Repository: Rust-SDL2/rust-sdl2 (language: rust)

Issue:
Added an ability to detect mouse events generated from touch events
Fix for https://github.com/Rust-SDL2/rust-sdl2/issues/1265


Discussion / hints:
I think it should be a method and not a variable inside the enum. This is something you can "generate" from the struct itself, so it's more appropriate to use a method `is_touch()`. Also, it's a breaking change since we would add a variable to quite a lot of variants, which I'm not really a fan of.
I see the problem in the fact that is_touch has some meaning only for few enum variants (obviously which are related to mouse events), but it will be defined for the whole enum.

Fix patch:
diff --git a/.github/workflows/CI.yml b/.github/workflows/CI.yml
index 908ed13927..2cce50a3a7 100644
--- a/.github/workflows/CI.yml
+++ b/.github/workflows/CI.yml
@@ -58,7 +58,7 @@ jobs:
 
   build-linux:
     name: build linux pkg-config
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-24.04
     steps:
       - uses: actions/checkout@v2
       - name: Install dependencies
diff --git a/Cargo.toml b/Cargo.toml
index e9e8ce9a44..1e0d26b6b8 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -31,9 +31,9 @@ optional = true
 
 [dev-dependencies]
 rand = "0.7"
-wgpu = { version = "0.19", features = ["spirv"] }
+wgpu = { version = "0.20", features = ["spirv"] }
 pollster = "0.2.4"
-env_logger = "0.9.0"
+env_logger = "0.11.0"
 
 [dependencies.raw-window-handle]
 version = "0.6.0"
diff --git a/examples/raw-window-handle-with-wgpu/main.rs b/examples/raw-window-handle-with-wgpu/main.rs
index a14598da40..b5038449a6 100644
--- a/examples/raw-window-handle-with-wgpu/main.rs
+++ b/examples/raw-window-handle-with-wgpu/main.rs
@@ -30,7 +30,9 @@ fn main() -> Result<(), String> {
         ..Default::default()
     });
     let surface = unsafe {
-        match instance.create_surface_unsafe(wgpu::SurfaceTargetUnsafe::from_window(&window).unwrap()) {
+        match instance
+            .create_surface_unsafe(wgpu::SurfaceTargetUnsafe::from_window(&window).unwrap())
+        {
             Ok(s) => s,
             Err(e) => return Err(e.to_string()),
         }
diff --git a/sdl2-sys/Cargo.toml b/sdl2-sys/Cargo.toml
index 2b8e5a7859..4e776e9350 100644
--- a/sdl2-sys/Cargo.toml
+++ b/sdl2-sys/Cargo.toml
@@ -20,7 +20,7 @@ path = "src/lib.rs"
 libc = "^0.2"
 
 [build-dependencies.bindgen]
-version = "^0.53"
+version = "^0.69"
 optional = true
 
 [build-dependencies.pkg-config]
diff --git a/sdl2-sys/build.rs b/sdl2-sys/build.rs
index 6cd2ef2a75..aee3f1a045 100644
--- a/sdl2-sys/build.rs
+++ b/sdl2-sys/build.rs
@@ -756,11 +756,11 @@ fn generate_bindings(target: &str, host: &str, headers_paths: &[String]) {
 
     let bindings = bindings
         .header("wrapper.h")
-        .blacklist_type("FP_NAN")
-        .blacklist_type("FP_INFINITE")
-        .blacklist_type("FP_ZERO")
-        .blacklist_type("FP_SUBNORMAL")
-        .blacklist_type("FP_NORMAL")
+        .blocklist_item("FP_NAN")
+        .blocklist_item("FP_INFINITE")
+        .blocklist_item("FP_ZERO")
+        .blocklist_item("FP_SUBNORMAL")
+        .blocklist_item("FP_NORMAL")
         .derive_debug(false)
         .generate()
         .expect("Unable to generate bindings!");
@@ -774,16 +774,16 @@ fn generate_bindings(target: &str, host: &str, headers_paths: &[String]) {
     if cfg!(feature = "image") {
         let image_bindings = image_bindings
             .header("wrapper_image.h")
-            .blacklist_type("FP_NAN")
-            .blacklist_type("FP_INFINITE")
-            .blacklist_type("FP_ZERO")
-            .blacklist_type("FP_SUBNORMAL")
-            .blacklist_type("FP_NORMAL")
-            .whitelist_type("IMG.*")
-            .whitelist_function("IMG.*")
-            .whitelist_var("IMG.*")
-            .blacklist_type("SDL_.*")
-            .blacklist_type("_IO.*|FILE")
+            .blocklist_item("FP_NAN")
+            .blocklist_item("FP_INFINITE")
+            .blocklist_item("FP_ZERO")
+            .blocklist_item("FP_SUBNORMAL")
+            .blocklist_item("FP_NORMAL")
+            .allowlist_type("IMG.*")
+            .allowlist_function("IMG.*")
+            .allowlist_var("IMG.*")
+            .blocklist_type("SDL_.*")
+            .blocklist_type("_IO.*|FILE")
             .generate()
             .expect("Unable to generate image_bindings!");
 
@@ -797,16 +797,16 @@ fn generate_bindings(target: &str, host: &str, headers_paths: &[String]) {
     if cfg!(feature = "ttf") {
         let ttf_bindings = ttf_bindings
             .header("wrapper_ttf.h")
-            .blacklist_type("FP_NAN")
-            .blacklist_type("FP_INFINITE")
-            .blacklist_type("FP_ZERO")
-            .blacklist_type("FP_SUBNORMAL")
-            .blacklist_type("FP_NORMAL")
-            .whitelist_type("TTF.*")
-            .whitelist_function("TTF.*")
-            .whitelist_var("TTF.*")
-            .blacklist_type("SDL_.*")
-            .blacklist_type("_IO.*|FILE")
+            .blocklist_item("FP_NAN")
+            .blocklist_item("FP_INFINITE")
+            .blocklist_item("FP_ZERO")
+            .blocklist_item("FP_SUBNORMAL")
+            .blocklist_item("FP_NORMAL")
+            .allowlist_type("TTF.*")
+            .allowlist_function("TTF.*")
+            .allowlist_var("TTF.*")
+            .blocklist_type("SDL_.*")
+            .blocklist_type("_IO.*|FILE")
             .generate()
             .expect("Unable to generate ttf_bindings!");
 
@@ -820,19 +820,19 @@ fn generate_bindings(target: &str, host: &str, headers_paths: &[String]) {
     if cfg!(feature = "mixer") {
         let mixer_bindings = mixer_bindings
             .header("wrapper_mixer.h")
-            .blacklist_type("FP_NAN")
-            .blacklist_type("FP_INFINITE")
-            .blacklist_type("FP_ZERO")
-            .blacklist_type("FP_SUBNORMAL")
-            .blacklist_type("FP_NORMAL")
-            .whitelist_type("MIX.*")
-            .whitelist_type("Mix.*")
-            .whitelist_type("MUS.*")
-            .whitelist_function("Mix.*")
-            .whitelist_var("MIX.*")
-            .whitelist_var("MUS.*")
-            .blacklist_type("SDL_.*")
-            .blacklist_type("_IO.*|FILE")
+            .blocklist_item("FP_NAN")
+            .blocklist_item("FP_INFINITE")
+            .blocklist_item("FP_ZERO")
+            .blocklist_item("FP_SUBNORMAL")
+            .blocklist_item("FP_NORMAL")
+            .allowlist_type("MIX.*")
+            .allowlist_type("Mix.*")
+            .allowlist_type("MUS.*")
+            .allowlist_function("Mix.*")
+            .allowlist_var("MIX.*")
+            .allowlist_var("MUS.*")
+            .blocklist_type("SDL_.*")
+            .blocklist_type("_IO.*|FILE")
             .generate()
             .expect("Unable to generate mixer_bindings!");
 
@@ -846,15 +846,15 @@ fn generate_bindings(target: &str, host: &str, headers_paths: &[String]) {
     if cfg!(feature = "gfx") {
         let gfx_framerate_bindings = gfx_framerate_bindings
             .header("wrapper_gfx_framerate.h")
-            .blacklist_type("FP_NAN")
-            .blacklist_type("FP_INFINITE")
-            .blacklist_type("FP_ZERO")
-            .blacklist_type("FP_SUBNORMAL")
-            .blacklist_type("FP_NORMAL")
-            .whitelist_type("FPS.*")
-            .whitelist_function("SDL_.*rame.*")
-            .whitelist_var("FPS.*")
-            .blacklist_type("_IO.*|FILE")
+            .blocklist_item("FP_NAN")
+            .blocklist_item("FP_INFINITE")
+            .blocklist_item("FP_ZERO")
+            .blocklist_item("FP_SUBNORMAL")
+            .blocklist_item("FP_NORMAL")
+            .allowlist_type("FPS.*")
+            .allowlist_function("SDL_.*rame.*")
+            .allowlist_var("FPS.*")
+            .blocklist_type("_IO.*|FILE")
             .generate()
             .expect("Unable to generate gfx_framerate_bindings!");
 
@@ -866,31 +866,31 @@ fn generate_bindings(target: &str, host: &str, headers_paths: &[String]) {
 
         let gfx_primitives_bindings = gfx_primitives_bindings
             .header("wrapper_gfx_primitives.h")
-            .blacklist_type("FP_NAN")
-            .blacklist_type("FP_INFINITE")
-            .blacklist_type("FP_ZERO")
-            .blacklist_type("FP_SUBNORMAL")
-            .blacklist_type("FP_NORMAL")
-            .blacklist_type("SDL_.*")
-            .whitelist_function("pixel.*")
-            .whitelist_function("rectangle.*")
-            .whitelist_function("rounded.*")
-            .whitelist_function("box.*")
-            .whitelist_function(".*line(Color|RGBA).*")
-            .whitelist_function("thick.*")
-            .whitelist_function(".*circle.*")
-            .whitelist_function("arc.*")
-            .whitelist_function("filled.*")
-            .whitelist_function(".*ellipse.*")
-            .whitelist_function("pie.*")
-            .whitelist_function(".*trigon.*")
-            .whitelist_function(".*polygon.*")
-            .whitelist_function("textured.*")
-            .whitelist_function("bezier.*")
-            .whitelist_function("character.*")
-            .whitelist_function("string.*")
-            .whitelist_function("gfx.*")
-            .blacklist_type("_IO.*|FILE")
+            .blocklist_item("FP_NAN")
+            .blocklist_item("FP_INFINITE")
+            .blocklist_item("FP_ZERO")
+            .blocklist_item("FP_SUBNORMAL")
+            .blocklist_item("FP_NORMAL")
+            .blocklist_type("SDL_.*")
+            .allowlist_function("pixel.*")
+            .allowlist_function("rectangle.*")
+            .allowlist_function("rounded.*")
+            .allowlist_function("box.*")
+            .allowlist_function(".*line(Color|RGBA).*")
+            .allowlist_function("thick.*")
+            .allowlist_function(".*circle.*")
+            .allowlist_function("arc.*")
+            .allowlist_function("filled.*")
+            .allowlist_function(".*ellipse.*")
+            .allowlist_function("pie.*")
+            .allowlist_function(".*trigon.*")
+            .allowlist_function(".*polygon.*")
+            .allowlist_function("textured.*")
+            .allowlist_function("bezier.*")
+            .allowlist_function("character.*")
+            .allowlist_function("string.*")
+            .allowlist_function("gfx.*")
+            .blocklist_type("_IO.*|FILE")
             .generate()
             .expect("Unable to generate gfx_primitives_bindings!");
 
@@ -902,13 +902,13 @@ fn generate_bindings(target: &str, host: &str, headers_paths: &[String]) {
 
         let gfx_imagefilter_bindings = gfx_imagefilter_bindings
             .header("wrapper_gfx_imagefilter.h")
-            .whitelist_function("SDL_image.*")
-            .blacklist_type("FP_NAN")
-            .blacklist_type("FP_INFINITE")
-            .blacklist_type("FP_ZERO")
-            .blacklist_type("FP_SUBNORMAL")
-            .blacklist_type("FP_NORMAL")
-            .blacklist_type("_IO.*|FILE")
+            .allowlist_function("SDL_image.*")
+            .blocklist_item("FP_NAN")
+            .blocklist_item("FP_INFINITE")
+            .blocklist_item("FP_ZERO")
+            .blocklist_item("FP_SUBNORMAL")
+            .blocklist_item("FP_NORMAL")
+            .blocklist_type("_IO.*|FILE")
             .generate()
             .expect("Unable to generate gfx_imagefilter_bindings!");
 
@@ -920,17 +920,17 @@ fn generate_bindings(target: &str, host: &str, headers_paths: &[String]) {
 
         let gfx_rotozoom_bindings = gfx_rotozoom_bindings
             .header("wrapper_gfx_rotozoom.h")
-            .blacklist_type("SDL_.*")
-            .whitelist_function("rotozoom.*")
-            .whitelist_function("zoom.*")
-            .whitelist_function("shrink.*")
-            .whitelist_function("rotate.*")
-            .blacklist_type("FP_NAN")
-            .blacklist_type("FP_INFINITE")
-            .blacklist_type("FP_ZERO")
-            .blacklist_type("FP_SUBNORMAL")
-            .blacklist_type("FP_NORMAL")
-            .blacklist_type("_IO.*|FILE")
+            .blocklist_type("SDL_.*")
+            .allowlist_function("rotozoom.*")
+            .allowlist_function("zoom.*")
+            .allowlist_function("shrink.*")
+            .allowlist_function("rotate.*")
+            .blocklist_item("FP_NAN")
+            .blocklist_item("FP_INFINITE")
+            .blocklist_item("FP_ZERO")
+            .blocklist_item("FP_SUBNORMAL")
+            .blocklist_item("FP_NORMAL")
+            .blocklist_type("_IO.*|FILE")
             .generate()
             .expect("Unable to generate gfx_rotozoom_bindings!");
 
diff --git a/sdl2-sys/sdl_bindings.rs b/sdl2-sys/sdl_bindings.rs
index b2bc6ca8ea..c04ce6e54c 100644
--- a/sdl2-sys/sdl_bindings.rs
+++ b/sdl2-sys/sdl_bindings.rs
@@ -1,5 +1,8 @@
-/* automatically generated by rust-bindgen */
+/* automatically generated by rust-bindgen 0.69.4 */
 
+#[derive(PartialEq, Copy, Clone, Hash, Debug, Default)]
+#[repr(transparent)]
+pub struct __BindgenFloat16(pub u16);
 pub const __LINUX__: u32 = 1;
 pub const HAVE_STDARG_H: u32 = 1;
 pub const HAVE_STDDEF_H: u32 = 1;
@@ -15,7 +18,6 @@ pub const SDL_THREADS_DISABLED: u32 = 1;
 pub const SDL_TIMERS_DISABLED: u32 = 1;
 pub const SDL_VIDEO_DRIVER_DUMMY: u32 = 1;
 pub const SDL_FILESYSTEM_DUMMY: u32 = 1;
-pub const __GNUC_VA_LIST: u32 = 1;
 pub const _STDINT_H: u32 = 1;
 pub const _FEATURES_H: u32 = 1;
 pub const _DEFAULT_SOURCE: u32 = 1;
@@ -42,6 +44,7 @@ pub const __USE_ATFILE: u32 = 1;
 pub const __USE_FORTIFY_LEVEL: u32 = 0;
 pub const __GLIBC_USE_DEPRECATED_GETS: u32 = 0;
 pub const __GLIBC_USE_DEPRECATED_SCANF: u32 = 0;
+pub const __GLIBC_USE_C2X_STRTOL: u32 = 0;
 pub const _STDC_PREDEF_H: u32 = 1;
 pub const __STDC_IEC_559__: u32 = 1;
 pub const __STDC_IEC_60559_BFP__: u32 = 201404;
@@ -50,7 +53,7 @@ pub const __STDC_IEC_60559_COMPLEX__: u32 = 201404;
 pub const __STDC_ISO_10646__: u32 = 201706;
 pub const __GNU_LIBRARY__: u32 = 6;
 pub const __GLIBC__: u32 = 2;
-pub const __GLIBC_MINOR__: u32 = 35;
+pub const __GLIBC_MINOR__: u32 = 39;
 pub const _SYS_CDEFS_H: u32 = 1;
 pub const __glibc_c99_flexarr_available: u32 = 1;
 pub const __LDOUBLE_REDIRECTS_TO_FLOAT128_ABI: u32 = 0;
@@ -74,6 +77,7 @@ pub const _BITS_TIME64_H: u32 = 1;
 pub const _BITS_WCHAR_H: u32 = 1;
 pub const _BITS_STDINT_INTN_H: u32 = 1;
 pub const _BITS_STDINT_UINTN_H: u32 = 1;
+pub const _BITS_STDINT_LEAST_H: u32 = 1;
 pub const INT8_MIN: i32 = -128;
 pub const INT16_MIN: i32 = -32768;
 pub const INT32_MIN: i32 = -2147483648;
@@ -111,14 +115,15 @@ pub const SIG_ATOMIC_MAX: u32 = 2147483647;
 pub const SIZE_MAX: i32 = -1;
 pub const WINT_MIN: u32 = 0;
 pub const WINT_MAX: u32 = 4294967295;
-pub const SDL_PRIs64: &'static [u8; 3usize] = b"ld\0";
-pub const SDL_PRIu64: &'static [u8; 3usize] = b"lu\0";
-pub const SDL_PRIx64: &'static [u8; 3usize] = b"lx\0";
-pub const SDL_PRIX64: &'static [u8; 3usize] = b"lX\0";
-pub const SDL_PRIs32: &'static [u8; 2usize] = b"d\0";
-pub const SDL_PRIu32: &'static [u8; 2usize] = b"u\0";
-pub const SDL_PRIx32: &'static [u8; 2usize] = b"x\0";
-pub const SDL_PRIX32: &'static [u8; 2usize] = b"X\0";
+pub const SDL_SIZE_MAX: i32 = -1;
+pub const SDL_PRIs64: &[u8; 3] = b"ld\0";
+pub const SDL_PRIu64: &[u8; 3] = b"lu\0";
+pub const SDL_PRIx64: &[u8; 3] = b"lx\0";
+pub const SDL_PRIX64: &[u8; 3] = b"lX\0";
+pub const SDL_PRIs32: &[u8; 2] = b"d\0";
+pub const SDL_PRIu32: &[u8; 2] = b"u\0";
+pub const SDL_PRIx32: &[u8; 2] = b"x\0";
+pub const SDL_PRIX32: &[u8; 2] = b"X\0";
 pub const M_PI: f64 = 3.141592653589793;
 pub const SDL_ASSERT_LEVEL: u32 = 2;
 pub const SDL_NULL_WHILE_LOOP_CONDITION: u32 = 0;
@@ -139,6 +144,7 @@ pub const BYTE_ORDER: u32 = 1234;
 pub const _BITS_BYTESWAP_H: u32 = 1;
 pub const _BITS_UINTN_IDENTITY_H: u32 = 1;
 pub const SDL_BYTEORDER: u32 = 1234;
+pub const SDL_FLOATWORDORDER: u32 = 1234;
 pub const SDL_MUTEX_TIMEDOUT: u32 = 1;
 pub const SDL_RWOPS_UNKNOWN: u32 = 0;
 pub const SDL_RWOPS_WINFILE: u32 = 1;
@@ -286,6 +292,7 @@ pub const SDL_BUTTON_RIGHT: u32 = 3;
 pub const SDL_BUTTON_X1: u32 = 4;
 pub const SDL_BUTTON_X2: u32 = 5;
 pub const SDL_IPHONE_MAX_GFORCE: f64 = 5.0;
+pub const SDL_VIRTUAL_JOYSTICK_DESC_VERSION: u32 = 1;
 pub const SDL_JOYSTICK_AXIS_MAX: u32 = 32767;
 pub const SDL_JOYSTICK_AXIS_MIN: i32 = -32768;
 pub const SDL_HAT_CENTERED: u32 = 0;
@@ -327,206 +334,222 @@ pub const SDL_HAPTIC_CARTESIAN: u32 = 1;
 pub const SDL_HAPTIC_SPHERICAL: u32 = 2;
 pub const SDL_HAPTIC_STEERING_AXIS: u32 = 3;
 pub const SDL_HAPTIC_INFINITY: u32 = 4294967295;
-pub const SDL_HINT_ACCELEROMETER_AS_JOYSTICK: &'static [u8; 30usize] =
-    b"SDL_ACCELEROMETER_AS_JOYSTICK\0";
-pub const SDL_HINT_ALLOW_ALT_TAB_WHILE_GRABBED: &'static [u8; 32usize] =
-    b"SDL_ALLOW_ALT_TAB_WHILE_GRABBED\0";
-pub const SDL_HINT_ALLOW_TOPMOST: &'static [u8; 18usize] = b"SDL_ALLOW_TOPMOST\0";
-pub const SDL_HINT_ANDROID_APK_EXPANSION_MAIN_FILE_VERSION: &'static [u8; 44usize] =
+pub const SDL_HINT_ACCELEROMETER_AS_JOYSTICK: &[u8; 30] = b"SDL_ACCELEROMETER_AS_JOYSTICK\0";
+pub const SDL_HINT_ALLOW_ALT_TAB_WHILE_GRABBED: &[u8; 32] = b"SDL_ALLOW_ALT_TAB_WHILE_GRABBED\0";
+pub const SDL_HINT_ALLOW_TOPMOST: &[u8; 18] = b"SDL_ALLOW_TOPMOST\0";
+pub const SDL_HINT_ANDROID_APK_EXPANSION_MAIN_FILE_VERSION: &[u8; 44] =
     b"SDL_ANDROID_APK_EXPANSION_MAIN_FILE_VERSION\0";
-pub const SDL_HINT_ANDROID_APK_EXPANSION_PATCH_FILE_VERSION: &'static [u8; 45usize] =
+pub const SDL_HINT_ANDROID_APK_EXPANSION_PATCH_FILE_VERSION: &[u8; 45] =
     b"SDL_ANDROID_APK_EXPANSION_PATCH_FILE_VERSION\0";
-pub const SDL_HINT_ANDROID_BLOCK_ON_PAUSE: &'static [u8; 27usize] = b"SDL_ANDROID_BLOCK_ON_PAUSE\0";
-pub const SDL_HINT_ANDROID_BLOCK_ON_PAUSE_PAUSEAUDIO: &'static [u8; 38usize] =
+pub const SDL_HINT_ANDROID_BLOCK_ON_PAUSE: &[u8; 27] = b"SDL_ANDROID_BLOCK_ON_PAUSE\0";
+pub const SDL_HINT_ANDROID_BLOCK_ON_PAUSE_PAUSEAUDIO: &[u8; 38] =
     b"SDL_ANDROID_BLOCK_ON_PAUSE_PAUSEAUDIO\0";
-pub const SDL_HINT_ANDROID_TRAP_BACK_BUTTON: &'static [u8; 29usize] =
-    b"SDL_ANDROID_TRAP_BACK_BUTTON\0";
-pub const SDL_HINT_APP_NAME: &'static [u8; 13usize] = b"SDL_APP_NAME\0";
-pub const SDL_HINT_APPLE_TV_CONTROLLER_UI_EVENTS: &'static [u8; 34usize] =
+pub const SDL_HINT_ANDROID_TRAP_BACK_BUTTON: &[u8; 29] = b"SDL_ANDROID_TRAP_BACK_BUTTON\0";
+pub const SDL_HINT_APP_NAME: &[u8; 13] = b"SDL_APP_NAME\0";
+pub const SDL_HINT_APPLE_TV_CONTROLLER_UI_EVENTS: &[u8; 34] =
     b"SDL_APPLE_TV_CONTROLLER_UI_EVENTS\0";
-pub const SDL_HINT_APPLE_TV_REMOTE_ALLOW_ROTATION: &'static [u8; 35usize] =
+pub const SDL_HINT_APPLE_TV_REMOTE_ALLOW_ROTATION: &[u8; 35] =
     b"SDL_APPLE_TV_REMOTE_ALLOW_ROTATION\0";
-pub const SDL_HINT_AUDIO_CATEGORY: &'static [u8; 19usize] = b"SDL_AUDIO_CATEGORY\0";
-pub const SDL_HINT_AUDIO_DEVICE_APP_NAME: &'static [u8; 26usize] = b"SDL_AUDIO_DEVICE_APP_NAME\0";
-pub const SDL_HINT_AUDIO_DEVICE_STREAM_NAME: &'static [u8; 29usize] =
-    b"SDL_AUDIO_DEVICE_STREAM_NAME\0";
-pub const SDL_HINT_AUDIO_DEVICE_STREAM_ROLE: &'static [u8; 29usize] =
-    b"SDL_AUDIO_DEVICE_STREAM_ROLE\0";
-pub const SDL_HINT_AUDIO_RESAMPLING_MODE: &'static [u8; 26usize] = b"SDL_AUDIO_RESAMPLING_MODE\0";
-pub const SDL_HINT_AUTO_UPDATE_JOYSTICKS: &'static [u8; 26usize] = b"SDL_AUTO_UPDATE_JOYSTICKS\0";
-pub const SDL_HINT_AUTO_UPDATE_SENSORS: &'static [u8; 24usize] = b"SDL_AUTO_UPDATE_SENSORS\0";
-pub const SDL_HINT_BMP_SAVE_LEGACY_FORMAT: &'static [u8; 27usize] = b"SDL_BMP_SAVE_LEGACY_FORMAT\0";
-pub const SDL_HINT_DISPLAY_USABLE_BOUNDS: &'static [u8; 26usize] = b"SDL_DISPLAY_USABLE_BOUNDS\0";
-pub const SDL_HINT_EMSCRIPTEN_ASYNCIFY: &'static [u8; 24usize] = b"SDL_EMSCRIPTEN_ASYNCIFY\0";
-pub const SDL_HINT_EMSCRIPTEN_KEYBOARD_ELEMENT: &'static [u8; 32usize] =
-    b"SDL_EMSCRIPTEN_KEYBOARD_ELEMENT\0";
-pub const SDL_HINT_ENABLE_STEAM_CONTROLLERS: &'static [u8; 29usize] =
-    b"SDL_ENABLE_STEAM_CONTROLLERS\0";
-pub const SDL_HINT_EVENT_LOGGING: &'static [u8; 18usize] = b"SDL_EVENT_LOGGING\0";
-pub const SDL_HINT_FRAMEBUFFER_ACCELERATION: &'static [u8; 29usize] =
-    b"SDL_FRAMEBUFFER_ACCELERATION\0";
-pub const SDL_HINT_GAMECONTROLLERCONFIG: &'static [u8; 25usize] = b"SDL_GAMECONTROLLERCONFIG\0";
-pub const SDL_HINT_GAMECONTROLLERCONFIG_FILE: &'static [u8; 30usize] =
-    b"SDL_GAMECONTROLLERCONFIG_FILE\0";
-pub const SDL_HINT_GAMECONTROLLERTYPE: &'static [u8; 23usize] = b"SDL_GAMECONTROLLERTYPE\0";
-pub const SDL_HINT_GAMECONTROLLER_IGNORE_DEVICES: &'static [u8; 34usize] =
+pub const SDL_HINT_AUDIO_CATEGORY: &[u8; 19] = b"SDL_AUDIO_CATEGORY\0";
+pub const SDL_HINT_AUDIO_DEVICE_APP_NAME: &[u8; 26] = b"SDL_AUDIO_DEVICE_APP_NAME\0";
+pub const SDL_HINT_AUDIO_DEVICE_STREAM_NAME: &[u8; 29] = b"SDL_AUDIO_DEVICE_STREAM_NAME\0";
+pub const SDL_HINT_AUDIO_DEVICE_STREAM_ROLE: &[u8; 29] = b"SDL_AUDIO_DEVICE_STREAM_ROLE\0";
+pub const SDL_HINT_AUDIO_RESAMPLING_MODE: &[u8; 26] = b"SDL_AUDIO_RESAMPLING_MODE\0";
+pub const SDL_HINT_AUTO_UPDATE_JOYSTICKS: &[u8; 26] = b"SDL_AUTO_UPDATE_JOYSTICKS\0";
+pub const SDL_HINT_AUTO_UPDATE_SENSORS: &[u8; 24] = b"SDL_AUTO_UPDATE_SENSORS\0";
+pub const SDL_HINT_BMP_SAVE_LEGACY_FORMAT: &[u8; 27] = b"SDL_BMP_SAVE_LEGACY_FORMAT\0";
+pub const SDL_HINT_DISPLAY_USABLE_BOUNDS: &[u8; 26] = b"SDL_DISPLAY_USABLE_BOUNDS\0";
+pub const SDL_HINT_EMSCRIPTEN_ASYNCIFY: &[u8; 24] = b"SDL_EMSCRIPTEN_ASYNCIFY\0";
+pub const SDL_HINT_EMSCRIPTEN_KEYBOARD_ELEMENT: &[u8; 32] = b"SDL_EMSCRIPTEN_KEYBOARD_ELEMENT\0";
+pub const SDL_HINT_ENABLE_STEAM_CONTROLLERS: &[u8; 29] = b"SDL_ENABLE_STEAM_CONTROLLERS\0";
+pub const SDL_HINT_EVENT_LOGGING: &[u8; 18] = b"SDL_EVENT_LOGGING\0";
+pub const SDL_HINT_FORCE_RAISEWINDOW: &[u8; 27] = b"SDL_HINT_FORCE_RAISEWINDOW\0";
+pub const SDL_HINT_FRAMEBUFFER_ACCELERATION: &[u8; 29] = b"SDL_FRAMEBUFFER_ACCELERATION\0";
+pub const SDL_HINT_GAMECONTROLLERCONFIG: &[u8; 25] = b"SDL_GAMECONTROLLERCONFIG\0";
+pub const SDL_HINT_GAMECONTROLLERCONFIG_FILE: &[u8; 30] = b"SDL_GAMECONTROLLERCONFIG_FILE\0";
+pub const SDL_HINT_GAMECONTROLLERTYPE: &[u8; 23] = b"SDL_GAMECONTROLLERTYPE\0";
+pub const SDL_HINT_GAMECONTROLLER_IGNORE_DEVICES: &[u8; 34] =
     b"SDL_GAMECONTROLLER_IGNORE_DEVICES\0";
-pub const SDL_HINT_GAMECONTROLLER_IGNORE_DEVICES_EXCEPT: &'static [u8; 41usize] =
+pub const SDL_HINT_GAMECONTROLLER_IGNORE_DEVICES_EXCEPT: &[u8; 41] =
     b"SDL_GAMECONTROLLER_IGNORE_DEVICES_EXCEPT\0";
-pub const SDL_HINT_GAMECONTROLLER_USE_BUTTON_LABELS: &'static [u8; 37usize] =
+pub const SDL_HINT_GAMECONTROLLER_USE_BUTTON_LABELS: &[u8; 37] =
     b"SDL_GAMECONTROLLER_USE_BUTTON_LABELS\0";
-pub const SDL_HINT_GRAB_KEYBOARD: &'static [u8; 18usize] = b"SDL_GRAB_KEYBOARD\0";
-pub const SDL_HINT_IDLE_TIMER_DISABLED: &'static [u8; 28usize] = b"SDL_IOS_IDLE_TIMER_DISABLED\0";
-pub const SDL_HINT_IME_INTERNAL_EDITING: &'static [u8; 25usize] = b"SDL_IME_INTERNAL_EDITING\0";
-pub const SDL_HINT_IME_SHOW_UI: &'static [u8; 16usize] = b"SDL_IME_SHOW_UI\0";
-pub const SDL_HINT_IOS_HIDE_HOME_INDICATOR: &'static [u8; 28usize] =
-    b"SDL_IOS_HIDE_HOME_INDICATOR\0";
-pub const SDL_HINT_JOYSTICK_ALLOW_BACKGROUND_EVENTS: &'static [u8; 37usize] =
+pub const SDL_HINT_GRAB_KEYBOARD: &[u8; 18] = b"SDL_GRAB_KEYBOARD\0";
+pub const SDL_HINT_HIDAPI_IGNORE_DEVICES: &[u8; 26] = b"SDL_HIDAPI_IGNORE_DEVICES\0";
+pub const SDL_HINT_IDLE_TIMER_DISABLED: &[u8; 28] = b"SDL_IOS_IDLE_TIMER_DISABLED\0";
+pub const SDL_HINT_IME_INTERNAL_EDITING: &[u8; 25] = b"SDL_IME_INTERNAL_EDITING\0";
+pub const SDL_HINT_IME_SHOW_UI: &[u8; 16] = b"SDL_IME_SHOW_UI\0";
+pub const SDL_HINT_IME_SUPPORT_EXTENDED_TEXT: &[u8; 30] = b"SDL_IME_SUPPORT_EXTENDED_TEXT\0";
+pub const SDL_HINT_IOS_HIDE_HOME_INDICATOR: &[u8; 28] = b"SDL_IOS_HIDE_HOME_INDICATOR\0";
+pub const SDL_HINT_JOYSTICK_ALLOW_BACKGROUND_EVENTS: &[u8; 37] =
     b"SDL_JOYSTICK_ALLOW_BACKGROUND_EVENTS\0";
-pub const SDL_HINT_JOYSTICK_HIDAPI: &'static [u8; 20usize] = b"SDL_JOYSTICK_HIDAPI\0";
-pub const SDL_HINT_JOYSTICK_HIDAPI_GAMECUBE: &'static [u8; 29usize] =
-    b"SDL_JOYSTICK_HIDAPI_GAMECUBE\0";
-pub const SDL_HINT_JOYSTICK_HIDAPI_JOY_CONS: &'static [u8; 29usize] =
-    b"SDL_JOYSTICK_HIDAPI_JOY_CONS\0";
-pub const SDL_HINT_JOYSTICK_HIDAPI_LUNA: &'static [u8; 25usize] = b"SDL_JOYSTICK_HIDAPI_LUNA\0";
-pub const SDL_HINT_JOYSTICK_HIDAPI_PS4: &'static [u8; 24usize] = b"SDL_JOYSTICK_HIDAPI_PS4\0";
-pub const SDL_HINT_JOYSTICK_HIDAPI_PS4_RUMBLE: &'static [u8; 31usize] =
-    b"SDL_JOYSTICK_HIDAPI_PS4_RUMBLE\0";
-pub const SDL_HINT_JOYSTICK_HIDAPI_PS5: &'static [u8; 24usize] = b"SDL_JOYSTICK_HIDAPI_PS5\0";
-pub const SDL_HINT_JOYSTICK_HIDAPI_PS5_PLAYER_LED: &'static [u8; 35usize] =
+pub const SDL_HINT_JOYSTICK_HIDAPI: &[u8; 20] = b"SDL_JOYSTICK_HIDAPI\0";
+pub const SDL_HINT_JOYSTICK_HIDAPI_GAMECUBE: &[u8; 29] = b"SDL_JOYSTICK_HIDAPI_GAMECUBE\0";
+pub const SDL_HINT_JOYSTICK_GAMECUBE_RUMBLE_BRAKE: &[u8; 35] =
+    b"SDL_JOYSTICK_GAMECUBE_RUMBLE_BRAKE\0";
+pub const SDL_HINT_JOYSTICK_HIDAPI_JOY_CONS: &[u8; 29] = b"SDL_JOYSTICK_HIDAPI_JOY_CONS\0";
+pub const SDL_HINT_JOYSTICK_HIDAPI_COMBINE_JOY_CONS: &[u8; 37] =
+    b"SDL_JOYSTICK_HIDAPI_COMBINE_JOY_CONS\0";
+pub const SDL_HINT_JOYSTICK_HIDAPI_VERTICAL_JOY_CONS: &[u8; 38] =
+    b"SDL_JOYSTICK_HIDAPI_VERTICAL_JOY_CONS\0";
+pub const SDL_HINT_JOYSTICK_HIDAPI_LUNA: &[u8; 25] = b"SDL_JOYSTICK_HIDAPI_LUNA\0";
+pub const SDL_HINT_JOYSTICK_HIDAPI_NINTENDO_CLASSIC: &[u8; 37] =
+    b"SDL_JOYSTICK_HIDAPI_NINTENDO_CLASSIC\0";
+pub const SDL_HINT_JOYSTICK_HIDAPI_SHIELD: &[u8; 27] = b"SDL_JOYSTICK_HIDAPI_SHIELD\0";
+pub const SDL_HINT_JOYSTICK_HIDAPI_PS3: &[u8; 24] = b"SDL_JOYSTICK_HIDAPI_PS3\0";
+pub const SDL_HINT_JOYSTICK_HIDAPI_PS4: &[u8; 24] = b"SDL_JOYSTICK_HIDAPI_PS4\0";
+pub const SDL_HINT_JOYSTICK_HIDAPI_PS4_RUMBLE: &[u8; 31] = b"SDL_JOYSTICK_HIDAPI_PS4_RUMBLE\0";
+pub const SDL_HINT_JOYSTICK_HIDAPI_PS5: &[u8; 24] = b"SDL_JOYSTICK_HIDAPI_PS5\0";
+pub const SDL_HINT_JOYSTICK_HIDAPI_PS5_PLAYER_LED: &[u8; 35] =
     b"SDL_JOYSTICK_HIDAPI_PS5_PLAYER_LED\0";
-pub const SDL_HINT_JOYSTICK_HIDAPI_PS5_RUMBLE: &'static [u8; 31usize] =
-    b"SDL_JOYSTICK_HIDAPI_PS5_RUMBLE\0";
-pub const SDL_HINT_JOYSTICK_HIDAPI_STADIA: &'static [u8; 27usize] = b"SDL_JOYSTICK_HIDAPI_STADIA\0";
-pub const SDL_HINT_JOYSTICK_HIDAPI_STEAM: &'static [u8; 26usize] = b"SDL_JOYSTICK_HIDAPI_STEAM\0";
-pub const SDL_HINT_JOYSTICK_HIDAPI_SWITCH: &'static [u8; 27usize] = b"SDL_JOYSTICK_HIDAPI_SWITCH\0";
-pub const SDL_HINT_JOYSTICK_HIDAPI_SWITCH_HOME_LED: &'static [u8; 36usize] =
+pub const SDL_HINT_JOYSTICK_HIDAPI_PS5_RUMBLE: &[u8; 31] = b"SDL_JOYSTICK_HIDAPI_PS5_RUMBLE\0";
+pub const SDL_HINT_JOYSTICK_HIDAPI_STADIA: &[u8; 27] = b"SDL_JOYSTICK_HIDAPI_STADIA\0";
+pub const SDL_HINT_JOYSTICK_HIDAPI_STEAM: &[u8; 26] = b"SDL_JOYSTICK_HIDAPI_STEAM\0";
+pub const SDL_HINT_JOYSTICK_HIDAPI_SWITCH: &[u8; 27] = b"SDL_JOYSTICK_HIDAPI_SWITCH\0";
+pub const SDL_HINT_JOYSTICK_HIDAPI_SWITCH_HOME_LED: &[u8; 36] =
     b"SDL_JOYSTICK_HIDAPI_SWITCH_HOME_LED\0";
-pub const SDL_HINT_JOYSTICK_HIDAPI_XBOX: &'static [u8; 25usize] = b"SDL_JOYSTICK_HIDAPI_XBOX\0";
-pub const SDL_HINT_JOYSTICK_RAWINPUT: &'static [u8; 22usize] = b"SDL_JOYSTICK_RAWINPUT\0";
-pub const SDL_HINT_JOYSTICK_RAWINPUT_CORRELATE_XINPUT: &'static [u8; 39usize] =
+pub const SDL_HINT_JOYSTICK_HIDAPI_JOYCON_HOME_LED: &[u8; 36] =
+    b"SDL_JOYSTICK_HIDAPI_JOYCON_HOME_LED\0";
+pub const SDL_HINT_JOYSTICK_HIDAPI_SWITCH_PLAYER_LED: &[u8; 38] =
+    b"SDL_JOYSTICK_HIDAPI_SWITCH_PLAYER_LED\0";
+pub const SDL_HINT_JOYSTICK_HIDAPI_WII: &[u8; 24] = b"SDL_JOYSTICK_HIDAPI_WII\0";
+pub const SDL_HINT_JOYSTICK_HIDAPI_WII_PLAYER_LED: &[u8; 35] =
+    b"SDL_JOYSTICK_HIDAPI_WII_PLAYER_LED\0";
+pub const SDL_HINT_JOYSTICK_HIDAPI_XBOX: &[u8; 25] = b"SDL_JOYSTICK_HIDAPI_XBOX\0";
+pub const SDL_HINT_JOYSTICK_HIDAPI_XBOX_360: &[u8; 29] = b"SDL_JOYSTICK_HIDAPI_XBOX_360\0";
+pub const SDL_HINT_JOYSTICK_HIDAPI_XBOX_360_PLAYER_LED: &[u8; 40] =
+    b"SDL_JOYSTICK_HIDAPI_XBOX_360_PLAYER_LED\0";
+pub const SDL_HINT_JOYSTICK_HIDAPI_XBOX_360_WIRELESS: &[u8; 38] =
+    b"SDL_JOYSTICK_HIDAPI_XBOX_360_WIRELESS\0";
+pub const SDL_HINT_JOYSTICK_HIDAPI_XBOX_ONE: &[u8; 29] = b"SDL_JOYSTICK_HIDAPI_XBOX_ONE\0";
+pub const SDL_HINT_JOYSTICK_HIDAPI_XBOX_ONE_HOME_LED: &[u8; 38] =
+    b"SDL_JOYSTICK_HIDAPI_XBOX_ONE_HOME_LED\0";
+pub const SDL_HINT_JOYSTICK_RAWINPUT: &[u8; 22] = b"SDL_JOYSTICK_RAWINPUT\0";
+pub const SDL_HINT_JOYSTICK_RAWINPUT_CORRELATE_XINPUT: &[u8; 39] =
     b"SDL_JOYSTICK_RAWINPUT_CORRELATE_XINPUT\0";
-pub const SDL_HINT_JOYSTICK_THREAD: &'static [u8; 20usize] = b"SDL_JOYSTICK_THREAD\0";
-pub const SDL_HINT_KMSDRM_REQUIRE_DRM_MASTER: &'static [u8; 30usize] =
-    b"SDL_KMSDRM_REQUIRE_DRM_MASTER\0";
-pub const SDL_HINT_JOYSTICK_DEVICE: &'static [u8; 20usize] = b"SDL_JOYSTICK_DEVICE\0";
-pub const SDL_HINT_LINUX_JOYSTICK_CLASSIC: &'static [u8; 27usize] = b"SDL_LINUX_JOYSTICK_CLASSIC\0";
-pub const SDL_HINT_LINUX_JOYSTICK_DEADZONES: &'static [u8; 29usize] =
-    b"SDL_LINUX_JOYSTICK_DEADZONES\0";
-pub const SDL_HINT_MAC_BACKGROUND_APP: &'static [u8; 23usize] = b"SDL_MAC_BACKGROUND_APP\0";
-pub const SDL_HINT_MAC_CTRL_CLICK_EMULATE_RIGHT_CLICK: &'static [u8; 39usize] =
+pub const SDL_HINT_JOYSTICK_ROG_CHAKRAM: &[u8; 25] = b"SDL_JOYSTICK_ROG_CHAKRAM\0";
+pub const SDL_HINT_JOYSTICK_THREAD: &[u8; 20] = b"SDL_JOYSTICK_THREAD\0";
+pub const SDL_HINT_KMSDRM_REQUIRE_DRM_MASTER: &[u8; 30] = b"SDL_KMSDRM_REQUIRE_DRM_MASTER\0";
+pub const SDL_HINT_JOYSTICK_DEVICE: &[u8; 20] = b"SDL_JOYSTICK_DEVICE\0";
+pub const SDL_HINT_LINUX_DIGITAL_HATS: &[u8; 23] = b"SDL_LINUX_DIGITAL_HATS\0";
+pub const SDL_HINT_LINUX_HAT_DEADZONES: &[u8; 24] = b"SDL_LINUX_HAT_DEADZONES\0";
+pub const SDL_HINT_LINUX_JOYSTICK_CLASSIC: &[u8; 27] = b"SDL_LINUX_JOYSTICK_CLASSIC\0";
+pub const SDL_HINT_LINUX_JOYSTICK_DEADZONES: &[u8; 29] = b"SDL_LINUX_JOYSTICK_DEADZONES\0";
+pub const SDL_HINT_MAC_BACKGROUND_APP: &[u8; 23] = b"SDL_MAC_BACKGROUND_APP\0";
+pub const SDL_HINT_MAC_CTRL_CLICK_EMULATE_RIGHT_CLICK: &[u8; 39] =
     b"SDL_MAC_CTRL_CLICK_EMULATE_RIGHT_CLICK\0";
-pub const SDL_HINT_MOUSE_DOUBLE_CLICK_RADIUS: &'static [u8; 30usize] =
-    b"SDL_MOUSE_DOUBLE_CLICK_RADIUS\0";
-pub const SDL_HINT_MOUSE_DOUBLE_CLICK_TIME: &'static [u8; 28usize] =
-    b"SDL_MOUSE_DOUBLE_CLICK_TIME\0";
-pub const SDL_HINT_MOUSE_FOCUS_CLICKTHROUGH: &'static [u8; 29usize] =
-    b"SDL_MOUSE_FOCUS_CLICKTHROUGH\0";
-pub const SDL_HINT_MOUSE_NORMAL_SPEED_SCALE: &'static [u8; 29usize] =
-    b"SDL_MOUSE_NORMAL_SPEED_SCALE\0";
-pub const SDL_HINT_MOUSE_RELATIVE_MODE_WARP: &'static [u8; 29usize] =
-    b"SDL_MOUSE_RELATIVE_MODE_WARP\0";
-pub const SDL_HINT_MOUSE_RELATIVE_SCALING: &'static [u8; 27usize] = b"SDL_MOUSE_RELATIVE_SCALING\0";
-pub const SDL_HINT_MOUSE_RELATIVE_SPEED_SCALE: &'static [u8; 31usize] =
-    b"SDL_MOUSE_RELATIVE_SPEED_SCALE\0";
-pub const SDL_HINT_MOUSE_TOUCH_EVENTS: &'static [u8; 23usize] = b"SDL_MOUSE_TOUCH_EVENTS\0";
-pub const SDL_HINT_NO_SIGNAL_HANDLERS: &'static [u8; 23usize] = b"SDL_NO_SIGNAL_HANDLERS\0";
-pub const SDL_HINT_OPENGL_ES_DRIVER: &'static [u8; 21usize] = b"SDL_OPENGL_ES_DRIVER\0";
-pub const SDL_HINT_ORIENTATIONS: &'static [u8; 21usize] = b"SDL_IOS_ORIENTATIONS\0";
-pub const SDL_HINT_POLL_SENTINEL: &'static [u8; 18usize] = b"SDL_POLL_SENTINEL\0";
-pub const SDL_HINT_PREFERRED_LOCALES: &'static [u8; 22usize] = b"SDL_PREFERRED_LOCALES\0";
-pub const SDL_HINT_QTWAYLAND_CONTENT_ORIENTATION: &'static [u8; 34usize] =
+pub const SDL_HINT_MAC_OPENGL_ASYNC_DISPATCH: &[u8; 30] = b"SDL_MAC_OPENGL_ASYNC_DISPATCH\0";
+pub const SDL_HINT_MOUSE_DOUBLE_CLICK_RADIUS: &[u8; 30] = b"SDL_MOUSE_DOUBLE_CLICK_RADIUS\0";
+pub const SDL_HINT_MOUSE_DOUBLE_CLICK_TIME: &[u8; 28] = b"SDL_MOUSE_DOUBLE_CLICK_TIME\0";
+pub const SDL_HINT_MOUSE_FOCUS_CLICKTHROUGH: &[u8; 29] = b"SDL_MOUSE_FOCUS_CLICKTHROUGH\0";
+pub const SDL_HINT_MOUSE_NORMAL_SPEED_SCALE: &[u8; 29] = b"SDL_MOUSE_NORMAL_SPEED_SCALE\0";
+pub const SDL_HINT_MOUSE_RELATIVE_MODE_CENTER: &[u8; 31] = b"SDL_MOUSE_RELATIVE_MODE_CENTER\0";
+pub const SDL_HINT_MOUSE_RELATIVE_MODE_WARP: &[u8; 29] = b"SDL_MOUSE_RELATIVE_MODE_WARP\0";
+pub const SDL_HINT_MOUSE_RELATIVE_SCALING: &[u8; 27] = b"SDL_MOUSE_RELATIVE_SCALING\0";
+pub const SDL_HINT_MOUSE_RELATIVE_SPEED_SCALE: &[u8; 31] = b"SDL_MOUSE_RELATIVE_SPEED_SCALE\0";
+pub const SDL_HINT_MOUSE_RELATIVE_SYSTEM_SCALE: &[u8; 32] = b"SDL_MOUSE_RELATIVE_SYSTEM_SCALE\0";
+pub const SDL_HINT_MOUSE_RELATIVE_WARP_MOTION: &[u8; 31] = b"SDL_MOUSE_RELATIVE_WARP_MOTION\0";
+pub const SDL_HINT_MOUSE_TOUCH_EVENTS: &[u8; 23] = b"SDL_MOUSE_TOUCH_EVENTS\0";
+pub const SDL_HINT_MOUSE_AUTO_CAPTURE: &[u8; 23] = b"SDL_MOUSE_AUTO_CAPTURE\0";
+pub const SDL_HINT_NO_SIGNAL_HANDLERS: &[u8; 23] = b"SDL_NO_SIGNAL_HANDLERS\0";
+pub const SDL_HINT_OPENGL_ES_DRIVER: &[u8; 21] = b"SDL_OPENGL_ES_DRIVER\0";
+pub const SDL_HINT_ORIENTATIONS: &[u8; 21] = b"SDL_IOS_ORIENTATIONS\0";
+pub const SDL_HINT_POLL_SENTINEL: &[u8; 18] = b"SDL_POLL_SENTINEL\0";
+pub const SDL_HINT_PREFERRED_LOCALES: &[u8; 22] = b"SDL_PREFERRED_LOCALES\0";
+pub const SDL_HINT_QTWAYLAND_CONTENT_ORIENTATION: &[u8; 34] =
     b"SDL_QTWAYLAND_CONTENT_ORIENTATION\0";
-pub const SDL_HINT_QTWAYLAND_WINDOW_FLAGS: &'static [u8; 27usize] = b"SDL_QTWAYLAND_WINDOW_FLAGS\0";
-pub const SDL_HINT_RENDER_BATCHING: &'static [u8; 20usize] = b"SDL_RENDER_BATCHING\0";
-pub const SDL_HINT_RENDER_LINE_METHOD: &'static [u8; 23usize] = b"SDL_RENDER_LINE_METHOD\0";
-pub const SDL_HINT_RENDER_DIRECT3D11_DEBUG: &'static [u8; 28usize] =
-    b"SDL_RENDER_DIRECT3D11_DEBUG\0";
-pub const SDL_HINT_RENDER_DIRECT3D_THREADSAFE: &'static [u8; 31usize] =
-    b"SDL_RENDER_DIRECT3D_THREADSAFE\0";
-pub const SDL_HINT_RENDER_DRIVER: &'static [u8; 18usize] = b"SDL_RENDER_DRIVER\0";
-pub const SDL_HINT_RENDER_LOGICAL_SIZE_MODE: &'static [u8; 29usize] =
-    b"SDL_RENDER_LOGICAL_SIZE_MODE\0";
-pub const SDL_HINT_RENDER_OPENGL_SHADERS: &'static [u8; 26usize] = b"SDL_RENDER_OPENGL_SHADERS\0";
-pub const SDL_HINT_RENDER_SCALE_QUALITY: &'static [u8; 25usize] = b"SDL_RENDER_SCALE_QUALITY\0";
-pub const SDL_HINT_RENDER_VSYNC: &'static [u8; 17usize] = b"SDL_RENDER_VSYNC\0";
-pub const SDL_HINT_RETURN_KEY_HIDES_IME: &'static [u8; 25usize] = b"SDL_RETURN_KEY_HIDES_IME\0";
-pub const SDL_HINT_RPI_VIDEO_LAYER: &'static [u8; 20usize] = b"SDL_RPI_VIDEO_LAYER\0";
-pub const SDL_HINT_SCREENSAVER_INHIBIT_ACTIVITY_NAME: &'static [u8; 38usize] =
+pub const SDL_HINT_QTWAYLAND_WINDOW_FLAGS: &[u8; 27] = b"SDL_QTWAYLAND_WINDOW_FLAGS\0";
+pub const SDL_HINT_RENDER_BATCHING: &[u8; 20] = b"SDL_RENDER_BATCHING\0";
+pub const SDL_HINT_RENDER_LINE_METHOD: &[u8; 23] = b"SDL_RENDER_LINE_METHOD\0";
+pub const SDL_HINT_RENDER_DIRECT3D11_DEBUG: &[u8; 28] = b"SDL_RENDER_DIRECT3D11_DEBUG\0";
+pub const SDL_HINT_RENDER_DIRECT3D_THREADSAFE: &[u8; 31] = b"SDL_RENDER_DIRECT3D_THREADSAFE\0";
+pub const SDL_HINT_RENDER_DRIVER: &[u8; 18] = b"SDL_RENDER_DRIVER\0";
+pub const SDL_HINT_RENDER_LOGICAL_SIZE_MODE: &[u8; 29] = b"SDL_RENDER_LOGICAL_SIZE_MODE\0";
+pub const SDL_HINT_RENDER_OPENGL_SHADERS: &[u8; 26] = b"SDL_RENDER_OPENGL_SHADERS\0";
+pub const SDL_HINT_RENDER_SCALE_QUALITY: &[u8; 25] = b"SDL_RENDER_SCALE_QUALITY\0";
+pub const SDL_HINT_RENDER_VSYNC: &[u8; 17] = b"SDL_RENDER_VSYNC\0";
+pub const SDL_HINT_PS2_DYNAMIC_VSYNC: &[u8; 22] = b"SDL_PS2_DYNAMIC_VSYNC\0";
+pub const SDL_HINT_RETURN_KEY_HIDES_IME: &[u8; 25] = b"SDL_RETURN_KEY_HIDES_IME\0";
+pub const SDL_HINT_RPI_VIDEO_LAYER: &[u8; 20] = b"SDL_RPI_VIDEO_LAYER\0";
+pub const SDL_HINT_SCREENSAVER_INHIBIT_ACTIVITY_NAME: &[u8; 38] =
     b"SDL_SCREENSAVER_INHIBIT_ACTIVITY_NAME\0";
-pub const SDL_HINT_THREAD_FORCE_REALTIME_TIME_CRITICAL: &'static [u8; 40usize] =
+pub const SDL_HINT_THREAD_FORCE_REALTIME_TIME_CRITICAL: &[u8; 40] =
     b"SDL_THREAD_FORCE_REALTIME_TIME_CRITICAL\0";
-pub const SDL_HINT_THREAD_PRIORITY_POLICY: &'static [u8; 27usize] = b"SDL_THREAD_PRIORITY_POLICY\0";
-pub const SDL_HINT_THREAD_STACK_SIZE: &'static [u8; 22usize] = b"SDL_THREAD_STACK_SIZE\0";
-pub const SDL_HINT_TIMER_RESOLUTION: &'static [u8; 21usize] = b"SDL_TIMER_RESOLUTION\0";
-pub const SDL_HINT_TOUCH_MOUSE_EVENTS: &'static [u8; 23usize] = b"SDL_TOUCH_MOUSE_EVENTS\0";
-pub const SDL_HINT_TV_REMOTE_AS_JOYSTICK: &'static [u8; 26usize] = b"SDL_TV_REMOTE_AS_JOYSTICK\0";
-pub const SDL_HINT_VIDEO_ALLOW_SCREENSAVER: &'static [u8; 28usize] =
-    b"SDL_VIDEO_ALLOW_SCREENSAVER\0";
-pub const SDL_HINT_VIDEO_DOUBLE_BUFFER: &'static [u8; 24usize] = b"SDL_VIDEO_DOUBLE_BUFFER\0";
-pub const SDL_HINT_VIDEO_EGL_ALLOW_TRANSPARENCY: &'static [u8; 33usize] =
-    b"SDL_VIDEO_EGL_ALLOW_TRANSPARENCY\0";
-pub const SDL_HINT_VIDEO_EXTERNAL_CONTEXT: &'static [u8; 27usize] = b"SDL_VIDEO_EXTERNAL_CONTEXT\0";
-pub const SDL_HINT_VIDEO_HIGHDPI_DISABLED: &'static [u8; 27usize] = b"SDL_VIDEO_HIGHDPI_DISABLED\0";
-pub const SDL_HINT_VIDEO_MAC_FULLSCREEN_SPACES: &'static [u8; 32usize] =
-    b"SDL_VIDEO_MAC_FULLSCREEN_SPACES\0";
-pub const SDL_HINT_VIDEO_MINIMIZE_ON_FOCUS_LOSS: &'static [u8; 33usize] =
-    b"SDL_VIDEO_MINIMIZE_ON_FOCUS_LOSS\0";
-pub const SDL_HINT_VIDEO_WAYLAND_ALLOW_LIBDECOR: &'static [u8; 33usize] =
-    b"SDL_VIDEO_WAYLAND_ALLOW_LIBDECOR\0";
-pub const SDL_HINT_VIDEO_WINDOW_SHARE_PIXEL_FORMAT: &'static [u8; 36usize] =
+pub const SDL_HINT_THREAD_PRIORITY_POLICY: &[u8; 27] = b"SDL_THREAD_PRIORITY_POLICY\0";
+pub const SDL_HINT_THREAD_STACK_SIZE: &[u8; 22] = b"SDL_THREAD_STACK_SIZE\0";
+pub const SDL_HINT_TIMER_RESOLUTION: &[u8; 21] = b"SDL_TIMER_RESOLUTION\0";
+pub const SDL_HINT_TOUCH_MOUSE_EVENTS: &[u8; 23] = b"SDL_TOUCH_MOUSE_EVENTS\0";
+pub const SDL_HINT_VITA_TOUCH_MOUSE_DEVICE: &[u8; 33] = b"SDL_HINT_VITA_TOUCH_MOUSE_DEVICE\0";
+pub const SDL_HINT_TV_REMOTE_AS_JOYSTICK: &[u8; 26] = b"SDL_TV_REMOTE_AS_JOYSTICK\0";
+pub const SDL_HINT_VIDEO_ALLOW_SCREENSAVER: &[u8; 28] = b"SDL_VIDEO_ALLOW_SCREENSAVER\0";
+pub const SDL_HINT_VIDEO_DOUBLE_BUFFER: &[u8; 24] = b"SDL_VIDEO_DOUBLE_BUFFER\0";
+pub const SDL_HINT_VIDEO_EGL_ALLOW_TRANSPARENCY: &[u8; 33] = b"SDL_VIDEO_EGL_ALLOW_TRANSPARENCY\0";
+pub const SDL_HINT_VIDEO_EXTERNAL_CONTEXT: &[u8; 27] = b"SDL_VIDEO_EXTERNAL_CONTEXT\0";
+pub const SDL_HINT_VIDEO_HIGHDPI_DISABLED: &[u8; 27] = b"SDL_VIDEO_HIGHDPI_DISABLED\0";
+pub const SDL_HINT_VIDEO_MAC_FULLSCREEN_SPACES: &[u8; 32] = b"SDL_VIDEO_MAC_FULLSCREEN_SPACES\0";
+pub const SDL_HINT_VIDEO_MINIMIZE_ON_FOCUS_LOSS: &[u8; 33] = b"SDL_VIDEO_MINIMIZE_ON_FOCUS_LOSS\0";
+pub const SDL_HINT_VIDEO_WAYLAND_ALLOW_LIBDECOR: &[u8; 33] = b"SDL_VIDEO_WAYLAND_ALLOW_LIBDECOR\0";
+pub const SDL_HINT_VIDEO_WAYLAND_PREFER_LIBDECOR: &[u8; 34] =
+    b"SDL_VIDEO_WAYLAND_PREFER_LIBDECOR\0";
+pub const SDL_HINT_VIDEO_WAYLAND_MODE_EMULATION: &[u8; 33] = b"SDL_VIDEO_WAYLAND_MODE_EMULATION\0";
+pub const SDL_HINT_VIDEO_WAYLAND_EMULATE_MOUSE_WARP: &[u8; 37] =
+    b"SDL_VIDEO_WAYLAND_EMULATE_MOUSE_WARP\0";
+pub const SDL_HINT_VIDEO_WINDOW_SHARE_PIXEL_FORMAT: &[u8; 36] =
     b"SDL_VIDEO_WINDOW_SHARE_PIXEL_FORMAT\0";
-pub const SDL_HINT_VIDEO_WIN_D3DCOMPILER: &'static [u8; 26usize] = b"SDL_VIDEO_WIN_D3DCOMPILER\0";
-pub const SDL_HINT_VIDEO_X11_FORCE_EGL: &'static [u8; 24usize] = b"SDL_VIDEO_X11_FORCE_EGL\0";
-pub const SDL_HINT_VIDEO_X11_NET_WM_BYPASS_COMPOSITOR: &'static [u8; 39usize] =
+pub const SDL_HINT_VIDEO_FOREIGN_WINDOW_OPENGL: &[u8; 32] = b"SDL_VIDEO_FOREIGN_WINDOW_OPENGL\0";
+pub const SDL_HINT_VIDEO_FOREIGN_WINDOW_VULKAN: &[u8; 32] = b"SDL_VIDEO_FOREIGN_WINDOW_VULKAN\0";
+pub const SDL_HINT_VIDEO_WIN_D3DCOMPILER: &[u8; 26] = b"SDL_VIDEO_WIN_D3DCOMPILER\0";
+pub const SDL_HINT_VIDEO_X11_FORCE_EGL: &[u8; 24] = b"SDL_VIDEO_X11_FORCE_EGL\0";
+pub const SDL_HINT_VIDEO_X11_NET_WM_BYPASS_COMPOSITOR: &[u8; 39] =
     b"SDL_VIDEO_X11_NET_WM_BYPASS_COMPOSITOR\0";
-pub const SDL_HINT_VIDEO_X11_NET_WM_PING: &'static [u8; 26usize] = b"SDL_VIDEO_X11_NET_WM_PING\0";
-pub const SDL_HINT_VIDEO_X11_WINDOW_VISUALID: &'static [u8; 30usize] =
-    b"SDL_VIDEO_X11_WINDOW_VISUALID\0";
-pub const SDL_HINT_VIDEO_X11_XINERAMA: &'static [u8; 23usize] = b"SDL_VIDEO_X11_XINERAMA\0";
-pub const SDL_HINT_VIDEO_X11_XRANDR: &'static [u8; 21usize] = b"SDL_VIDEO_X11_XRANDR\0";
-pub const SDL_HINT_VIDEO_X11_XVIDMODE: &'static [u8; 23usize] = b"SDL_VIDEO_X11_XVIDMODE\0";
-pub const SDL_HINT_WAVE_FACT_CHUNK: &'static [u8; 20usize] = b"SDL_WAVE_FACT_CHUNK\0";
-pub const SDL_HINT_WAVE_RIFF_CHUNK_SIZE: &'static [u8; 25usize] = b"SDL_WAVE_RIFF_CHUNK_SIZE\0";
-pub const SDL_HINT_WAVE_TRUNCATION: &'static [u8; 20usize] = b"SDL_WAVE_TRUNCATION\0";
-pub const SDL_HINT_WINDOWS_DISABLE_THREAD_NAMING: &'static [u8; 34usize] =
+pub const SDL_HINT_VIDEO_X11_NET_WM_PING: &[u8; 26] = b"SDL_VIDEO_X11_NET_WM_PING\0";
+pub const SDL_HINT_VIDEO_X11_WINDOW_VISUALID: &[u8; 30] = b"SDL_VIDEO_X11_WINDOW_VISUALID\0";
+pub const SDL_HINT_VIDEO_X11_XINERAMA: &[u8; 23] = b"SDL_VIDEO_X11_XINERAMA\0";
+pub const SDL_HINT_VIDEO_X11_XRANDR: &[u8; 21] = b"SDL_VIDEO_X11_XRANDR\0";
+pub const SDL_HINT_VIDEO_X11_XVIDMODE: &[u8; 23] = b"SDL_VIDEO_X11_XVIDMODE\0";
+pub const SDL_HINT_WAVE_FACT_CHUNK: &[u8; 20] = b"SDL_WAVE_FACT_CHUNK\0";
+pub const SDL_HINT_WAVE_RIFF_CHUNK_SIZE: &[u8; 25] = b"SDL_WAVE_RIFF_CHUNK_SIZE\0";
+pub const SDL_HINT_WAVE_TRUNCATION: &[u8; 20] = b"SDL_WAVE_TRUNCATION\0";
+pub const SDL_HINT_WINDOWS_DISABLE_THREAD_NAMING: &[u8; 34] =
     b"SDL_WINDOWS_DISABLE_THREAD_NAMING\0";
-pub const SDL_HINT_WINDOWS_ENABLE_MESSAGELOOP: &'static [u8; 31usize] =
-    b"SDL_WINDOWS_ENABLE_MESSAGELOOP\0";
-pub const SDL_HINT_WINDOWS_FORCE_MUTEX_CRITICAL_SECTIONS: &'static [u8; 42usize] =
+pub const SDL_HINT_WINDOWS_ENABLE_MESSAGELOOP: &[u8; 31] = b"SDL_WINDOWS_ENABLE_MESSAGELOOP\0";
+pub const SDL_HINT_WINDOWS_FORCE_MUTEX_CRITICAL_SECTIONS: &[u8; 42] =
     b"SDL_WINDOWS_FORCE_MUTEX_CRITICAL_SECTIONS\0";
-pub const SDL_HINT_WINDOWS_FORCE_SEMAPHORE_KERNEL: &'static [u8; 35usize] =
+pub const SDL_HINT_WINDOWS_FORCE_SEMAPHORE_KERNEL: &[u8; 35] =
     b"SDL_WINDOWS_FORCE_SEMAPHORE_KERNEL\0";
-pub const SDL_HINT_WINDOWS_INTRESOURCE_ICON: &'static [u8; 29usize] =
-    b"SDL_WINDOWS_INTRESOURCE_ICON\0";
-pub const SDL_HINT_WINDOWS_INTRESOURCE_ICON_SMALL: &'static [u8; 35usize] =
+pub const SDL_HINT_WINDOWS_INTRESOURCE_ICON: &[u8; 29] = b"SDL_WINDOWS_INTRESOURCE_ICON\0";
+pub const SDL_HINT_WINDOWS_INTRESOURCE_ICON_SMALL: &[u8; 35] =
     b"SDL_WINDOWS_INTRESOURCE_ICON_SMALL\0";
-pub const SDL_HINT_WINDOWS_NO_CLOSE_ON_ALT_F4: &'static [u8; 31usize] =
-    b"SDL_WINDOWS_NO_CLOSE_ON_ALT_F4\0";
-pub const SDL_HINT_WINDOWS_USE_D3D9EX: &'static [u8; 23usize] = b"SDL_WINDOWS_USE_D3D9EX\0";
-pub const SDL_HINT_WINDOW_FRAME_USABLE_WHILE_CURSOR_HIDDEN: &'static [u8; 44usize] =
+pub const SDL_HINT_WINDOWS_NO_CLOSE_ON_ALT_F4: &[u8; 31] = b"SDL_WINDOWS_NO_CLOSE_ON_ALT_F4\0";
+pub const SDL_HINT_WINDOWS_USE_D3D9EX: &[u8; 23] = b"SDL_WINDOWS_USE_D3D9EX\0";
+pub const SDL_HINT_WINDOWS_DPI_AWARENESS: &[u8; 26] = b"SDL_WINDOWS_DPI_AWARENESS\0";
+pub const SDL_HINT_WINDOWS_DPI_SCALING: &[u8; 24] = b"SDL_WINDOWS_DPI_SCALING\0";
+pub const SDL_HINT_WINDOW_FRAME_USABLE_WHILE_CURSOR_HIDDEN: &[u8; 44] =
     b"SDL_WINDOW_FRAME_USABLE_WHILE_CURSOR_HIDDEN\0";
-pub const SDL_HINT_WINDOW_NO_ACTIVATION_WHEN_SHOWN: &'static [u8; 36usize] =
+pub const SDL_HINT_WINDOW_NO_ACTIVATION_WHEN_SHOWN: &[u8; 36] =
     b"SDL_WINDOW_NO_ACTIVATION_WHEN_SHOWN\0";
-pub const SDL_HINT_WINRT_HANDLE_BACK_BUTTON: &'static [u8; 29usize] =
-    b"SDL_WINRT_HANDLE_BACK_BUTTON\0";
-pub const SDL_HINT_WINRT_PRIVACY_POLICY_LABEL: &'static [u8; 31usize] =
-    b"SDL_WINRT_PRIVACY_POLICY_LABEL\0";
-pub const SDL_HINT_WINRT_PRIVACY_POLICY_URL: &'static [u8; 29usize] =
-    b"SDL_WINRT_PRIVACY_POLICY_URL\0";
-pub const SDL_HINT_X11_FORCE_OVERRIDE_REDIRECT: &'static [u8; 32usize] =
-    b"SDL_X11_FORCE_OVERRIDE_REDIRECT\0";
-pub const SDL_HINT_XINPUT_ENABLED: &'static [u8; 19usize] = b"SDL_XINPUT_ENABLED\0";
-pub const SDL_HINT_XINPUT_USE_OLD_JOYSTICK_MAPPING: &'static [u8; 36usize] =
+pub const SDL_HINT_WINRT_HANDLE_BACK_BUTTON: &[u8; 29] = b"SDL_WINRT_HANDLE_BACK_BUTTON\0";
+pub const SDL_HINT_WINRT_PRIVACY_POLICY_LABEL: &[u8; 31] = b"SDL_WINRT_PRIVACY_POLICY_LABEL\0";
+pub const SDL_HINT_WINRT_PRIVACY_POLICY_URL: &[u8; 29] = b"SDL_WINRT_PRIVACY_POLICY_URL\0";
+pub const SDL_HINT_X11_FORCE_OVERRIDE_REDIRECT: &[u8; 32] = b"SDL_X11_FORCE_OVERRIDE_REDIRECT\0";
+pub const SDL_HINT_XINPUT_ENABLED: &[u8; 19] = b"SDL_XINPUT_ENABLED\0";
+pub const SDL_HINT_DIRECTINPUT_ENABLED: &[u8; 24] = b"SDL_DIRECTINPUT_ENABLED\0";
+pub const SDL_HINT_XINPUT_USE_OLD_JOYSTICK_MAPPING: &[u8; 36] =
     b"SDL_XINPUT_USE_OLD_JOYSTICK_MAPPING\0";
-pub const SDL_HINT_AUDIO_INCLUDE_MONITORS: &'static [u8; 27usize] = b"SDL_AUDIO_INCLUDE_MONITORS\0";
+pub const SDL_HINT_AUDIO_INCLUDE_MONITORS: &[u8; 27] = b"SDL_AUDIO_INCLUDE_MONITORS\0";
+pub const SDL_HINT_X11_WINDOW_TYPE: &[u8; 20] = b"SDL_X11_WINDOW_TYPE\0";
+pub const SDL_HINT_QUIT_ON_LAST_WINDOW_CLOSE: &[u8; 30] = b"SDL_QUIT_ON_LAST_WINDOW_CLOSE\0";
+pub const SDL_HINT_VIDEODRIVER: &[u8; 16] = b"SDL_VIDEODRIVER\0";
+pub const SDL_HINT_AUDIODRIVER: &[u8; 16] = b"SDL_AUDIODRIVER\0";
+pub const SDL_HINT_KMSDRM_DEVICE_INDEX: &[u8; 24] = b"SDL_KMSDRM_DEVICE_INDEX\0";
+pub const SDL_HINT_TRACKPAD_IS_TOUCH_ONLY: &[u8; 27] = b"SDL_TRACKPAD_IS_TOUCH_ONLY\0";
 pub const SDL_MAX_LOG_MESSAGE: u32 = 4096;
 pub const SDL_NONSHAPEABLE_WINDOW: i32 = -1;
 pub const SDL_INVALID_SHAPE_ARGUMENT: i32 = -2;
 pub const SDL_WINDOW_LACKS_SHAPE: i32 = -3;
 pub const SDL_MAJOR_VERSION: u32 = 2;
-pub const SDL_MINOR_VERSION: u32 = 0;
-pub const SDL_PATCHLEVEL: u32 = 20;
+pub const SDL_MINOR_VERSION: u32 = 26;
+pub const SDL_PATCHLEVEL: u32 = 4;
 pub const SDL_INIT_TIMER: u32 = 1;
 pub const SDL_INIT_AUDIO: u32 = 16;
 pub const SDL_INIT_VIDEO: u32 = 32;
@@ -895,16 +918,16 @@ pub const False: u32 = 0;
 pub const QueuedAlready: u32 = 0;
 pub const QueuedAfterReading: u32 = 1;
 pub const QueuedAfterFlush: u32 = 2;
-pub const XNRequiredCharSet: &'static [u8; 16usize] = b"requiredCharSet\0";
-pub const XNQueryOrientation: &'static [u8; 17usize] = b"queryOrientation\0";
-pub const XNBaseFontName: &'static [u8; 13usize] = b"baseFontName\0";
-pub const XNOMAutomatic: &'static [u8; 12usize] = b"omAutomatic\0";
-pub const XNMissingCharSet: &'static [u8; 15usize] = b"missingCharSet\0";
-pub const XNDefaultString: &'static [u8; 14usize] = b"defaultString\0";
-pub const XNOrientation: &'static [u8; 12usize] = b"orientation\0";
-pub const XNDirectionalDependentDrawing: &'static [u8; 28usize] = b"directionalDependentDrawing\0";
-pub const XNContextualDrawing: &'static [u8; 18usize] = b"contextualDrawing\0";
-pub const XNFontInfo: &'static [u8; 9usize] = b"fontInfo\0";
+pub const XNRequiredCharSet: &[u8; 16] = b"requiredCharSet\0";
+pub const XNQueryOrientation: &[u8; 17] = b"queryOrientation\0";
+pub const XNBaseFontName: &[u8; 13] = b"baseFontName\0";
+pub const XNOMAutomatic: &[u8; 12] = b"omAutomatic\0";
+pub const XNMissingCharSet: &[u8; 15] = b"missingCharSet\0";
+pub const XNDefaultString: &[u8; 14] = b"defaultString\0";
+pub const XNOrientation: &[u8; 12] = b"orientation\0";
+pub const XNDirectionalDependentDrawing: &[u8; 28] = b"directionalDependentDrawing\0";
+pub const XNContextualDrawing: &[u8; 18] = b"contextualDrawing\0";
+pub const XNFontInfo: &[u8; 9] = b"fontInfo\0";
 pub const XIMPreeditArea: u32 = 1;
 pub const XIMPreeditCallbacks: u32 = 2;
 pub const XIMPreeditPosition: u32 = 4;
@@ -914,48 +937,48 @@ pub const XIMStatusArea: u32 = 256;
 pub const XIMStatusCallbacks: u32 = 512;
 pub const XIMStatusNothing: u32 = 1024;
 pub const XIMStatusNone: u32 = 2048;
-pub const XNVaNestedList: &'static [u8; 15usize] = b"XNVaNestedList\0";
-pub const XNQueryInputStyle: &'static [u8; 16usize] = b"queryInputStyle\0";
-pub const XNClientWindow: &'static [u8; 13usize] = b"clientWindow\0";
-pub const XNInputStyle: &'static [u8; 11usize] = b"inputStyle\0";
-pub const XNFocusWindow: &'static [u8; 12usize] = b"focusWindow\0";
-pub const XNResourceName: &'static [u8; 13usize] = b"resourceName\0";
-pub const XNResourceClass: &'static [u8; 14usize] = b"resourceClass\0";
-pub const XNGeometryCallback: &'static [u8; 17usize] = b"geometryCallback\0";
-pub const XNDestroyCallback: &'static [u8; 16usize] = b"destroyCallback\0";
-pub const XNFilterEvents: &'static [u8; 13usize] = b"filterEvents\0";
-pub const XNPreeditStartCallback: &'static [u8; 21usize] = b"preeditStartCallback\0";
-pub const XNPreeditDoneCallback: &'static [u8; 20usize] = b"preeditDoneCallback\0";
-pub const XNPreeditDrawCallback: &'static [u8; 20usize] = b"preeditDrawCallback\0";
-pub const XNPreeditCaretCallback: &'static [u8; 21usize] = b"preeditCaretCallback\0";
-pub const XNPreeditStateNotifyCallback: &'static [u8; 27usize] = b"preeditStateNotifyCallback\0";
-pub const XNPreeditAttributes: &'static [u8; 18usize] = b"preeditAttributes\0";
-pub const XNStatusStartCallback: &'static [u8; 20usize] = b"statusStartCallback\0";
-pub const XNStatusDoneCallback: &'static [u8; 19usize] = b"statusDoneCallback\0";
-pub const XNStatusDrawCallback: &'static [u8; 19usize] = b"statusDrawCallback\0";
-pub const XNStatusAttributes: &'static [u8; 17usize] = b"statusAttributes\0";
-pub const XNArea: &'static [u8; 5usize] = b"area\0";
-pub const XNAreaNeeded: &'static [u8; 11usize] = b"areaNeeded\0";
-pub const XNSpotLocation: &'static [u8; 13usize] = b"spotLocation\0";
-pub const XNColormap: &'static [u8; 9usize] = b"colorMap\0";
-pub const XNStdColormap: &'static [u8; 12usize] = b"stdColorMap\0";
-pub const XNForeground: &'static [u8; 11usize] = b"foreground\0";
-pub const XNBackground: &'static [u8; 11usize] = b"background\0";
-pub const XNBackgroundPixmap: &'static [u8; 17usize] = b"backgroundPixmap\0";
-pub const XNFontSet: &'static [u8; 8usize] = b"fontSet\0";
-pub const XNLineSpace: &'static [u8; 10usize] = b"lineSpace\0";
-pub const XNCursor: &'static [u8; 7usize] = b"cursor\0";
-pub const XNQueryIMValuesList: &'static [u8; 18usize] = b"queryIMValuesList\0";
-pub const XNQueryICValuesList: &'static [u8; 18usize] = b"queryICValuesList\0";
-pub const XNVisiblePosition: &'static [u8; 16usize] = b"visiblePosition\0";
-pub const XNR6PreeditCallback: &'static [u8; 18usize] = b"r6PreeditCallback\0";
-pub const XNStringConversionCallback: &'static [u8; 25usize] = b"stringConversionCallback\0";
-pub const XNStringConversion: &'static [u8; 17usize] = b"stringConversion\0";
-pub const XNResetState: &'static [u8; 11usize] = b"resetState\0";
-pub const XNHotKey: &'static [u8; 7usize] = b"hotKey\0";
-pub const XNHotKeyState: &'static [u8; 12usize] = b"hotKeyState\0";
-pub const XNPreeditState: &'static [u8; 13usize] = b"preeditState\0";
-pub const XNSeparatorofNestedList: &'static [u8; 22usize] = b"separatorofNestedList\0";
+pub const XNVaNestedList: &[u8; 15] = b"XNVaNestedList\0";
+pub const XNQueryInputStyle: &[u8; 16] = b"queryInputStyle\0";
+pub const XNClientWindow: &[u8; 13] = b"clientWindow\0";
+pub const XNInputStyle: &[u8; 11] = b"inputStyle\0";
+pub const XNFocusWindow: &[u8; 12] = b"focusWindow\0";
+pub const XNResourceName: &[u8; 13] = b"resourceName\0";
+pub const XNResourceClass: &[u8; 14] = b"resourceClass\0";
+pub const XNGeometryCallback: &[u8; 17] = b"geometryCallback\0";
+pub const XNDestroyCallback: &[u8; 16] = b"destroyCallback\0";
+pub const XNFilterEvents: &[u8; 13] = b"filterEvents\0";
+pub const XNPreeditStartCallback: &[u8; 21] = b"preeditStartCallback\0";
+pub const XNPreeditDoneCallback: &[u8; 20] = b"preeditDoneCallback\0";
+pub const XNPreeditDrawCallback: &[u8; 20] = b"preeditDrawCallback\0";
+pub const XNPreeditCaretCallback: &[u8; 21] = b"preeditCaretCallback\0";
+pub const XNPreeditStateNotifyCallback: &[u8; 27] = b"preeditStateNotifyCallback\0";
+pub const XNPreeditAttributes: &[u8; 18] = b"preeditAttributes\0";
+pub const XNStatusStartCallback: &[u8; 20] = b"statusStartCallback\0";
+pub const XNStatusDoneCallback: &[u8; 19] = b"statusDoneCallback\0";
+pub const XNStatusDrawCallback: &[u8; 19] = b"statusDrawCallback\0";
+pub const XNStatusAttributes: &[u8; 17] = b"statusAttributes\0";
+pub const XNArea: &[u8; 5] = b"area\0";
+pub const XNAreaNeeded: &[u8; 11] = b"areaNeeded\0";
+pub const XNSpotLocation: &[u8; 13] = b"spotLocation\0";
+pub const XNColormap: &[u8; 9] = b"colorMap\0";
+pub const XNStdColormap: &[u8; 12] = b"stdColorMap\0";
+pub const XNForeground: &[u8; 11] = b"foreground\0";
+pub const XNBackground: &[u8; 11] = b"background\0";
+pub const XNBackgroundPixmap: &[u8; 17] = b"backgroundPixmap\0";
+pub const XNFontSet: &[u8; 8] = b"fontSet\0";
+pub const XNLineSpace: &[u8; 10] = b"lineSpace\0";
+pub const XNCursor: &[u8; 7] = b"cursor\0";
+pub const XNQueryIMValuesList: &[u8; 18] = b"queryIMValuesList\0";
+pub const XNQueryICValuesList: &[u8; 18] = b"queryICValuesList\0";
+pub const XNVisiblePosition: &[u8; 16] = b"visiblePosition\0";
+pub const XNR6PreeditCallback: &[u8; 18] = b"r6PreeditCallback\0";
+pub const XNStringConversionCallback: &[u8; 25] = b"stringConversionCallback\0";
+pub const XNStringConversion: &[u8; 17] = b"stringConversion\0";
+pub const XNResetState: &[u8; 11] = b"resetState\0";
+pub const XNHotKey: &[u8; 7] = b"hotKey\0";
+pub const XNHotKeyState: &[u8; 12] = b"hotKeyState\0";
+pub const XNPreeditState: &[u8; 13] = b"preeditState\0";
+pub const XNSeparatorofNestedList: &[u8; 22] = b"separatorofNestedList\0";
 pub const XBufferOverflow: i32 = -1;
 pub const XLookupNone: u32 = 1;
 pub const XLookupChars: u32 = 2;
@@ -991,23 +1014,9 @@ pub const XIMHotKeyStateON: u32 = 1;
 pub const XIMHotKeyStateOFF: u32 = 2;
 pub const XATOM_H: u32 = 1;
 extern "C" {
-    #[doc = " Get the name of the platform."]
-    #[doc = ""]
-    #[doc = " Here are the names returned for some (but not all) supported platforms:"]
-    #[doc = ""]
-    #[doc = " - \"Windows\""]
-    #[doc = " - \"Mac OS X\""]
-    #[doc = " - \"Linux\""]
-    #[doc = " - \"iOS\""]
-    #[doc = " - \"Android\""]
-    #[doc = ""]
-    #[doc = " \\returns the name of the platform. If the correct platform name is not"]
-    #[doc = "          available, returns a string beginning with the text \"Unknown\"."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
+    #[doc = " Get the name of the platform.\n\n Here are the names returned for some (but not all) supported platforms:\n\n - \"Windows\"\n - \"Mac OS X\"\n - \"Linux\"\n - \"iOS\"\n - \"Android\"\n\n \\returns the name of the platform. If the correct platform name is not\n          available, returns a string beginning with the text \"Unknown\".\n\n \\since This function is available since SDL 2.0.0."]
     pub fn SDL_GetPlatform() -> *const libc::c_char;
 }
-pub type size_t = libc::c_ulong;
 pub type wchar_t = libc::c_int;
 #[repr(C)]
 #[repr(align(16))]
@@ -1019,6 +1028,8 @@ pub struct max_align_t {
 }
 #[test]
 fn bindgen_test_layout_max_align_t() {
+    const UNINIT: ::core::mem::MaybeUninit<max_align_t> = ::core::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::core::mem::size_of::<max_align_t>(),
         32usize,
@@ -1030,9 +1041,7 @@ fn bindgen_test_layout_max_align_t() {
         concat!("Alignment of ", stringify!(max_align_t))
     );
     assert_eq!(
-        unsafe {
-            &(*(::core::ptr::null::<max_align_t>())).__clang_max_align_nonce1 as *const _ as usize
-        },
+        unsafe { ::core::ptr::addr_of!((*ptr).__clang_max_align_nonce1) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -1042,9 +1051,7 @@ fn bindgen_test_layout_max_align_t() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::core::ptr::null::<max_align_t>())).__clang_max_align_nonce2 as *const _ as usize
-        },
+        unsafe { ::core::ptr::addr_of!((*ptr).__clang_max_align_nonce2) as usize - ptr as usize },
         16usize,
         concat!(
             "Offset of field: ",
@@ -1054,8 +1061,8 @@ fn bindgen_test_layout_max_align_t() {
         )
     );
 }
-pub type va_list = __builtin_va_list;
 pub type __gnuc_va_list = __builtin_va_list;
+pub type va_list = __builtin_va_list;
 pub type __u_char = libc::c_uchar;
 pub type __u_short = libc::c_ushort;
 pub type __u_int = libc::c_uint;
@@ -1097,6 +1104,8 @@ pub struct __fsid_t {
 }
 #[test]
 fn bindgen_test_layout___fsid_t() {
+    const UNINIT: ::core::mem::MaybeUninit<__fsid_t> = ::core::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::core::mem::size_of::<__fsid_t>(),
         8usize,
@@ -1108,7 +1117,7 @@ fn bindgen_test_layout___fsid_t() {
         concat!("Alignment of ", stringify!(__fsid_t))
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<__fsid_t>())).__val as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).__val) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -1165,7 +1174,7 @@ pub type uint_fast64_t = libc::c_ulong;
 pub type intmax_t = __intmax_t;
 pub type uintmax_t = __uintmax_t;
 #[repr(u32)]
-#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
+#[derive(Copy, Clone, Hash, PartialEq, Eq)]
 pub enum SDL_bool {
     SDL_FALSE = 0,
     SDL_TRUE = 1,
@@ -1178,44 +1187,42 @@ pub type Sint32 = i32;
 pub type Uint32 = u32;
 pub type Sint64 = i64;
 pub type Uint64 = u64;
-pub type SDL_compile_time_assert_uint8 = [libc::c_int; 1usize];
-pub type SDL_compile_time_assert_sint8 = [libc::c_int; 1usize];
-pub type SDL_compile_time_assert_uint16 = [libc::c_int; 1usize];
-pub type SDL_compile_time_assert_sint16 = [libc::c_int; 1usize];
-pub type SDL_compile_time_assert_uint32 = [libc::c_int; 1usize];
-pub type SDL_compile_time_assert_sint32 = [libc::c_int; 1usize];
-pub type SDL_compile_time_assert_uint64 = [libc::c_int; 1usize];
-pub type SDL_compile_time_assert_sint64 = [libc::c_int; 1usize];
 #[repr(u32)]
-#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
+#[derive(Copy, Clone, Hash, PartialEq, Eq)]
 pub enum SDL_DUMMY_ENUM {
     DUMMY_ENUM_VALUE = 0,
 }
-pub type SDL_compile_time_assert_enum = [libc::c_int; 1usize];
 extern "C" {
-    pub fn SDL_malloc(size: size_t) -> *mut libc::c_void;
+    pub fn SDL_malloc(size: usize) -> *mut libc::c_void;
 }
 extern "C" {
-    pub fn SDL_calloc(nmemb: size_t, size: size_t) -> *mut libc::c_void;
+    pub fn SDL_calloc(nmemb: usize, size: usize) -> *mut libc::c_void;
 }
 extern "C" {
-    pub fn SDL_realloc(mem: *mut libc::c_void, size: size_t) -> *mut libc::c_void;
+    pub fn SDL_realloc(mem: *mut libc::c_void, size: usize) -> *mut libc::c_void;
 }
 extern "C" {
     pub fn SDL_free(mem: *mut libc::c_void);
 }
 pub type SDL_malloc_func =
-    ::core::option::Option<unsafe extern "C" fn(size: size_t) -> *mut libc::c_void>;
+    ::core::option::Option<unsafe extern "C" fn(size: usize) -> *mut libc::c_void>;
 pub type SDL_calloc_func =
-    ::core::option::Option<unsafe extern "C" fn(nmemb: size_t, size: size_t) -> *mut libc::c_void>;
+    ::core::option::Option<unsafe extern "C" fn(nmemb: usize, size: usize) -> *mut libc::c_void>;
 pub type SDL_realloc_func = ::core::option::Option<
-    unsafe extern "C" fn(mem: *mut libc::c_void, size: size_t) -> *mut libc::c_void,
+    unsafe extern "C" fn(mem: *mut libc::c_void, size: usize) -> *mut libc::c_void,
 >;
 pub type SDL_free_func = ::core::option::Option<unsafe extern "C" fn(mem: *mut libc::c_void)>;
 extern "C" {
-    #[doc = " Get the current set of SDL memory functions"]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.7."]
+    #[doc = " Get the original set of SDL memory functions\n\n \\since This function is available since SDL 2.24.0."]
+    pub fn SDL_GetOriginalMemoryFunctions(
+        malloc_func: *mut SDL_malloc_func,
+        calloc_func: *mut SDL_calloc_func,
+        realloc_func: *mut SDL_realloc_func,
+        free_func: *mut SDL_free_func,
+    );
+}
+extern "C" {
+    #[doc = " Get the current set of SDL memory functions\n\n \\since This function is available since SDL 2.0.7."]
     pub fn SDL_GetMemoryFunctions(
         malloc_func: *mut SDL_malloc_func,
         calloc_func: *mut SDL_calloc_func,
@@ -1224,9 +1231,7 @@ extern "C" {
     );
 }
 extern "C" {
-    #[doc = " Replace SDL's memory allocation functions with a custom set"]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.7."]
+    #[doc = " Replace SDL's memory allocation functions with a custom set\n\n \\since This function is available since SDL 2.0.7."]
     pub fn SDL_SetMemoryFunctions(
         malloc_func: SDL_malloc_func,
         calloc_func: SDL_calloc_func,
@@ -1235,9 +1240,7 @@ extern "C" {
     ) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Get the number of outstanding (unfreed) allocations"]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.7."]
+    #[doc = " Get the number of outstanding (unfreed) allocations\n\n \\since This function is available since SDL 2.0.7."]
     pub fn SDL_GetNumAllocations() -> libc::c_int;
 }
 extern "C" {
@@ -1253,8 +1256,8 @@ extern "C" {
 extern "C" {
     pub fn SDL_qsort(
         base: *mut libc::c_void,
-        nmemb: size_t,
-        size: size_t,
+        nmemb: usize,
+        size: usize,
         compare: ::core::option::Option<
             unsafe extern "C" fn(
                 arg1: *const libc::c_void,
@@ -1263,6 +1266,20 @@ extern "C" {
         >,
     );
 }
+extern "C" {
+    pub fn SDL_bsearch(
+        key: *const libc::c_void,
+        base: *const libc::c_void,
+        nmemb: usize,
+        size: usize,
+        compare: ::core::option::Option<
+            unsafe extern "C" fn(
+                arg1: *const libc::c_void,
+                arg2: *const libc::c_void,
+            ) -> libc::c_int,
+        >,
+    ) -> *mut libc::c_void;
+}
 extern "C" {
     pub fn SDL_abs(x: libc::c_int) -> libc::c_int;
 }
@@ -1309,37 +1326,39 @@ extern "C" {
     pub fn SDL_tolower(x: libc::c_int) -> libc::c_int;
 }
 extern "C" {
-    pub fn SDL_crc32(crc: Uint32, data: *const libc::c_void, len: size_t) -> Uint32;
+    pub fn SDL_crc16(crc: Uint16, data: *const libc::c_void, len: usize) -> Uint16;
 }
 extern "C" {
-    pub fn SDL_memset(dst: *mut libc::c_void, c: libc::c_int, len: size_t) -> *mut libc::c_void;
+    pub fn SDL_crc32(crc: Uint32, data: *const libc::c_void, len: usize) -> Uint32;
+}
+extern "C" {
+    pub fn SDL_memset(dst: *mut libc::c_void, c: libc::c_int, len: usize) -> *mut libc::c_void;
 }
 extern "C" {
     pub fn SDL_memcpy(
         dst: *mut libc::c_void,
         src: *const libc::c_void,
-        len: size_t,
+        len: usize,
     ) -> *mut libc::c_void;
 }
 extern "C" {
     pub fn SDL_memmove(
         dst: *mut libc::c_void,
         src: *const libc::c_void,
-        len: size_t,
+        len: usize,
     ) -> *mut libc::c_void;
 }
 extern "C" {
-    pub fn SDL_memcmp(s1: *const libc::c_void, s2: *const libc::c_void, len: size_t)
-        -> libc::c_int;
+    pub fn SDL_memcmp(s1: *const libc::c_void, s2: *const libc::c_void, len: usize) -> libc::c_int;
 }
 extern "C" {
-    pub fn SDL_wcslen(wstr: *const wchar_t) -> size_t;
+    pub fn SDL_wcslen(wstr: *const wchar_t) -> usize;
 }
 extern "C" {
-    pub fn SDL_wcslcpy(dst: *mut wchar_t, src: *const wchar_t, maxlen: size_t) -> size_t;
+    pub fn SDL_wcslcpy(dst: *mut wchar_t, src: *const wchar_t, maxlen: usize) -> usize;
 }
 extern "C" {
-    pub fn SDL_wcslcat(dst: *mut wchar_t, src: *const wchar_t, maxlen: size_t) -> size_t;
+    pub fn SDL_wcslcat(dst: *mut wchar_t, src: *const wchar_t, maxlen: usize) -> usize;
 }
 extern "C" {
     pub fn SDL_wcsdup(wstr: *const wchar_t) -> *mut wchar_t;
@@ -1351,47 +1370,47 @@ extern "C" {
     pub fn SDL_wcscmp(str1: *const wchar_t, str2: *const wchar_t) -> libc::c_int;
 }
 extern "C" {
-    pub fn SDL_wcsncmp(str1: *const wchar_t, str2: *const wchar_t, maxlen: size_t) -> libc::c_int;
+    pub fn SDL_wcsncmp(str1: *const wchar_t, str2: *const wchar_t, maxlen: usize) -> libc::c_int;
 }
 extern "C" {
     pub fn SDL_wcscasecmp(str1: *const wchar_t, str2: *const wchar_t) -> libc::c_int;
 }
 extern "C" {
-    pub fn SDL_wcsncasecmp(str1: *const wchar_t, str2: *const wchar_t, len: size_t) -> libc::c_int;
+    pub fn SDL_wcsncasecmp(str1: *const wchar_t, str2: *const wchar_t, len: usize) -> libc::c_int;
 }
 extern "C" {
-    pub fn SDL_strlen(str: *const libc::c_char) -> size_t;
+    pub fn SDL_strlen(str_: *const libc::c_char) -> usize;
 }
 extern "C" {
-    pub fn SDL_strlcpy(dst: *mut libc::c_char, src: *const libc::c_char, maxlen: size_t) -> size_t;
+    pub fn SDL_strlcpy(dst: *mut libc::c_char, src: *const libc::c_char, maxlen: usize) -> usize;
 }
 extern "C" {
     pub fn SDL_utf8strlcpy(
         dst: *mut libc::c_char,
         src: *const libc::c_char,
-        dst_bytes: size_t,
-    ) -> size_t;
+        dst_bytes: usize,
+    ) -> usize;
 }
 extern "C" {
-    pub fn SDL_strlcat(dst: *mut libc::c_char, src: *const libc::c_char, maxlen: size_t) -> size_t;
+    pub fn SDL_strlcat(dst: *mut libc::c_char, src: *const libc::c_char, maxlen: usize) -> usize;
 }
 extern "C" {
-    pub fn SDL_strdup(str: *const libc::c_char) -> *mut libc::c_char;
+    pub fn SDL_strdup(str_: *const libc::c_char) -> *mut libc::c_char;
 }
 extern "C" {
-    pub fn SDL_strrev(str: *mut libc::c_char) -> *mut libc::c_char;
+    pub fn SDL_strrev(str_: *mut libc::c_char) -> *mut libc::c_char;
 }
 extern "C" {
-    pub fn SDL_strupr(str: *mut libc::c_char) -> *mut libc::c_char;
+    pub fn SDL_strupr(str_: *mut libc::c_char) -> *mut libc::c_char;
 }
 extern "C" {
-    pub fn SDL_strlwr(str: *mut libc::c_char) -> *mut libc::c_char;
+    pub fn SDL_strlwr(str_: *mut libc::c_char) -> *mut libc::c_char;
 }
 extern "C" {
-    pub fn SDL_strchr(str: *const libc::c_char, c: libc::c_int) -> *mut libc::c_char;
+    pub fn SDL_strchr(str_: *const libc::c_char, c: libc::c_int) -> *mut libc::c_char;
 }
 extern "C" {
-    pub fn SDL_strrchr(str: *const libc::c_char, c: libc::c_int) -> *mut libc::c_char;
+    pub fn SDL_strrchr(str_: *const libc::c_char, c: libc::c_int) -> *mut libc::c_char;
 }
 extern "C" {
     pub fn SDL_strstr(
@@ -1399,6 +1418,12 @@ extern "C" {
         needle: *const libc::c_char,
     ) -> *mut libc::c_char;
 }
+extern "C" {
+    pub fn SDL_strcasestr(
+        haystack: *const libc::c_char,
+        needle: *const libc::c_char,
+    ) -> *mut libc::c_char;
+}
 extern "C" {
     pub fn SDL_strtokr(
         s1: *mut libc::c_char,
@@ -1407,86 +1432,89 @@ extern "C" {
     ) -> *mut libc::c_char;
 }
 extern "C" {
-    pub fn SDL_utf8strlen(str: *const libc::c_char) -> size_t;
+    pub fn SDL_utf8strlen(str_: *const libc::c_char) -> usize;
+}
+extern "C" {
+    pub fn SDL_utf8strnlen(str_: *const libc::c_char, bytes: usize) -> usize;
 }
 extern "C" {
     pub fn SDL_itoa(
         value: libc::c_int,
-        str: *mut libc::c_char,
+        str_: *mut libc::c_char,
         radix: libc::c_int,
     ) -> *mut libc::c_char;
 }
 extern "C" {
     pub fn SDL_uitoa(
         value: libc::c_uint,
-        str: *mut libc::c_char,
+        str_: *mut libc::c_char,
         radix: libc::c_int,
     ) -> *mut libc::c_char;
 }
 extern "C" {
     pub fn SDL_ltoa(
         value: libc::c_long,
-        str: *mut libc::c_char,
+        str_: *mut libc::c_char,
         radix: libc::c_int,
     ) -> *mut libc::c_char;
 }
 extern "C" {
     pub fn SDL_ultoa(
         value: libc::c_ulong,
-        str: *mut libc::c_char,
+        str_: *mut libc::c_char,
         radix: libc::c_int,
     ) -> *mut libc::c_char;
 }
 extern "C" {
     pub fn SDL_lltoa(
         value: Sint64,
-        str: *mut libc::c_char,
+        str_: *mut libc::c_char,
         radix: libc::c_int,
     ) -> *mut libc::c_char;
 }
 extern "C" {
     pub fn SDL_ulltoa(
         value: Uint64,
-        str: *mut libc::c_char,
+        str_: *mut libc::c_char,
         radix: libc::c_int,
     ) -> *mut libc::c_char;
 }
 extern "C" {
-    pub fn SDL_atoi(str: *const libc::c_char) -> libc::c_int;
+    pub fn SDL_atoi(str_: *const libc::c_char) -> libc::c_int;
 }
 extern "C" {
-    pub fn SDL_atof(str: *const libc::c_char) -> f64;
+    pub fn SDL_atof(str_: *const libc::c_char) -> f64;
 }
 extern "C" {
     pub fn SDL_strtol(
-        str: *const libc::c_char,
+        str_: *const libc::c_char,
         endp: *mut *mut libc::c_char,
         base: libc::c_int,
     ) -> libc::c_long;
 }
 extern "C" {
     pub fn SDL_strtoul(
-        str: *const libc::c_char,
+        str_: *const libc::c_char,
         endp: *mut *mut libc::c_char,
         base: libc::c_int,
     ) -> libc::c_ulong;
 }
 extern "C" {
     pub fn SDL_strtoll(
-        str: *const libc::c_char,
+        str_: *const libc::c_char,
         endp: *mut *mut libc::c_char,
         base: libc::c_int,
     ) -> Sint64;
 }
 extern "C" {
     pub fn SDL_strtoull(
-        str: *const libc::c_char,
+        str_: *const libc::c_char,
         endp: *mut *mut libc::c_char,
         base: libc::c_int,
     ) -> Uint64;
 }
 extern "C" {
-    pub fn SDL_strtod(str: *const libc::c_char, endp: *mut *mut libc::c_char) -> f64;
+    pub fn SDL_strtod(str_: *const libc::c_char, endp: *mut *mut libc::c_char) -> f64;
 }
 extern "C" {
     pub fn SDL_strcmp(str1: *const libc::c_char, str2: *const libc::c_char) -> libc::c_int;
@@ -1495,7 +1523,7 @@ extern "C" {
     pub fn SDL_strncmp(
         str1: *const libc::c_char,
         str2: *const libc::c_char,
-        maxlen: size_t,
+        maxlen: usize,
     ) -> libc::c_int;
 }
 extern "C" {
@@ -1505,7 +1533,7 @@ extern "C" {
     pub fn SDL_strncasecmp(
         str1: *const libc::c_char,
         str2: *const libc::c_char,
-        len: size_t,
+        len: usize,
     ) -> libc::c_int;
 }
 extern "C" {
@@ -1521,7 +1549,7 @@ extern "C" {
 extern "C" {
     pub fn SDL_snprintf(
         text: *mut libc::c_char,
-        maxlen: size_t,
+        maxlen: usize,
         fmt: *const libc::c_char,
         ...
     ) -> libc::c_int;
@@ -1529,7 +1557,7 @@ extern "C" {
 extern "C" {
     pub fn SDL_vsnprintf(
         text: *mut libc::c_char,
-        maxlen: size_t,
+        maxlen: usize,
         fmt: *const libc::c_char,
         ap: *mut __va_list_tag,
     ) -> libc::c_int;
@@ -1546,18 +1574,7 @@ extern "C" {
     ) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Use this function to compute arc cosine of `x`."]
-    #[doc = ""]
-    #[doc = " The definition of `y = acos(x)` is `x = cos(y)`."]
-    #[doc = ""]
-    #[doc = " Domain: `-1 <= x <= 1`"]
-    #[doc = ""]
-    #[doc = " Range: `0 <= y <= Pi`"]
-    #[doc = ""]
-    #[doc = " \\param x floating point value, in radians."]
-    #[doc = " \\returns arc cosine of `x`."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.2."]
+    #[doc = " Use this function to compute arc cosine of `x`.\n\n The definition of `y = acos(x)` is `x = cos(y)`.\n\n Domain: `-1 <= x <= 1`\n\n Range: `0 <= y <= Pi`\n\n \\param x floating point value, in radians.\n \\returns arc cosine of `x`.\n\n \\since This function is available since SDL 2.0.2."]
     pub fn SDL_acos(x: f64) -> f64;
 }
 extern "C" {
@@ -1702,21 +1719,18 @@ extern "C" {
     pub fn SDL_iconv(
         cd: SDL_iconv_t,
         inbuf: *mut *const libc::c_char,
-        inbytesleft: *mut size_t,
+        inbytesleft: *mut usize,
         outbuf: *mut *mut libc::c_char,
-        outbytesleft: *mut size_t,
-    ) -> size_t;
+        outbytesleft: *mut usize,
+    ) -> usize;
 }
 extern "C" {
-    #[doc = " This function converts a string between encodings in one pass, returning a"]
-    #[doc = " string that must be freed with SDL_free() or NULL on error."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
+    #[doc = " This function converts a string between encodings in one pass, returning a\n string that must be freed with SDL_free() or NULL on error.\n\n \\since This function is available since SDL 2.0.0."]
     pub fn SDL_iconv_string(
         tocode: *const libc::c_char,
         fromcode: *const libc::c_char,
         inbuf: *const libc::c_char,
-        inbytesleft: size_t,
+        inbytesleft: usize,
     ) -> *mut libc::c_char;
 }
 #[doc = "  The prototype for the application's main() function"]
@@ -1727,21 +1741,11 @@ extern "C" {
     pub fn SDL_main(argc: libc::c_int, argv: *mut *mut libc::c_char) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Circumvent failure of SDL_Init() when not using SDL_main() as an entry"]
-    #[doc = " point."]
-    #[doc = ""]
-    #[doc = " This function is defined in SDL_main.h, along with the preprocessor rule to"]
-    #[doc = " redefine main() as SDL_main(). Thus to ensure that your main() function"]
-    #[doc = " will not be changed it is necessary to define SDL_MAIN_HANDLED before"]
-    #[doc = " including SDL.h."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_Init"]
+    #[doc = " Circumvent failure of SDL_Init() when not using SDL_main() as an entry\n point.\n\n This function is defined in SDL_main.h, along with the preprocessor rule to\n redefine main() as SDL_main(). Thus to ensure that your main() function\n will not be changed it is necessary to define SDL_MAIN_HANDLED before\n including SDL.h.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_Init"]
     pub fn SDL_SetMainReady();
 }
 #[repr(u32)]
-#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
+#[derive(Copy, Clone, Hash, PartialEq, Eq)]
 pub enum SDL_AssertState {
     #[doc = "< Retry the assert immediately."]
     SDL_ASSERTION_RETRY = 0,
@@ -1767,6 +1771,8 @@ pub struct SDL_AssertData {
 }
 #[test]
 fn bindgen_test_layout_SDL_AssertData() {
+    const UNINIT: ::core::mem::MaybeUninit<SDL_AssertData> = ::core::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::core::mem::size_of::<SDL_AssertData>(),
         48usize,
@@ -1778,7 +1784,7 @@ fn bindgen_test_layout_SDL_AssertData() {
         concat!("Alignment of ", stringify!(SDL_AssertData))
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_AssertData>())).always_ignore as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).always_ignore) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -1788,7 +1794,7 @@ fn bindgen_test_layout_SDL_AssertData() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_AssertData>())).trigger_count as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).trigger_count) as usize - ptr as usize },
         4usize,
         concat!(
             "Offset of field: ",
@@ -1798,7 +1804,7 @@ fn bindgen_test_layout_SDL_AssertData() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_AssertData>())).condition as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).condition) as usize - ptr as usize },
         8usize,
         concat!(
             "Offset of field: ",
@@ -1808,7 +1814,7 @@ fn bindgen_test_layout_SDL_AssertData() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_AssertData>())).filename as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).filename) as usize - ptr as usize },
         16usize,
         concat!(
             "Offset of field: ",
@@ -1818,7 +1824,7 @@ fn bindgen_test_layout_SDL_AssertData() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_AssertData>())).linenum as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).linenum) as usize - ptr as usize },
         24usize,
         concat!(
             "Offset of field: ",
@@ -1828,7 +1834,7 @@ fn bindgen_test_layout_SDL_AssertData() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_AssertData>())).function as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).function) as usize - ptr as usize },
         32usize,
         concat!(
             "Offset of field: ",
@@ -1838,7 +1844,7 @@ fn bindgen_test_layout_SDL_AssertData() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_AssertData>())).next as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).next) as usize - ptr as usize },
         40usize,
         concat!(
             "Offset of field: ",
@@ -1856,12 +1862,7 @@ extern "C" {
         arg4: libc::c_int,
     ) -> SDL_AssertState;
 }
-#[doc = " A callback that fires when an SDL assertion fails."]
-#[doc = ""]
-#[doc = " \\param data a pointer to the SDL_AssertData structure corresponding to the"]
-#[doc = "             current assertion"]
-#[doc = " \\param userdata what was passed as `userdata` to SDL_SetAssertionHandler()"]
-#[doc = " \\returns an SDL_AssertState value indicating how to handle the failure."]
+#[doc = " A callback that fires when an SDL assertion fails.\n\n \\param data a pointer to the SDL_AssertData structure corresponding to the\n             current assertion\n \\param userdata what was passed as `userdata` to SDL_SetAssertionHandler()\n \\returns an SDL_AssertState value indicating how to handle the failure."]
 pub type SDL_AssertionHandler = ::core::option::Option<
     unsafe extern "C" fn(
         data: *const SDL_AssertData,
@@ -1869,179 +1870,46 @@ pub type SDL_AssertionHandler = ::core::option::Option<
     ) -> SDL_AssertState,
 >;
 extern "C" {
-    #[doc = " Set an application-defined assertion handler."]
-    #[doc = ""]
-    #[doc = " This function allows an application to show its own assertion UI and/or"]
-    #[doc = " force the response to an assertion failure. If the application doesn't"]
-    #[doc = " provide this, SDL will try to do the right thing, popping up a"]
-    #[doc = " system-specific GUI dialog, and probably minimizing any fullscreen windows."]
-    #[doc = ""]
-    #[doc = " This callback may fire from any thread, but it runs wrapped in a mutex, so"]
-    #[doc = " it will only fire from one thread at a time."]
-    #[doc = ""]
-    #[doc = " This callback is NOT reset to SDL's internal handler upon SDL_Quit()!"]
-    #[doc = ""]
-    #[doc = " \\param handler the SDL_AssertionHandler function to call when an assertion"]
-    #[doc = "                fails or NULL for the default handler"]
-    #[doc = " \\param userdata a pointer that is passed to `handler`"]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_GetAssertionHandler"]
+    #[doc = " Set an application-defined assertion handler.\n\n This function allows an application to show its own assertion UI and/or\n force the response to an assertion failure. If the application doesn't\n provide this, SDL will try to do the right thing, popping up a\n system-specific GUI dialog, and probably minimizing any fullscreen windows.\n\n This callback may fire from any thread, but it runs wrapped in a mutex, so\n it will only fire from one thread at a time.\n\n This callback is NOT reset to SDL's internal handler upon SDL_Quit()!\n\n \\param handler the SDL_AssertionHandler function to call when an assertion\n                fails or NULL for the default handler\n \\param userdata a pointer that is passed to `handler`\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_GetAssertionHandler"]
     pub fn SDL_SetAssertionHandler(handler: SDL_AssertionHandler, userdata: *mut libc::c_void);
 }
 extern "C" {
-    #[doc = " Get the default assertion handler."]
-    #[doc = ""]
-    #[doc = " This returns the function pointer that is called by default when an"]
-    #[doc = " assertion is triggered. This is an internal function provided by SDL, that"]
-    #[doc = " is used for assertions when SDL_SetAssertionHandler() hasn't been used to"]
-    #[doc = " provide a different function."]
-    #[doc = ""]
-    #[doc = " \\returns the default SDL_AssertionHandler that is called when an assert"]
-    #[doc = "          triggers."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.2."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_GetAssertionHandler"]
+    #[doc = " Get the default assertion handler.\n\n This returns the function pointer that is called by default when an\n assertion is triggered. This is an internal function provided by SDL, that\n is used for assertions when SDL_SetAssertionHandler() hasn't been used to\n provide a different function.\n\n \\returns the default SDL_AssertionHandler that is called when an assert\n          triggers.\n\n \\since This function is available since SDL 2.0.2.\n\n \\sa SDL_GetAssertionHandler"]
     pub fn SDL_GetDefaultAssertionHandler() -> SDL_AssertionHandler;
 }
 extern "C" {
-    #[doc = " Get the current assertion handler."]
-    #[doc = ""]
-    #[doc = " This returns the function pointer that is called when an assertion is"]
-    #[doc = " triggered. This is either the value last passed to"]
-    #[doc = " SDL_SetAssertionHandler(), or if no application-specified function is set,"]
-    #[doc = " is equivalent to calling SDL_GetDefaultAssertionHandler()."]
-    #[doc = ""]
-    #[doc = " The parameter `puserdata` is a pointer to a void*, which will store the"]
-    #[doc = " \"userdata\" pointer that was passed to SDL_SetAssertionHandler(). This value"]
-    #[doc = " will always be NULL for the default handler. If you don't care about this"]
-    #[doc = " data, it is safe to pass a NULL pointer to this function to ignore it."]
-    #[doc = ""]
-    #[doc = " \\param puserdata pointer which is filled with the \"userdata\" pointer that"]
-    #[doc = "                  was passed to SDL_SetAssertionHandler()"]
-    #[doc = " \\returns the SDL_AssertionHandler that is called when an assert triggers."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.2."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_SetAssertionHandler"]
+    #[doc = " Get the current assertion handler.\n\n This returns the function pointer that is called when an assertion is\n triggered. This is either the value last passed to\n SDL_SetAssertionHandler(), or if no application-specified function is set,\n is equivalent to calling SDL_GetDefaultAssertionHandler().\n\n The parameter `puserdata` is a pointer to a void*, which will store the\n \"userdata\" pointer that was passed to SDL_SetAssertionHandler(). This value\n will always be NULL for the default handler. If you don't care about this\n data, it is safe to pass a NULL pointer to this function to ignore it.\n\n \\param puserdata pointer which is filled with the \"userdata\" pointer that\n                  was passed to SDL_SetAssertionHandler()\n \\returns the SDL_AssertionHandler that is called when an assert triggers.\n\n \\since This function is available since SDL 2.0.2.\n\n \\sa SDL_SetAssertionHandler"]
     pub fn SDL_GetAssertionHandler(puserdata: *mut *mut libc::c_void) -> SDL_AssertionHandler;
 }
 extern "C" {
-    #[doc = " Get a list of all assertion failures."]
-    #[doc = ""]
-    #[doc = " This function gets all assertions triggered since the last call to"]
-    #[doc = " SDL_ResetAssertionReport(), or the start of the program."]
-    #[doc = ""]
-    #[doc = " The proper way to examine this data looks something like this:"]
-    #[doc = ""]
-    #[doc = " ```c"]
-    #[doc = " const SDL_AssertData *item = SDL_GetAssertionReport();"]
-    #[doc = " while (item) {"]
-    #[doc = "    printf(\"'%s', %s (%s:%d), triggered %u times, always ignore: %s.\\\\n\","]
-    #[doc = "           item->condition, item->function, item->filename,"]
-    #[doc = "           item->linenum, item->trigger_count,"]
-    #[doc = "           item->always_ignore ? \"yes\" : \"no\");"]
-    #[doc = "    item = item->next;"]
-    #[doc = " }"]
-    #[doc = " ```"]
-    #[doc = ""]
-    #[doc = " \\returns a list of all failed assertions or NULL if the list is empty. This"]
-    #[doc = "          memory should not be modified or freed by the application."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_ResetAssertionReport"]
+    #[doc = " Get a list of all assertion failures.\n\n This function gets all assertions triggered since the last call to\n SDL_ResetAssertionReport(), or the start of the program.\n\n The proper way to examine this data looks something like this:\n\n ```c\n const SDL_AssertData *item = SDL_GetAssertionReport();\n while (item) {\n    printf(\"'%s', %s (%s:%d), triggered %u times, always ignore: %s.\\\\n\",\n           item->condition, item->function, item->filename,\n           item->linenum, item->trigger_count,\n           item->always_ignore ? \"yes\" : \"no\");\n    item = item->next;\n }\n ```\n\n \\returns a list of all failed assertions or NULL if the list is empty. This\n          memory should not be modified or freed by the application.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_ResetAssertionReport"]
     pub fn SDL_GetAssertionReport() -> *const SDL_AssertData;
 }
 extern "C" {
-    #[doc = " Clear the list of all assertion failures."]
-    #[doc = ""]
-    #[doc = " This function will clear the list of all assertions triggered up to that"]
-    #[doc = " point. Immediately following this call, SDL_GetAssertionReport will return"]
-    #[doc = " no items. In addition, any previously-triggered assertions will be reset to"]
-    #[doc = " a trigger_count of zero, and their always_ignore state will be false."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_GetAssertionReport"]
+    #[doc = " Clear the list of all assertion failures.\n\n This function will clear the list of all assertions triggered up to that\n point. Immediately following this call, SDL_GetAssertionReport will return\n no items. In addition, any previously-triggered assertions will be reset to\n a trigger_count of zero, and their always_ignore state will be false.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_GetAssertionReport"]
     pub fn SDL_ResetAssertionReport();
 }
 pub type SDL_SpinLock = libc::c_int;
 extern "C" {
-    #[doc = " Try to lock a spin lock by setting it to a non-zero value."]
-    #[doc = ""]
-    #[doc = " ***Please note that spinlocks are dangerous if you don't know what you're"]
-    #[doc = " doing. Please be careful using any sort of spinlock!***"]
-    #[doc = ""]
-    #[doc = " \\param lock a pointer to a lock variable"]
-    #[doc = " \\returns SDL_TRUE if the lock succeeded, SDL_FALSE if the lock is already"]
-    #[doc = "          held."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_AtomicLock"]
-    #[doc = " \\sa SDL_AtomicUnlock"]
+    #[doc = " Try to lock a spin lock by setting it to a non-zero value.\n\n ***Please note that spinlocks are dangerous if you don't know what you're\n doing. Please be careful using any sort of spinlock!***\n\n \\param lock a pointer to a lock variable\n \\returns SDL_TRUE if the lock succeeded, SDL_FALSE if the lock is already\n          held.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_AtomicLock\n \\sa SDL_AtomicUnlock"]
     pub fn SDL_AtomicTryLock(lock: *mut SDL_SpinLock) -> SDL_bool;
 }
 extern "C" {
-    #[doc = " Lock a spin lock by setting it to a non-zero value."]
-    #[doc = ""]
-    #[doc = " ***Please note that spinlocks are dangerous if you don't know what you're"]
-    #[doc = " doing. Please be careful using any sort of spinlock!***"]
-    #[doc = ""]
-    #[doc = " \\param lock a pointer to a lock variable"]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_AtomicTryLock"]
-    #[doc = " \\sa SDL_AtomicUnlock"]
+    #[doc = " Lock a spin lock by setting it to a non-zero value.\n\n ***Please note that spinlocks are dangerous if you don't know what you're\n doing. Please be careful using any sort of spinlock!***\n\n \\param lock a pointer to a lock variable\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_AtomicTryLock\n \\sa SDL_AtomicUnlock"]
     pub fn SDL_AtomicLock(lock: *mut SDL_SpinLock);
 }
 extern "C" {
-    #[doc = " Unlock a spin lock by setting it to 0."]
-    #[doc = ""]
-    #[doc = " Always returns immediately."]
-    #[doc = ""]
-    #[doc = " ***Please note that spinlocks are dangerous if you don't know what you're"]
-    #[doc = " doing. Please be careful using any sort of spinlock!***"]
-    #[doc = ""]
-    #[doc = " \\param lock a pointer to a lock variable"]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_AtomicLock"]
-    #[doc = " \\sa SDL_AtomicTryLock"]
+    #[doc = " Unlock a spin lock by setting it to 0.\n\n Always returns immediately.\n\n ***Please note that spinlocks are dangerous if you don't know what you're\n doing. Please be careful using any sort of spinlock!***\n\n \\param lock a pointer to a lock variable\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_AtomicLock\n \\sa SDL_AtomicTryLock"]
     pub fn SDL_AtomicUnlock(lock: *mut SDL_SpinLock);
 }
 extern "C" {
-    #[doc = " Memory barriers are designed to prevent reads and writes from being"]
-    #[doc = " reordered by the compiler and being seen out of order on multi-core CPUs."]
-    #[doc = ""]
-    #[doc = " A typical pattern would be for thread A to write some data and a flag, and"]
-    #[doc = " for thread B to read the flag and get the data. In this case you would"]
-    #[doc = " insert a release barrier between writing the data and the flag,"]
-    #[doc = " guaranteeing that the data write completes no later than the flag is"]
-    #[doc = " written, and you would insert an acquire barrier between reading the flag"]
-    #[doc = " and reading the data, to ensure that all the reads associated with the flag"]
-    #[doc = " have completed."]
-    #[doc = ""]
-    #[doc = " In this pattern you should always see a release barrier paired with an"]
-    #[doc = " acquire barrier and you should gate the data reads/writes with a single"]
-    #[doc = " flag variable."]
-    #[doc = ""]
-    #[doc = " For more information on these semantics, take a look at the blog post:"]
-    #[doc = " http://preshing.com/20120913/acquire-and-release-semantics"]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.6."]
+    #[doc = " Memory barriers are designed to prevent reads and writes from being\n reordered by the compiler and being seen out of order on multi-core CPUs.\n\n A typical pattern would be for thread A to write some data and a flag, and\n for thread B to read the flag and get the data. In this case you would\n insert a release barrier between writing the data and the flag,\n guaranteeing that the data write completes no later than the flag is\n written, and you would insert an acquire barrier between reading the flag\n and reading the data, to ensure that all the reads associated with the flag\n have completed.\n\n In this pattern you should always see a release barrier paired with an\n acquire barrier and you should gate the data reads/writes with a single\n flag variable.\n\n For more information on these semantics, take a look at the blog post:\n http://preshing.com/20120913/acquire-and-release-semantics\n\n \\since This function is available since SDL 2.0.6."]
     pub fn SDL_MemoryBarrierReleaseFunction();
 }
 extern "C" {
     pub fn SDL_MemoryBarrierAcquireFunction();
 }
-#[doc = " \\brief A type representing an atomic integer value.  It is a struct"]
-#[doc = "        so people don't accidentally use numeric operations on it."]
+#[doc = " \\brief A type representing an atomic integer value.  It is a struct\n        so people don't accidentally use numeric operations on it."]
 #[repr(C)]
 #[derive(Copy, Clone)]
 pub struct SDL_atomic_t {
@@ -2049,6 +1917,8 @@ pub struct SDL_atomic_t {
 }
 #[test]
 fn bindgen_test_layout_SDL_atomic_t() {
+    const UNINIT: ::core::mem::MaybeUninit<SDL_atomic_t> = ::core::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::core::mem::size_of::<SDL_atomic_t>(),
         4usize,
@@ -2060,7 +1930,7 @@ fn bindgen_test_layout_SDL_atomic_t() {
         concat!("Alignment of ", stringify!(SDL_atomic_t))
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_atomic_t>())).value as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).value) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -2071,21 +1941,7 @@ fn bindgen_test_layout_SDL_atomic_t() {
     );
 }
 extern "C" {
-    #[doc = " Set an atomic variable to a new value if it is currently an old value."]
-    #[doc = ""]
-    #[doc = " ***Note: If you don't know what this function is for, you shouldn't use"]
-    #[doc = " it!***"]
-    #[doc = ""]
-    #[doc = " \\param a a pointer to an SDL_atomic_t variable to be modified"]
-    #[doc = " \\param oldval the old value"]
-    #[doc = " \\param newval the new value"]
-    #[doc = " \\returns SDL_TRUE if the atomic variable was set, SDL_FALSE otherwise."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_AtomicCASPtr"]
-    #[doc = " \\sa SDL_AtomicGet"]
-    #[doc = " \\sa SDL_AtomicSet"]
+    #[doc = " Set an atomic variable to a new value if it is currently an old value.\n\n ***Note: If you don't know what this function is for, you shouldn't use\n it!***\n\n \\param a a pointer to an SDL_atomic_t variable to be modified\n \\param oldval the old value\n \\param newval the new value\n \\returns SDL_TRUE if the atomic variable was set, SDL_FALSE otherwise.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_AtomicCASPtr\n \\sa SDL_AtomicGet\n \\sa SDL_AtomicSet"]
     pub fn SDL_AtomicCAS(
         a: *mut SDL_atomic_t,
         oldval: libc::c_int,
@@ -2093,70 +1949,19 @@ extern "C" {
     ) -> SDL_bool;
 }
 extern "C" {
-    #[doc = " Set an atomic variable to a value."]
-    #[doc = ""]
-    #[doc = " This function also acts as a full memory barrier."]
-    #[doc = ""]
-    #[doc = " ***Note: If you don't know what this function is for, you shouldn't use"]
-    #[doc = " it!***"]
-    #[doc = ""]
-    #[doc = " \\param a a pointer to an SDL_atomic_t variable to be modified"]
-    #[doc = " \\param v the desired value"]
-    #[doc = " \\returns the previous value of the atomic variable."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.2."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_AtomicGet"]
+    #[doc = " Set an atomic variable to a value.\n\n This function also acts as a full memory barrier.\n\n ***Note: If you don't know what this function is for, you shouldn't use\n it!***\n\n \\param a a pointer to an SDL_atomic_t variable to be modified\n \\param v the desired value\n \\returns the previous value of the atomic variable.\n\n \\since This function is available since SDL 2.0.2.\n\n \\sa SDL_AtomicGet"]
     pub fn SDL_AtomicSet(a: *mut SDL_atomic_t, v: libc::c_int) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Get the value of an atomic variable."]
-    #[doc = ""]
-    #[doc = " ***Note: If you don't know what this function is for, you shouldn't use"]
-    #[doc = " it!***"]
-    #[doc = ""]
-    #[doc = " \\param a a pointer to an SDL_atomic_t variable"]
-    #[doc = " \\returns the current value of an atomic variable."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.2."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_AtomicSet"]
+    #[doc = " Get the value of an atomic variable.\n\n ***Note: If you don't know what this function is for, you shouldn't use\n it!***\n\n \\param a a pointer to an SDL_atomic_t variable\n \\returns the current value of an atomic variable.\n\n \\since This function is available since SDL 2.0.2.\n\n \\sa SDL_AtomicSet"]
     pub fn SDL_AtomicGet(a: *mut SDL_atomic_t) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Add to an atomic variable."]
-    #[doc = ""]
-    #[doc = " This function also acts as a full memory barrier."]
-    #[doc = ""]
-    #[doc = " ***Note: If you don't know what this function is for, you shouldn't use"]
-    #[doc = " it!***"]
-    #[doc = ""]
-    #[doc = " \\param a a pointer to an SDL_atomic_t variable to be modified"]
-    #[doc = " \\param v the desired value to add"]
-    #[doc = " \\returns the previous value of the atomic variable."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.2."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_AtomicDecRef"]
-    #[doc = " \\sa SDL_AtomicIncRef"]
+    #[doc = " Add to an atomic variable.\n\n This function also acts as a full memory barrier.\n\n ***Note: If you don't know what this function is for, you shouldn't use\n it!***\n\n \\param a a pointer to an SDL_atomic_t variable to be modified\n \\param v the desired value to add\n \\returns the previous value of the atomic variable.\n\n \\since This function is available since SDL 2.0.2.\n\n \\sa SDL_AtomicDecRef\n \\sa SDL_AtomicIncRef"]
     pub fn SDL_AtomicAdd(a: *mut SDL_atomic_t, v: libc::c_int) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Set a pointer to a new value if it is currently an old value."]
-    #[doc = ""]
-    #[doc = " ***Note: If you don't know what this function is for, you shouldn't use"]
-    #[doc = " it!***"]
-    #[doc = ""]
-    #[doc = " \\param a a pointer to a pointer"]
-    #[doc = " \\param oldval the old pointer value"]
-    #[doc = " \\param newval the new pointer value"]
-    #[doc = " \\returns SDL_TRUE if the pointer was set, SDL_FALSE otherwise."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_AtomicCAS"]
-    #[doc = " \\sa SDL_AtomicGetPtr"]
-    #[doc = " \\sa SDL_AtomicSetPtr"]
+    #[doc = " Set a pointer to a new value if it is currently an old value.\n\n ***Note: If you don't know what this function is for, you shouldn't use\n it!***\n\n \\param a a pointer to a pointer\n \\param oldval the old pointer value\n \\param newval the new pointer value\n \\returns SDL_TRUE if the pointer was set, SDL_FALSE otherwise.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_AtomicCAS\n \\sa SDL_AtomicGetPtr\n \\sa SDL_AtomicSetPtr"]
     pub fn SDL_AtomicCASPtr(
         a: *mut *mut libc::c_void,
         oldval: *mut libc::c_void,
@@ -2164,124 +1969,31 @@ extern "C" {
     ) -> SDL_bool;
 }
 extern "C" {
-    #[doc = " Set a pointer to a value atomically."]
-    #[doc = ""]
-    #[doc = " ***Note: If you don't know what this function is for, you shouldn't use"]
-    #[doc = " it!***"]
-    #[doc = ""]
-    #[doc = " \\param a a pointer to a pointer"]
-    #[doc = " \\param v the desired pointer value"]
-    #[doc = " \\returns the previous value of the pointer."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.2."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_AtomicCASPtr"]
-    #[doc = " \\sa SDL_AtomicGetPtr"]
+    #[doc = " Set a pointer to a value atomically.\n\n ***Note: If you don't know what this function is for, you shouldn't use\n it!***\n\n \\param a a pointer to a pointer\n \\param v the desired pointer value\n \\returns the previous value of the pointer.\n\n \\since This function is available since SDL 2.0.2.\n\n \\sa SDL_AtomicCASPtr\n \\sa SDL_AtomicGetPtr"]
     pub fn SDL_AtomicSetPtr(a: *mut *mut libc::c_void, v: *mut libc::c_void) -> *mut libc::c_void;
 }
 extern "C" {
-    #[doc = " Get the value of a pointer atomically."]
-    #[doc = ""]
-    #[doc = " ***Note: If you don't know what this function is for, you shouldn't use"]
-    #[doc = " it!***"]
-    #[doc = ""]
-    #[doc = " \\param a a pointer to a pointer"]
-    #[doc = " \\returns the current value of a pointer."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.2."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_AtomicCASPtr"]
-    #[doc = " \\sa SDL_AtomicSetPtr"]
+    #[doc = " Get the value of a pointer atomically.\n\n ***Note: If you don't know what this function is for, you shouldn't use\n it!***\n\n \\param a a pointer to a pointer\n \\returns the current value of a pointer.\n\n \\since This function is available since SDL 2.0.2.\n\n \\sa SDL_AtomicCASPtr\n \\sa SDL_AtomicSetPtr"]
     pub fn SDL_AtomicGetPtr(a: *mut *mut libc::c_void) -> *mut libc::c_void;
 }
 extern "C" {
-    #[doc = " Set the SDL error message for the current thread."]
-    #[doc = ""]
-    #[doc = " Calling this function will replace any previous error message that was set."]
-    #[doc = ""]
-    #[doc = " This function always returns -1, since SDL frequently uses -1 to signify an"]
-    #[doc = " failing result, leading to this idiom:"]
-    #[doc = ""]
-    #[doc = " ```c"]
-    #[doc = " if (error_code) {"]
-    #[doc = "     return SDL_SetError(\"This operation has failed: %d\", error_code);"]
-    #[doc = " }"]
-    #[doc = " ```"]
-    #[doc = ""]
-    #[doc = " \\param fmt a printf()-style message format string"]
-    #[doc = " \\param ... additional parameters matching % tokens in the `fmt` string, if"]
-    #[doc = "            any"]
-    #[doc = " \\returns always -1."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_ClearError"]
-    #[doc = " \\sa SDL_GetError"]
+    #[doc = " Set the SDL error message for the current thread.\n\n Calling this function will replace any previous error message that was set.\n\n This function always returns -1, since SDL frequently uses -1 to signify an\n failing result, leading to this idiom:\n\n ```c\n if (error_code) {\n     return SDL_SetError(\"This operation has failed: %d\", error_code);\n }\n ```\n\n \\param fmt a printf()-style message format string\n \\param ... additional parameters matching % tokens in the `fmt` string, if\n            any\n \\returns always -1.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_ClearError\n \\sa SDL_GetError"]
     pub fn SDL_SetError(fmt: *const libc::c_char, ...) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Retrieve a message about the last error that occurred on the current"]
-    #[doc = " thread."]
-    #[doc = ""]
-    #[doc = " It is possible for multiple errors to occur before calling SDL_GetError()."]
-    #[doc = " Only the last error is returned."]
-    #[doc = ""]
-    #[doc = " The message is only applicable when an SDL function has signaled an error."]
-    #[doc = " You must check the return values of SDL function calls to determine when to"]
-    #[doc = " appropriately call SDL_GetError(). You should *not* use the results of"]
-    #[doc = " SDL_GetError() to decide if an error has occurred! Sometimes SDL will set"]
-    #[doc = " an error string even when reporting success."]
-    #[doc = ""]
-    #[doc = " SDL will *not* clear the error string for successful API calls. You *must*"]
-    #[doc = " check return values for failure cases before you can assume the error"]
-    #[doc = " string applies."]
-    #[doc = ""]
-    #[doc = " Error strings are set per-thread, so an error set in a different thread"]
-    #[doc = " will not interfere with the current thread's operation."]
-    #[doc = ""]
-    #[doc = " The returned string is internally allocated and must not be freed by the"]
-    #[doc = " application."]
-    #[doc = ""]
-    #[doc = " \\returns a message with information about the specific error that occurred,"]
-    #[doc = "          or an empty string if there hasn't been an error message set since"]
-    #[doc = "          the last call to SDL_ClearError(). The message is only applicable"]
-    #[doc = "          when an SDL function has signaled an error. You must check the"]
-    #[doc = "          return values of SDL function calls to determine when to"]
-    #[doc = "          appropriately call SDL_GetError()."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_ClearError"]
-    #[doc = " \\sa SDL_SetError"]
+    #[doc = " Retrieve a message about the last error that occurred on the current\n thread.\n\n It is possible for multiple errors to occur before calling SDL_GetError().\n Only the last error is returned.\n\n The message is only applicable when an SDL function has signaled an error.\n You must check the return values of SDL function calls to determine when to\n appropriately call SDL_GetError(). You should *not* use the results of\n SDL_GetError() to decide if an error has occurred! Sometimes SDL will set\n an error string even when reporting success.\n\n SDL will *not* clear the error string for successful API calls. You *must*\n check return values for failure cases before you can assume the error\n string applies.\n\n Error strings are set per-thread, so an error set in a different thread\n will not interfere with the current thread's operation.\n\n The returned string is internally allocated and must not be freed by the\n application.\n\n \\returns a message with information about the specific error that occurred,\n          or an empty string if there hasn't been an error message set since\n          the last call to SDL_ClearError(). The message is only applicable\n          when an SDL function has signaled an error. You must check the\n          return values of SDL function calls to determine when to\n          appropriately call SDL_GetError().\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_ClearError\n \\sa SDL_SetError"]
     pub fn SDL_GetError() -> *const libc::c_char;
 }
 extern "C" {
-    #[doc = " Get the last error message that was set for the current thread."]
-    #[doc = ""]
-    #[doc = " This allows the caller to copy the error string into a provided buffer, but"]
-    #[doc = " otherwise operates exactly the same as SDL_GetError()."]
-    #[doc = ""]
-    #[doc = " \\param errstr A buffer to fill with the last error message that was set for"]
-    #[doc = "               the current thread"]
-    #[doc = " \\param maxlen The size of the buffer pointed to by the errstr parameter"]
-    #[doc = " \\returns the pointer passed in as the `errstr` parameter."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.14."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_GetError"]
+    #[doc = " Get the last error message that was set for the current thread.\n\n This allows the caller to copy the error string into a provided buffer, but\n otherwise operates exactly the same as SDL_GetError().\n\n \\param errstr A buffer to fill with the last error message that was set for\n               the current thread\n \\param maxlen The size of the buffer pointed to by the errstr parameter\n \\returns the pointer passed in as the `errstr` parameter.\n\n \\since This function is available since SDL 2.0.14.\n\n \\sa SDL_GetError"]
     pub fn SDL_GetErrorMsg(errstr: *mut libc::c_char, maxlen: libc::c_int) -> *mut libc::c_char;
 }
 extern "C" {
-    #[doc = " Clear any previous error message for this thread."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_GetError"]
-    #[doc = " \\sa SDL_SetError"]
+    #[doc = " Clear any previous error message for this thread.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_GetError\n \\sa SDL_SetError"]
     pub fn SDL_ClearError();
 }
 #[repr(u32)]
-#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
+#[derive(Copy, Clone, Hash, PartialEq, Eq)]
 pub enum SDL_errorcode {
     SDL_ENOMEM = 0,
     SDL_EFREAD = 1,
@@ -2299,99 +2011,23 @@ pub struct SDL_mutex {
     _unused: [u8; 0],
 }
 extern "C" {
-    #[doc = " Create a new mutex."]
-    #[doc = ""]
-    #[doc = " All newly-created mutexes begin in the _unlocked_ state."]
-    #[doc = ""]
-    #[doc = " Calls to SDL_LockMutex() will not return while the mutex is locked by"]
-    #[doc = " another thread. See SDL_TryLockMutex() to attempt to lock without blocking."]
-    #[doc = ""]
-    #[doc = " SDL mutexes are reentrant."]
-    #[doc = ""]
-    #[doc = " \\returns the initialized and unlocked mutex or NULL on failure; call"]
-    #[doc = "          SDL_GetError() for more information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_DestroyMutex"]
-    #[doc = " \\sa SDL_LockMutex"]
-    #[doc = " \\sa SDL_TryLockMutex"]
-    #[doc = " \\sa SDL_UnlockMutex"]
+    #[doc = " Create a new mutex.\n\n All newly-created mutexes begin in the _unlocked_ state.\n\n Calls to SDL_LockMutex() will not return while the mutex is locked by\n another thread. See SDL_TryLockMutex() to attempt to lock without blocking.\n\n SDL mutexes are reentrant.\n\n \\returns the initialized and unlocked mutex or NULL on failure; call\n          SDL_GetError() for more information.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_DestroyMutex\n \\sa SDL_LockMutex\n \\sa SDL_TryLockMutex\n \\sa SDL_UnlockMutex"]
     pub fn SDL_CreateMutex() -> *mut SDL_mutex;
 }
 extern "C" {
-    #[doc = " Lock the mutex."]
-    #[doc = ""]
-    #[doc = " This will block until the mutex is available, which is to say it is in the"]
-    #[doc = " unlocked state and the OS has chosen the caller as the next thread to lock"]
-    #[doc = " it. Of all threads waiting to lock the mutex, only one may do so at a time."]
-    #[doc = ""]
-    #[doc = " It is legal for the owning thread to lock an already-locked mutex. It must"]
-    #[doc = " unlock it the same number of times before it is actually made available for"]
-    #[doc = " other threads in the system (this is known as a \"recursive mutex\")."]
-    #[doc = ""]
-    #[doc = " \\param mutex the mutex to lock"]
-    #[doc = " \\return 0, or -1 on error."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
+    #[doc = " Lock the mutex.\n\n This will block until the mutex is available, which is to say it is in the\n unlocked state and the OS has chosen the caller as the next thread to lock\n it. Of all threads waiting to lock the mutex, only one may do so at a time.\n\n It is legal for the owning thread to lock an already-locked mutex. It must\n unlock it the same number of times before it is actually made available for\n other threads in the system (this is known as a \"recursive mutex\").\n\n \\param mutex the mutex to lock\n \\return 0, or -1 on error.\n\n \\since This function is available since SDL 2.0.0."]
     pub fn SDL_LockMutex(mutex: *mut SDL_mutex) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Try to lock a mutex without blocking."]
-    #[doc = ""]
-    #[doc = " This works just like SDL_LockMutex(), but if the mutex is not available,"]
-    #[doc = " this function returns `SDL_MUTEX_TIMEOUT` immediately."]
-    #[doc = ""]
-    #[doc = " This technique is useful if you need exclusive access to a resource but"]
-    #[doc = " don't want to wait for it, and will return to it to try again later."]
-    #[doc = ""]
-    #[doc = " \\param mutex the mutex to try to lock"]
-    #[doc = " \\returns 0, `SDL_MUTEX_TIMEDOUT`, or -1 on error; call SDL_GetError() for"]
-    #[doc = "          more information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_CreateMutex"]
-    #[doc = " \\sa SDL_DestroyMutex"]
-    #[doc = " \\sa SDL_LockMutex"]
-    #[doc = " \\sa SDL_UnlockMutex"]
+    #[doc = " Try to lock a mutex without blocking.\n\n This works just like SDL_LockMutex(), but if the mutex is not available,\n this function returns `SDL_MUTEX_TIMEOUT` immediately.\n\n This technique is useful if you need exclusive access to a resource but\n don't want to wait for it, and will return to it to try again later.\n\n \\param mutex the mutex to try to lock\n \\returns 0, `SDL_MUTEX_TIMEDOUT`, or -1 on error; call SDL_GetError() for\n          more information.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_CreateMutex\n \\sa SDL_DestroyMutex\n \\sa SDL_LockMutex\n \\sa SDL_UnlockMutex"]
     pub fn SDL_TryLockMutex(mutex: *mut SDL_mutex) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Unlock the mutex."]
-    #[doc = ""]
-    #[doc = " It is legal for the owning thread to lock an already-locked mutex. It must"]
-    #[doc = " unlock it the same number of times before it is actually made available for"]
-    #[doc = " other threads in the system (this is known as a \"recursive mutex\")."]
-    #[doc = ""]
-    #[doc = " It is an error to unlock a mutex that has not been locked by the current"]
-    #[doc = " thread, and doing so results in undefined behavior."]
-    #[doc = ""]
-    #[doc = " It is also an error to unlock a mutex that isn't locked at all."]
-    #[doc = ""]
-    #[doc = " \\param mutex the mutex to unlock."]
-    #[doc = " \\returns 0, or -1 on error."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
+    #[doc = " Unlock the mutex.\n\n It is legal for the owning thread to lock an already-locked mutex. It must\n unlock it the same number of times before it is actually made available for\n other threads in the system (this is known as a \"recursive mutex\").\n\n It is an error to unlock a mutex that has not been locked by the current\n thread, and doing so results in undefined behavior.\n\n It is also an error to unlock a mutex that isn't locked at all.\n\n \\param mutex the mutex to unlock.\n \\returns 0, or -1 on error.\n\n \\since This function is available since SDL 2.0.0."]
     pub fn SDL_UnlockMutex(mutex: *mut SDL_mutex) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Destroy a mutex created with SDL_CreateMutex()."]
-    #[doc = ""]
-    #[doc = " This function must be called on any mutex that is no longer needed. Failure"]
-    #[doc = " to destroy a mutex will result in a system memory or resource leak. While"]
-    #[doc = " it is safe to destroy a mutex that is _unlocked_, it is not safe to attempt"]
-    #[doc = " to destroy a locked mutex, and may result in undefined behavior depending"]
-    #[doc = " on the platform."]
-    #[doc = ""]
-    #[doc = " \\param mutex the mutex to destroy"]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_CreateMutex"]
-    #[doc = " \\sa SDL_LockMutex"]
-    #[doc = " \\sa SDL_TryLockMutex"]
-    #[doc = " \\sa SDL_UnlockMutex"]
+    #[doc = " Destroy a mutex created with SDL_CreateMutex().\n\n This function must be called on any mutex that is no longer needed. Failure\n to destroy a mutex will result in a system memory or resource leak. While\n it is safe to destroy a mutex that is _unlocked_, it is not safe to attempt\n to destroy a locked mutex, and may result in undefined behavior depending\n on the platform.\n\n \\param mutex the mutex to destroy\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_CreateMutex\n \\sa SDL_LockMutex\n \\sa SDL_TryLockMutex\n \\sa SDL_UnlockMutex"]
     pub fn SDL_DestroyMutex(mutex: *mut SDL_mutex);
 }
 #[repr(C)]
@@ -2401,145 +2037,31 @@ pub struct SDL_semaphore {
 }
 pub type SDL_sem = SDL_semaphore;
 extern "C" {
-    #[doc = " Create a semaphore."]
-    #[doc = ""]
-    #[doc = " This function creates a new semaphore and initializes it with the value"]
-    #[doc = " `initial_value`. Each wait operation on the semaphore will atomically"]
-    #[doc = " decrement the semaphore value and potentially block if the semaphore value"]
-    #[doc = " is 0. Each post operation will atomically increment the semaphore value and"]
-    #[doc = " wake waiting threads and allow them to retry the wait operation."]
-    #[doc = ""]
-    #[doc = " \\param initial_value the starting value of the semaphore"]
-    #[doc = " \\returns a new semaphore or NULL on failure; call SDL_GetError() for more"]
-    #[doc = "          information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_DestroySemaphore"]
-    #[doc = " \\sa SDL_SemPost"]
-    #[doc = " \\sa SDL_SemTryWait"]
-    #[doc = " \\sa SDL_SemValue"]
-    #[doc = " \\sa SDL_SemWait"]
-    #[doc = " \\sa SDL_SemWaitTimeout"]
+    #[doc = " Create a semaphore.\n\n This function creates a new semaphore and initializes it with the value\n `initial_value`. Each wait operation on the semaphore will atomically\n decrement the semaphore value and potentially block if the semaphore value\n is 0. Each post operation will atomically increment the semaphore value and\n wake waiting threads and allow them to retry the wait operation.\n\n \\param initial_value the starting value of the semaphore\n \\returns a new semaphore or NULL on failure; call SDL_GetError() for more\n          information.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_DestroySemaphore\n \\sa SDL_SemPost\n \\sa SDL_SemTryWait\n \\sa SDL_SemValue\n \\sa SDL_SemWait\n \\sa SDL_SemWaitTimeout"]
     pub fn SDL_CreateSemaphore(initial_value: Uint32) -> *mut SDL_sem;
 }
 extern "C" {
-    #[doc = " Destroy a semaphore."]
-    #[doc = ""]
-    #[doc = " It is not safe to destroy a semaphore if there are threads currently"]
-    #[doc = " waiting on it."]
-    #[doc = ""]
-    #[doc = " \\param sem the semaphore to destroy"]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_CreateSemaphore"]
-    #[doc = " \\sa SDL_SemPost"]
-    #[doc = " \\sa SDL_SemTryWait"]
-    #[doc = " \\sa SDL_SemValue"]
-    #[doc = " \\sa SDL_SemWait"]
-    #[doc = " \\sa SDL_SemWaitTimeout"]
+    #[doc = " Destroy a semaphore.\n\n It is not safe to destroy a semaphore if there are threads currently\n waiting on it.\n\n \\param sem the semaphore to destroy\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_CreateSemaphore\n \\sa SDL_SemPost\n \\sa SDL_SemTryWait\n \\sa SDL_SemValue\n \\sa SDL_SemWait\n \\sa SDL_SemWaitTimeout"]
     pub fn SDL_DestroySemaphore(sem: *mut SDL_sem);
 }
 extern "C" {
-    #[doc = " Wait until a semaphore has a positive value and then decrements it."]
-    #[doc = ""]
-    #[doc = " This function suspends the calling thread until either the semaphore"]
-    #[doc = " pointed to by `sem` has a positive value or the call is interrupted by a"]
-    #[doc = " signal or error. If the call is successful it will atomically decrement the"]
-    #[doc = " semaphore value."]
-    #[doc = ""]
-    #[doc = " This function is the equivalent of calling SDL_SemWaitTimeout() with a time"]
-    #[doc = " length of `SDL_MUTEX_MAXWAIT`."]
-    #[doc = ""]
-    #[doc = " \\param sem the semaphore wait on"]
-    #[doc = " \\returns 0 on success or a negative error code on failure; call"]
-    #[doc = "          SDL_GetError() for more information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_CreateSemaphore"]
-    #[doc = " \\sa SDL_DestroySemaphore"]
-    #[doc = " \\sa SDL_SemPost"]
-    #[doc = " \\sa SDL_SemTryWait"]
-    #[doc = " \\sa SDL_SemValue"]
-    #[doc = " \\sa SDL_SemWait"]
-    #[doc = " \\sa SDL_SemWaitTimeout"]
+    #[doc = " Wait until a semaphore has a positive value and then decrements it.\n\n This function suspends the calling thread until either the semaphore\n pointed to by `sem` has a positive value or the call is interrupted by a\n signal or error. If the call is successful it will atomically decrement the\n semaphore value.\n\n This function is the equivalent of calling SDL_SemWaitTimeout() with a time\n length of `SDL_MUTEX_MAXWAIT`.\n\n \\param sem the semaphore wait on\n \\returns 0 on success or a negative error code on failure; call\n          SDL_GetError() for more information.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_CreateSemaphore\n \\sa SDL_DestroySemaphore\n \\sa SDL_SemPost\n \\sa SDL_SemTryWait\n \\sa SDL_SemValue\n \\sa SDL_SemWait\n \\sa SDL_SemWaitTimeout"]
     pub fn SDL_SemWait(sem: *mut SDL_sem) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " See if a semaphore has a positive value and decrement it if it does."]
-    #[doc = ""]
-    #[doc = " This function checks to see if the semaphore pointed to by `sem` has a"]
-    #[doc = " positive value and atomically decrements the semaphore value if it does. If"]
-    #[doc = " the semaphore doesn't have a positive value, the function immediately"]
-    #[doc = " returns SDL_MUTEX_TIMEDOUT."]
-    #[doc = ""]
-    #[doc = " \\param sem the semaphore to wait on"]
-    #[doc = " \\returns 0 if the wait succeeds, `SDL_MUTEX_TIMEDOUT` if the wait would"]
-    #[doc = "          block, or a negative error code on failure; call SDL_GetError()"]
-    #[doc = "          for more information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_CreateSemaphore"]
-    #[doc = " \\sa SDL_DestroySemaphore"]
-    #[doc = " \\sa SDL_SemPost"]
-    #[doc = " \\sa SDL_SemValue"]
-    #[doc = " \\sa SDL_SemWait"]
-    #[doc = " \\sa SDL_SemWaitTimeout"]
+    #[doc = " See if a semaphore has a positive value and decrement it if it does.\n\n This function checks to see if the semaphore pointed to by `sem` has a\n positive value and atomically decrements the semaphore value if it does. If\n the semaphore doesn't have a positive value, the function immediately\n returns SDL_MUTEX_TIMEDOUT.\n\n \\param sem the semaphore to wait on\n \\returns 0 if the wait succeeds, `SDL_MUTEX_TIMEDOUT` if the wait would\n          block, or a negative error code on failure; call SDL_GetError()\n          for more information.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_CreateSemaphore\n \\sa SDL_DestroySemaphore\n \\sa SDL_SemPost\n \\sa SDL_SemValue\n \\sa SDL_SemWait\n \\sa SDL_SemWaitTimeout"]
     pub fn SDL_SemTryWait(sem: *mut SDL_sem) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Wait until a semaphore has a positive value and then decrements it."]
-    #[doc = ""]
-    #[doc = " This function suspends the calling thread until either the semaphore"]
-    #[doc = " pointed to by `sem` has a positive value, the call is interrupted by a"]
-    #[doc = " signal or error, or the specified time has elapsed. If the call is"]
-    #[doc = " successful it will atomically decrement the semaphore value."]
-    #[doc = ""]
-    #[doc = " \\param sem the semaphore to wait on"]
-    #[doc = " \\param ms the length of the timeout, in milliseconds"]
-    #[doc = " \\returns 0 if the wait succeeds, `SDL_MUTEX_TIMEDOUT` if the wait does not"]
-    #[doc = "          succeed in the allotted time, or a negative error code on failure;"]
-    #[doc = "          call SDL_GetError() for more information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_CreateSemaphore"]
-    #[doc = " \\sa SDL_DestroySemaphore"]
-    #[doc = " \\sa SDL_SemPost"]
-    #[doc = " \\sa SDL_SemTryWait"]
-    #[doc = " \\sa SDL_SemValue"]
-    #[doc = " \\sa SDL_SemWait"]
+    #[doc = " Wait until a semaphore has a positive value and then decrements it.\n\n This function suspends the calling thread until either the semaphore\n pointed to by `sem` has a positive value, the call is interrupted by a\n signal or error, or the specified time has elapsed. If the call is\n successful it will atomically decrement the semaphore value.\n\n \\param sem the semaphore to wait on\n \\param ms the length of the timeout, in milliseconds\n \\returns 0 if the wait succeeds, `SDL_MUTEX_TIMEDOUT` if the wait does not\n          succeed in the allotted time, or a negative error code on failure;\n          call SDL_GetError() for more information.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_CreateSemaphore\n \\sa SDL_DestroySemaphore\n \\sa SDL_SemPost\n \\sa SDL_SemTryWait\n \\sa SDL_SemValue\n \\sa SDL_SemWait"]
     pub fn SDL_SemWaitTimeout(sem: *mut SDL_sem, ms: Uint32) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Atomically increment a semaphore's value and wake waiting threads."]
-    #[doc = ""]
-    #[doc = " \\param sem the semaphore to increment"]
-    #[doc = " \\returns 0 on success or a negative error code on failure; call"]
-    #[doc = "          SDL_GetError() for more information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_CreateSemaphore"]
-    #[doc = " \\sa SDL_DestroySemaphore"]
-    #[doc = " \\sa SDL_SemTryWait"]
-    #[doc = " \\sa SDL_SemValue"]
-    #[doc = " \\sa SDL_SemWait"]
-    #[doc = " \\sa SDL_SemWaitTimeout"]
+    #[doc = " Atomically increment a semaphore's value and wake waiting threads.\n\n \\param sem the semaphore to increment\n \\returns 0 on success or a negative error code on failure; call\n          SDL_GetError() for more information.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_CreateSemaphore\n \\sa SDL_DestroySemaphore\n \\sa SDL_SemTryWait\n \\sa SDL_SemValue\n \\sa SDL_SemWait\n \\sa SDL_SemWaitTimeout"]
     pub fn SDL_SemPost(sem: *mut SDL_sem) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Get the current value of a semaphore."]
-    #[doc = ""]
-    #[doc = " \\param sem the semaphore to query"]
-    #[doc = " \\returns the current value of the semaphore."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_CreateSemaphore"]
+    #[doc = " Get the current value of a semaphore.\n\n \\param sem the semaphore to query\n \\returns the current value of the semaphore.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_CreateSemaphore"]
     pub fn SDL_SemValue(sem: *mut SDL_sem) -> Uint32;
 }
 #[repr(C)]
@@ -2548,119 +2070,27 @@ pub struct SDL_cond {
     _unused: [u8; 0],
 }
 extern "C" {
-    #[doc = " Create a condition variable."]
-    #[doc = ""]
-    #[doc = " \\returns a new condition variable or NULL on failure; call SDL_GetError()"]
-    #[doc = "          for more information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_CondBroadcast"]
-    #[doc = " \\sa SDL_CondSignal"]
-    #[doc = " \\sa SDL_CondWait"]
-    #[doc = " \\sa SDL_CondWaitTimeout"]
-    #[doc = " \\sa SDL_DestroyCond"]
+    #[doc = " Create a condition variable.\n\n \\returns a new condition variable or NULL on failure; call SDL_GetError()\n          for more information.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_CondBroadcast\n \\sa SDL_CondSignal\n \\sa SDL_CondWait\n \\sa SDL_CondWaitTimeout\n \\sa SDL_DestroyCond"]
     pub fn SDL_CreateCond() -> *mut SDL_cond;
 }
 extern "C" {
-    #[doc = " Destroy a condition variable."]
-    #[doc = ""]
-    #[doc = " \\param cond the condition variable to destroy"]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_CondBroadcast"]
-    #[doc = " \\sa SDL_CondSignal"]
-    #[doc = " \\sa SDL_CondWait"]
-    #[doc = " \\sa SDL_CondWaitTimeout"]
-    #[doc = " \\sa SDL_CreateCond"]
+    #[doc = " Destroy a condition variable.\n\n \\param cond the condition variable to destroy\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_CondBroadcast\n \\sa SDL_CondSignal\n \\sa SDL_CondWait\n \\sa SDL_CondWaitTimeout\n \\sa SDL_CreateCond"]
     pub fn SDL_DestroyCond(cond: *mut SDL_cond);
 }
 extern "C" {
-    #[doc = " Restart one of the threads that are waiting on the condition variable."]
-    #[doc = ""]
-    #[doc = " \\param cond the condition variable to signal"]
-    #[doc = " \\returns 0 on success or a negative error code on failure; call"]
-    #[doc = "          SDL_GetError() for more information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_CondBroadcast"]
-    #[doc = " \\sa SDL_CondWait"]
-    #[doc = " \\sa SDL_CondWaitTimeout"]
-    #[doc = " \\sa SDL_CreateCond"]
-    #[doc = " \\sa SDL_DestroyCond"]
+    #[doc = " Restart one of the threads that are waiting on the condition variable.\n\n \\param cond the condition variable to signal\n \\returns 0 on success or a negative error code on failure; call\n          SDL_GetError() for more information.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_CondBroadcast\n \\sa SDL_CondWait\n \\sa SDL_CondWaitTimeout\n \\sa SDL_CreateCond\n \\sa SDL_DestroyCond"]
     pub fn SDL_CondSignal(cond: *mut SDL_cond) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Restart all threads that are waiting on the condition variable."]
-    #[doc = ""]
-    #[doc = " \\param cond the condition variable to signal"]
-    #[doc = " \\returns 0 on success or a negative error code on failure; call"]
-    #[doc = "          SDL_GetError() for more information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_CondSignal"]
-    #[doc = " \\sa SDL_CondWait"]
-    #[doc = " \\sa SDL_CondWaitTimeout"]
-    #[doc = " \\sa SDL_CreateCond"]
-    #[doc = " \\sa SDL_DestroyCond"]
+    #[doc = " Restart all threads that are waiting on the condition variable.\n\n \\param cond the condition variable to signal\n \\returns 0 on success or a negative error code on failure; call\n          SDL_GetError() for more information.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_CondSignal\n \\sa SDL_CondWait\n \\sa SDL_CondWaitTimeout\n \\sa SDL_CreateCond\n \\sa SDL_DestroyCond"]
     pub fn SDL_CondBroadcast(cond: *mut SDL_cond) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Wait until a condition variable is signaled."]
-    #[doc = ""]
-    #[doc = " This function unlocks the specified `mutex` and waits for another thread to"]
-    #[doc = " call SDL_CondSignal() or SDL_CondBroadcast() on the condition variable"]
-    #[doc = " `cond`. Once the condition variable is signaled, the mutex is re-locked and"]
-    #[doc = " the function returns."]
-    #[doc = ""]
-    #[doc = " The mutex must be locked before calling this function."]
-    #[doc = ""]
-    #[doc = " This function is the equivalent of calling SDL_CondWaitTimeout() with a"]
-    #[doc = " time length of `SDL_MUTEX_MAXWAIT`."]
-    #[doc = ""]
-    #[doc = " \\param cond the condition variable to wait on"]
-    #[doc = " \\param mutex the mutex used to coordinate thread access"]
-    #[doc = " \\returns 0 when it is signaled or a negative error code on failure; call"]
-    #[doc = "          SDL_GetError() for more information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_CondBroadcast"]
-    #[doc = " \\sa SDL_CondSignal"]
-    #[doc = " \\sa SDL_CondWaitTimeout"]
-    #[doc = " \\sa SDL_CreateCond"]
-    #[doc = " \\sa SDL_DestroyCond"]
+    #[doc = " Wait until a condition variable is signaled.\n\n This function unlocks the specified `mutex` and waits for another thread to\n call SDL_CondSignal() or SDL_CondBroadcast() on the condition variable\n `cond`. Once the condition variable is signaled, the mutex is re-locked and\n the function returns.\n\n The mutex must be locked before calling this function.\n\n This function is the equivalent of calling SDL_CondWaitTimeout() with a\n time length of `SDL_MUTEX_MAXWAIT`.\n\n \\param cond the condition variable to wait on\n \\param mutex the mutex used to coordinate thread access\n \\returns 0 when it is signaled or a negative error code on failure; call\n          SDL_GetError() for more information.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_CondBroadcast\n \\sa SDL_CondSignal\n \\sa SDL_CondWaitTimeout\n \\sa SDL_CreateCond\n \\sa SDL_DestroyCond"]
     pub fn SDL_CondWait(cond: *mut SDL_cond, mutex: *mut SDL_mutex) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Wait until a condition variable is signaled or a certain time has passed."]
-    #[doc = ""]
-    #[doc = " This function unlocks the specified `mutex` and waits for another thread to"]
-    #[doc = " call SDL_CondSignal() or SDL_CondBroadcast() on the condition variable"]
-    #[doc = " `cond`, or for the specified time to elapse. Once the condition variable is"]
-    #[doc = " signaled or the time elapsed, the mutex is re-locked and the function"]
-    #[doc = " returns."]
-    #[doc = ""]
-    #[doc = " The mutex must be locked before calling this function."]
-    #[doc = ""]
-    #[doc = " \\param cond the condition variable to wait on"]
-    #[doc = " \\param mutex the mutex used to coordinate thread access"]
-    #[doc = " \\param ms the maximum time to wait, in milliseconds, or `SDL_MUTEX_MAXWAIT`"]
-    #[doc = "           to wait indefinitely"]
-    #[doc = " \\returns 0 if the condition variable is signaled, `SDL_MUTEX_TIMEDOUT` if"]
-    #[doc = "          the condition is not signaled in the allotted time, or a negative"]
-    #[doc = "          error code on failure; call SDL_GetError() for more information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_CondBroadcast"]
-    #[doc = " \\sa SDL_CondSignal"]
-    #[doc = " \\sa SDL_CondWait"]
-    #[doc = " \\sa SDL_CreateCond"]
-    #[doc = " \\sa SDL_DestroyCond"]
+    #[doc = " Wait until a condition variable is signaled or a certain time has passed.\n\n This function unlocks the specified `mutex` and waits for another thread to\n call SDL_CondSignal() or SDL_CondBroadcast() on the condition variable\n `cond`, or for the specified time to elapse. Once the condition variable is\n signaled or the time elapsed, the mutex is re-locked and the function\n returns.\n\n The mutex must be locked before calling this function.\n\n \\param cond the condition variable to wait on\n \\param mutex the mutex used to coordinate thread access\n \\param ms the maximum time to wait, in milliseconds, or `SDL_MUTEX_MAXWAIT`\n           to wait indefinitely\n \\returns 0 if the condition variable is signaled, `SDL_MUTEX_TIMEDOUT` if\n          the condition is not signaled in the allotted time, or a negative\n          error code on failure; call SDL_GetError() for more information.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_CondBroadcast\n \\sa SDL_CondSignal\n \\sa SDL_CondWait\n \\sa SDL_CreateCond\n \\sa SDL_DestroyCond"]
     pub fn SDL_CondWaitTimeout(
         cond: *mut SDL_cond,
         mutex: *mut SDL_mutex,
@@ -2675,47 +2105,19 @@ pub struct SDL_Thread {
 pub type SDL_threadID = libc::c_ulong;
 pub type SDL_TLSID = libc::c_uint;
 #[repr(u32)]
-#[doc = "  The SDL thread priority."]
-#[doc = ""]
-#[doc = "  SDL will make system changes as necessary in order to apply the thread priority."]
-#[doc = "  Code which attempts to control thread state related to priority should be aware"]
-#[doc = "  that calling SDL_SetThreadPriority may alter such state."]
-#[doc = "  SDL_HINT_THREAD_PRIORITY_POLICY can be used to control aspects of this behavior."]
-#[doc = ""]
-#[doc = "  \\note On many systems you require special privileges to set high or time critical priority."]
-#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
+#[doc = "  The SDL thread priority.\n\n  SDL will make system changes as necessary in order to apply the thread priority.\n  Code which attempts to control thread state related to priority should be aware\n  that calling SDL_SetThreadPriority may alter such state.\n  SDL_HINT_THREAD_PRIORITY_POLICY can be used to control aspects of this behavior.\n\n  \\note On many systems you require special privileges to set high or time critical priority."]
+#[derive(Copy, Clone, Hash, PartialEq, Eq)]
 pub enum SDL_ThreadPriority {
     SDL_THREAD_PRIORITY_LOW = 0,
     SDL_THREAD_PRIORITY_NORMAL = 1,
     SDL_THREAD_PRIORITY_HIGH = 2,
     SDL_THREAD_PRIORITY_TIME_CRITICAL = 3,
 }
-#[doc = " The function passed to SDL_CreateThread()."]
-#[doc = ""]
-#[doc = " \\param data what was passed as `data` to SDL_CreateThread()"]
-#[doc = " \\returns a value that can be reported through SDL_WaitThread()."]
+#[doc = " The function passed to SDL_CreateThread().\n\n \\param data what was passed as `data` to SDL_CreateThread()\n \\returns a value that can be reported through SDL_WaitThread()."]
 pub type SDL_ThreadFunction =
     ::core::option::Option<unsafe extern "C" fn(data: *mut libc::c_void) -> libc::c_int>;
 extern "C" {
-    #[doc = " Create a new thread with a default stack size."]
-    #[doc = ""]
-    #[doc = " This is equivalent to calling:"]
-    #[doc = ""]
-    #[doc = " ```c"]
-    #[doc = " SDL_CreateThreadWithStackSize(fn, name, 0, data);"]
-    #[doc = " ```"]
-    #[doc = ""]
-    #[doc = " \\param fn the SDL_ThreadFunction function to call in the new thread"]
-    #[doc = " \\param name the name of the thread"]
-    #[doc = " \\param data a pointer that is passed to `fn`"]
-    #[doc = " \\returns an opaque pointer to the new thread object on success, NULL if the"]
-    #[doc = "          new thread could not be created; call SDL_GetError() for more"]
-    #[doc = "          information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_CreateThreadWithStackSize"]
-    #[doc = " \\sa SDL_WaitThread"]
+    #[doc = " Create a new thread with a default stack size.\n\n This is equivalent to calling:\n\n ```c\n SDL_CreateThreadWithStackSize(fn, name, 0, data);\n ```\n\n \\param fn the SDL_ThreadFunction function to call in the new thread\n \\param name the name of the thread\n \\param data a pointer that is passed to `fn`\n \\returns an opaque pointer to the new thread object on success, NULL if the\n          new thread could not be created; call SDL_GetError() for more\n          information.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_CreateThreadWithStackSize\n \\sa SDL_WaitThread"]
     pub fn SDL_CreateThread(
         fn_: SDL_ThreadFunction,
         name: *const libc::c_char,
@@ -2723,234 +2125,48 @@ extern "C" {
     ) -> *mut SDL_Thread;
 }
 extern "C" {
-    #[doc = " Create a new thread with a specific stack size."]
-    #[doc = ""]
-    #[doc = " SDL makes an attempt to report `name` to the system, so that debuggers can"]
-    #[doc = " display it. Not all platforms support this."]
-    #[doc = ""]
-    #[doc = " Thread naming is a little complicated: Most systems have very small limits"]
-    #[doc = " for the string length (Haiku has 32 bytes, Linux currently has 16, Visual"]
-    #[doc = " C++ 6.0 has _nine_!), and possibly other arbitrary rules. You'll have to"]
-    #[doc = " see what happens with your system's debugger. The name should be UTF-8 (but"]
-    #[doc = " using the naming limits of C identifiers is a better bet). There are no"]
-    #[doc = " requirements for thread naming conventions, so long as the string is"]
-    #[doc = " null-terminated UTF-8, but these guidelines are helpful in choosing a name:"]
-    #[doc = ""]
-    #[doc = " https://stackoverflow.com/questions/149932/naming-conventions-for-threads"]
-    #[doc = ""]
-    #[doc = " If a system imposes requirements, SDL will try to munge the string for it"]
-    #[doc = " (truncate, etc), but the original string contents will be available from"]
-    #[doc = " SDL_GetThreadName()."]
-    #[doc = ""]
-    #[doc = " The size (in bytes) of the new stack can be specified. Zero means \"use the"]
-    #[doc = " system default\" which might be wildly different between platforms. x86"]
-    #[doc = " Linux generally defaults to eight megabytes, an embedded device might be a"]
-    #[doc = " few kilobytes instead. You generally need to specify a stack that is a"]
-    #[doc = " multiple of the system's page size (in many cases, this is 4 kilobytes, but"]
-    #[doc = " check your system documentation)."]
-    #[doc = ""]
-    #[doc = " In SDL 2.1, stack size will be folded into the original SDL_CreateThread"]
-    #[doc = " function, but for backwards compatibility, this is currently a separate"]
-    #[doc = " function."]
-    #[doc = ""]
-    #[doc = " \\param fn the SDL_ThreadFunction function to call in the new thread"]
-    #[doc = " \\param name the name of the thread"]
-    #[doc = " \\param stacksize the size, in bytes, to allocate for the new thread stack."]
-    #[doc = " \\param data a pointer that is passed to `fn`"]
-    #[doc = " \\returns an opaque pointer to the new thread object on success, NULL if the"]
-    #[doc = "          new thread could not be created; call SDL_GetError() for more"]
-    #[doc = "          information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.9."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_WaitThread"]
+    #[doc = " Create a new thread with a specific stack size.\n\n SDL makes an attempt to report `name` to the system, so that debuggers can\n display it. Not all platforms support this.\n\n Thread naming is a little complicated: Most systems have very small limits\n for the string length (Haiku has 32 bytes, Linux currently has 16, Visual\n C++ 6.0 has _nine_!), and possibly other arbitrary rules. You'll have to\n see what happens with your system's debugger. The name should be UTF-8 (but\n using the naming limits of C identifiers is a better bet). There are no\n requirements for thread naming conventions, so long as the string is\n null-terminated UTF-8, but these guidelines are helpful in choosing a name:\n\n https://stackoverflow.com/questions/149932/naming-conventions-for-threads\n\n If a system imposes requirements, SDL will try to munge the string for it\n (truncate, etc), but the original string contents will be available from\n SDL_GetThreadName().\n\n The size (in bytes) of the new stack can be specified. Zero means \"use the\n system default\" which might be wildly different between platforms. x86\n Linux generally defaults to eight megabytes, an embedded device might be a\n few kilobytes instead. You generally need to specify a stack that is a\n multiple of the system's page size (in many cases, this is 4 kilobytes, but\n check your system documentation).\n\n In SDL 2.1, stack size will be folded into the original SDL_CreateThread\n function, but for backwards compatibility, this is currently a separate\n function.\n\n \\param fn the SDL_ThreadFunction function to call in the new thread\n \\param name the name of the thread\n \\param stacksize the size, in bytes, to allocate for the new thread stack.\n \\param data a pointer that is passed to `fn`\n \\returns an opaque pointer to the new thread object on success, NULL if the\n          new thread could not be created; call SDL_GetError() for more\n          information.\n\n \\since This function is available since SDL 2.0.9.\n\n \\sa SDL_WaitThread"]
     pub fn SDL_CreateThreadWithStackSize(
         fn_: SDL_ThreadFunction,
         name: *const libc::c_char,
-        stacksize: size_t,
+        stacksize: usize,
         data: *mut libc::c_void,
     ) -> *mut SDL_Thread;
 }
 extern "C" {
-    #[doc = " Get the thread name as it was specified in SDL_CreateThread()."]
-    #[doc = ""]
-    #[doc = " This is internal memory, not to be freed by the caller, and remains valid"]
-    #[doc = " until the specified thread is cleaned up by SDL_WaitThread()."]
-    #[doc = ""]
-    #[doc = " \\param thread the thread to query"]
-    #[doc = " \\returns a pointer to a UTF-8 string that names the specified thread, or"]
-    #[doc = "          NULL if it doesn't have a name."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_CreateThread"]
+    #[doc = " Get the thread name as it was specified in SDL_CreateThread().\n\n This is internal memory, not to be freed by the caller, and remains valid\n until the specified thread is cleaned up by SDL_WaitThread().\n\n \\param thread the thread to query\n \\returns a pointer to a UTF-8 string that names the specified thread, or\n          NULL if it doesn't have a name.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_CreateThread"]
     pub fn SDL_GetThreadName(thread: *mut SDL_Thread) -> *const libc::c_char;
 }
 extern "C" {
-    #[doc = " Get the thread identifier for the current thread."]
-    #[doc = ""]
-    #[doc = " This thread identifier is as reported by the underlying operating system."]
-    #[doc = " If SDL is running on a platform that does not support threads the return"]
-    #[doc = " value will always be zero."]
-    #[doc = ""]
-    #[doc = " This function also returns a valid thread ID when called from the main"]
-    #[doc = " thread."]
-    #[doc = ""]
-    #[doc = " \\returns the ID of the current thread."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_GetThreadID"]
+    #[doc = " Get the thread identifier for the current thread.\n\n This thread identifier is as reported by the underlying operating system.\n If SDL is running on a platform that does not support threads the return\n value will always be zero.\n\n This function also returns a valid thread ID when called from the main\n thread.\n\n \\returns the ID of the current thread.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_GetThreadID"]
     pub fn SDL_ThreadID() -> SDL_threadID;
 }
 extern "C" {
-    #[doc = " Get the thread identifier for the specified thread."]
-    #[doc = ""]
-    #[doc = " This thread identifier is as reported by the underlying operating system."]
-    #[doc = " If SDL is running on a platform that does not support threads the return"]
-    #[doc = " value will always be zero."]
-    #[doc = ""]
-    #[doc = " \\param thread the thread to query"]
-    #[doc = " \\returns the ID of the specified thread, or the ID of the current thread if"]
-    #[doc = "          `thread` is NULL."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_ThreadID"]
+    #[doc = " Get the thread identifier for the specified thread.\n\n This thread identifier is as reported by the underlying operating system.\n If SDL is running on a platform that does not support threads the return\n value will always be zero.\n\n \\param thread the thread to query\n \\returns the ID of the specified thread, or the ID of the current thread if\n          `thread` is NULL.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_ThreadID"]
     pub fn SDL_GetThreadID(thread: *mut SDL_Thread) -> SDL_threadID;
 }
 extern "C" {
-    #[doc = " Set the priority for the current thread."]
-    #[doc = ""]
-    #[doc = " Note that some platforms will not let you alter the priority (or at least,"]
-    #[doc = " promote the thread to a higher priority) at all, and some require you to be"]
-    #[doc = " an administrator account. Be prepared for this to fail."]
-    #[doc = ""]
-    #[doc = " \\param priority the SDL_ThreadPriority to set"]
-    #[doc = " \\returns 0 on success or a negative error code on failure; call"]
-    #[doc = "          SDL_GetError() for more information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
+    #[doc = " Set the priority for the current thread.\n\n Note that some platforms will not let you alter the priority (or at least,\n promote the thread to a higher priority) at all, and some require you to be\n an administrator account. Be prepared for this to fail.\n\n \\param priority the SDL_ThreadPriority to set\n \\returns 0 on success or a negative error code on failure; call\n          SDL_GetError() for more information.\n\n \\since This function is available since SDL 2.0.0."]
     pub fn SDL_SetThreadPriority(priority: SDL_ThreadPriority) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Wait for a thread to finish."]
-    #[doc = ""]
-    #[doc = " Threads that haven't been detached will remain (as a \"zombie\") until this"]
-    #[doc = " function cleans them up. Not doing so is a resource leak."]
-    #[doc = ""]
-    #[doc = " Once a thread has been cleaned up through this function, the SDL_Thread"]
-    #[doc = " that references it becomes invalid and should not be referenced again. As"]
-    #[doc = " such, only one thread may call SDL_WaitThread() on another."]
-    #[doc = ""]
-    #[doc = " The return code for the thread function is placed in the area pointed to by"]
-    #[doc = " `status`, if `status` is not NULL."]
-    #[doc = ""]
-    #[doc = " You may not wait on a thread that has been used in a call to"]
-    #[doc = " SDL_DetachThread(). Use either that function or this one, but not both, or"]
-    #[doc = " behavior is undefined."]
-    #[doc = ""]
-    #[doc = " It is safe to pass a NULL thread to this function; it is a no-op."]
-    #[doc = ""]
-    #[doc = " Note that the thread pointer is freed by this function and is not valid"]
-    #[doc = " afterward."]
-    #[doc = ""]
-    #[doc = " \\param thread the SDL_Thread pointer that was returned from the"]
-    #[doc = "               SDL_CreateThread() call that started this thread"]
-    #[doc = " \\param status pointer to an integer that will receive the value returned"]
-    #[doc = "               from the thread function by its 'return', or NULL to not"]
-    #[doc = "               receive such value back."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_CreateThread"]
-    #[doc = " \\sa SDL_DetachThread"]
+    #[doc = " Wait for a thread to finish.\n\n Threads that haven't been detached will remain (as a \"zombie\") until this\n function cleans them up. Not doing so is a resource leak.\n\n Once a thread has been cleaned up through this function, the SDL_Thread\n that references it becomes invalid and should not be referenced again. As\n such, only one thread may call SDL_WaitThread() on another.\n\n The return code for the thread function is placed in the area pointed to by\n `status`, if `status` is not NULL.\n\n You may not wait on a thread that has been used in a call to\n SDL_DetachThread(). Use either that function or this one, but not both, or\n behavior is undefined.\n\n It is safe to pass a NULL thread to this function; it is a no-op.\n\n Note that the thread pointer is freed by this function and is not valid\n afterward.\n\n \\param thread the SDL_Thread pointer that was returned from the\n               SDL_CreateThread() call that started this thread\n \\param status pointer to an integer that will receive the value returned\n               from the thread function by its 'return', or NULL to not\n               receive such value back.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_CreateThread\n \\sa SDL_DetachThread"]
     pub fn SDL_WaitThread(thread: *mut SDL_Thread, status: *mut libc::c_int);
 }
 extern "C" {
-    #[doc = " Let a thread clean up on exit without intervention."]
-    #[doc = ""]
-    #[doc = " A thread may be \"detached\" to signify that it should not remain until"]
-    #[doc = " another thread has called SDL_WaitThread() on it. Detaching a thread is"]
-    #[doc = " useful for long-running threads that nothing needs to synchronize with or"]
-    #[doc = " further manage. When a detached thread is done, it simply goes away."]
-    #[doc = ""]
-    #[doc = " There is no way to recover the return code of a detached thread. If you"]
-    #[doc = " need this, don't detach the thread and instead use SDL_WaitThread()."]
-    #[doc = ""]
-    #[doc = " Once a thread is detached, you should usually assume the SDL_Thread isn't"]
-    #[doc = " safe to reference again, as it will become invalid immediately upon the"]
-    #[doc = " detached thread's exit, instead of remaining until someone has called"]
-    #[doc = " SDL_WaitThread() to finally clean it up. As such, don't detach the same"]
-    #[doc = " thread more than once."]
-    #[doc = ""]
-    #[doc = " If a thread has already exited when passed to SDL_DetachThread(), it will"]
-    #[doc = " stop waiting for a call to SDL_WaitThread() and clean up immediately. It is"]
-    #[doc = " not safe to detach a thread that might be used with SDL_WaitThread()."]
-    #[doc = ""]
-    #[doc = " You may not call SDL_WaitThread() on a thread that has been detached. Use"]
-    #[doc = " either that function or this one, but not both, or behavior is undefined."]
-    #[doc = ""]
-    #[doc = " It is safe to pass NULL to this function; it is a no-op."]
-    #[doc = ""]
-    #[doc = " \\param thread the SDL_Thread pointer that was returned from the"]
-    #[doc = "               SDL_CreateThread() call that started this thread"]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.2."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_CreateThread"]
-    #[doc = " \\sa SDL_WaitThread"]
+    #[doc = " Let a thread clean up on exit without intervention.\n\n A thread may be \"detached\" to signify that it should not remain until\n another thread has called SDL_WaitThread() on it. Detaching a thread is\n useful for long-running threads that nothing needs to synchronize with or\n further manage. When a detached thread is done, it simply goes away.\n\n There is no way to recover the return code of a detached thread. If you\n need this, don't detach the thread and instead use SDL_WaitThread().\n\n Once a thread is detached, you should usually assume the SDL_Thread isn't\n safe to reference again, as it will become invalid immediately upon the\n detached thread's exit, instead of remaining until someone has called\n SDL_WaitThread() to finally clean it up. As such, don't detach the same\n thread more than once.\n\n If a thread has already exited when passed to SDL_DetachThread(), it will\n stop waiting for a call to SDL_WaitThread() and clean up immediately. It is\n not safe to detach a thread that might be used with SDL_WaitThread().\n\n You may not call SDL_WaitThread() on a thread that has been detached. Use\n either that function or this one, but not both, or behavior is undefined.\n\n It is safe to pass NULL to this function; it is a no-op.\n\n \\param thread the SDL_Thread pointer that was returned from the\n               SDL_CreateThread() call that started this thread\n\n \\since This function is available since SDL 2.0.2.\n\n \\sa SDL_CreateThread\n \\sa SDL_WaitThread"]
     pub fn SDL_DetachThread(thread: *mut SDL_Thread);
 }
 extern "C" {
-    #[doc = " Create a piece of thread-local storage."]
-    #[doc = ""]
-    #[doc = " This creates an identifier that is globally visible to all threads but"]
-    #[doc = " refers to data that is thread-specific."]
-    #[doc = ""]
-    #[doc = " \\returns the newly created thread local storage identifier or 0 on error."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_TLSGet"]
-    #[doc = " \\sa SDL_TLSSet"]
+    #[doc = " Create a piece of thread-local storage.\n\n This creates an identifier that is globally visible to all threads but\n refers to data that is thread-specific.\n\n \\returns the newly created thread local storage identifier or 0 on error.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_TLSGet\n \\sa SDL_TLSSet"]
     pub fn SDL_TLSCreate() -> SDL_TLSID;
 }
 extern "C" {
-    #[doc = " Get the current thread's value associated with a thread local storage ID."]
-    #[doc = ""]
-    #[doc = " \\param id the thread local storage ID"]
-    #[doc = " \\returns the value associated with the ID for the current thread or NULL if"]
-    #[doc = "          no value has been set; call SDL_GetError() for more information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_TLSCreate"]
-    #[doc = " \\sa SDL_TLSSet"]
+    #[doc = " Get the current thread's value associated with a thread local storage ID.\n\n \\param id the thread local storage ID\n \\returns the value associated with the ID for the current thread or NULL if\n          no value has been set; call SDL_GetError() for more information.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_TLSCreate\n \\sa SDL_TLSSet"]
     pub fn SDL_TLSGet(id: SDL_TLSID) -> *mut libc::c_void;
 }
 extern "C" {
-    #[doc = " Set the current thread's value associated with a thread local storage ID."]
-    #[doc = ""]
-    #[doc = " The function prototype for `destructor` is:"]
-    #[doc = ""]
-    #[doc = " ```c"]
-    #[doc = " void destructor(void *value)"]
-    #[doc = " ```"]
-    #[doc = ""]
-    #[doc = " where its parameter `value` is what was passed as `value` to SDL_TLSSet()."]
-    #[doc = ""]
-    #[doc = " \\param id the thread local storage ID"]
-    #[doc = " \\param value the value to associate with the ID for the current thread"]
-    #[doc = " \\param destructor a function called when the thread exits, to free the"]
-    #[doc = "                   value"]
-    #[doc = " \\returns 0 on success or a negative error code on failure; call"]
-    #[doc = "          SDL_GetError() for more information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_TLSCreate"]
-    #[doc = " \\sa SDL_TLSGet"]
+    #[doc = " Set the current thread's value associated with a thread local storage ID.\n\n The function prototype for `destructor` is:\n\n ```c\n void destructor(void *value)\n ```\n\n where its parameter `value` is what was passed as `value` to SDL_TLSSet().\n\n \\param id the thread local storage ID\n \\param value the value to associate with the ID for the current thread\n \\param destructor a function called when the thread exits, to free the\n                   value\n \\returns 0 on success or a negative error code on failure; call\n          SDL_GetError() for more information.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_TLSCreate\n \\sa SDL_TLSGet"]
     pub fn SDL_TLSSet(
         id: SDL_TLSID,
         value: *const libc::c_void,
@@ -2958,9 +2174,7 @@ extern "C" {
     ) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Cleanup all TLS data for this thread."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.16."]
+    #[doc = " Cleanup all TLS data for this thread.\n\n \\since This function is available since SDL 2.0.16."]
     pub fn SDL_TLSCleanup();
 }
 #[doc = " This is the read/write operation structure -- very basic."]
@@ -2969,10 +2183,7 @@ extern "C" {
 pub struct SDL_RWops {
     #[doc = "  Return the size of the file in this rwops, or -1 if unknown"]
     pub size: ::core::option::Option<unsafe extern "C" fn(context: *mut SDL_RWops) -> Sint64>,
-    #[doc = "  Seek to \\c offset relative to \\c whence, one of stdio's whence values:"]
-    #[doc = "  RW_SEEK_SET, RW_SEEK_CUR, RW_SEEK_END"]
-    #[doc = ""]
-    #[doc = "  \\return the final offset in the data stream, or -1 on error."]
+    #[doc = "  Seek to \\c offset relative to \\c whence, one of stdio's whence values:\n  RW_SEEK_SET, RW_SEEK_CUR, RW_SEEK_END\n\n  \\return the final offset in the data stream, or -1 on error."]
     pub seek: ::core::option::Option<
         unsafe extern "C" fn(
             context: *mut SDL_RWops,
@@ -2980,33 +2191,25 @@ pub struct SDL_RWops {
             whence: libc::c_int,
         ) -> Sint64,
     >,
-    #[doc = "  Read up to \\c maxnum objects each of size \\c size from the data"]
-    #[doc = "  stream to the area pointed at by \\c ptr."]
-    #[doc = ""]
-    #[doc = "  \\return the number of objects read, or 0 at error or end of file."]
+    #[doc = "  Read up to \\c maxnum objects each of size \\c size from the data\n  stream to the area pointed at by \\c ptr.\n\n  \\return the number of objects read, or 0 at error or end of file."]
     pub read: ::core::option::Option<
         unsafe extern "C" fn(
             context: *mut SDL_RWops,
             ptr: *mut libc::c_void,
-            size: size_t,
-            maxnum: size_t,
-        ) -> size_t,
+            size: usize,
+            maxnum: usize,
+        ) -> usize,
     >,
-    #[doc = "  Write exactly \\c num objects each of size \\c size from the area"]
-    #[doc = "  pointed at by \\c ptr to data stream."]
-    #[doc = ""]
-    #[doc = "  \\return the number of objects written, or 0 at error or end of file."]
+    #[doc = "  Write exactly \\c num objects each of size \\c size from the area\n  pointed at by \\c ptr to data stream.\n\n  \\return the number of objects written, or 0 at error or end of file."]
     pub write: ::core::option::Option<
         unsafe extern "C" fn(
             context: *mut SDL_RWops,
             ptr: *const libc::c_void,
-            size: size_t,
-            num: size_t,
-        ) -> size_t,
+            size: usize,
+            num: usize,
+        ) -> usize,
     >,
-    #[doc = "  Close and free an allocated SDL_RWops structure."]
-    #[doc = ""]
-    #[doc = "  \\return 0 if successful or -1 on write error when flushing data."]
+    #[doc = "  Close and free an allocated SDL_RWops structure.\n\n  \\return 0 if successful or -1 on write error when flushing data."]
     pub close: ::core::option::Option<unsafe extern "C" fn(context: *mut SDL_RWops) -> libc::c_int>,
     pub type_: Uint32,
     pub hidden: SDL_RWops__bindgen_ty_1,
@@ -3016,7 +2219,6 @@ pub struct SDL_RWops {
 pub union SDL_RWops__bindgen_ty_1 {
     pub mem: SDL_RWops__bindgen_ty_1__bindgen_ty_1,
     pub unknown: SDL_RWops__bindgen_ty_1__bindgen_ty_2,
-    _bindgen_union_align: [u64; 3usize],
 }
 #[repr(C)]
 #[derive(Copy, Clone)]
@@ -3027,6 +2229,9 @@ pub struct SDL_RWops__bindgen_ty_1__bindgen_ty_1 {
 }
 #[test]
 fn bindgen_test_layout_SDL_RWops__bindgen_ty_1__bindgen_ty_1() {
+    const UNINIT: ::core::mem::MaybeUninit<SDL_RWops__bindgen_ty_1__bindgen_ty_1> =
+        ::core::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::core::mem::size_of::<SDL_RWops__bindgen_ty_1__bindgen_ty_1>(),
         24usize,
@@ -3044,10 +2249,7 @@ fn bindgen_test_layout_SDL_RWops__bindgen_ty_1__bindgen_ty_1() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::core::ptr::null::<SDL_RWops__bindgen_ty_1__bindgen_ty_1>())).base as *const _
-                as usize
-        },
+        unsafe { ::core::ptr::addr_of!((*ptr).base) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -3057,10 +2259,7 @@ fn bindgen_test_layout_SDL_RWops__bindgen_ty_1__bindgen_ty_1() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::core::ptr::null::<SDL_RWops__bindgen_ty_1__bindgen_ty_1>())).here as *const _
-                as usize
-        },
+        unsafe { ::core::ptr::addr_of!((*ptr).here) as usize - ptr as usize },
         8usize,
         concat!(
             "Offset of field: ",
@@ -3070,10 +2269,7 @@ fn bindgen_test_layout_SDL_RWops__bindgen_ty_1__bindgen_ty_1() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::core::ptr::null::<SDL_RWops__bindgen_ty_1__bindgen_ty_1>())).stop as *const _
-                as usize
-        },
+        unsafe { ::core::ptr::addr_of!((*ptr).stop) as usize - ptr as usize },
         16usize,
         concat!(
             "Offset of field: ",
@@ -3091,6 +2287,9 @@ pub struct SDL_RWops__bindgen_ty_1__bindgen_ty_2 {
 }
 #[test]
 fn bindgen_test_layout_SDL_RWops__bindgen_ty_1__bindgen_ty_2() {
+    const UNINIT: ::core::mem::MaybeUninit<SDL_RWops__bindgen_ty_1__bindgen_ty_2> =
+        ::core::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::core::mem::size_of::<SDL_RWops__bindgen_ty_1__bindgen_ty_2>(),
         16usize,
@@ -3108,10 +2307,7 @@ fn bindgen_test_layout_SDL_RWops__bindgen_ty_1__bindgen_ty_2() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::core::ptr::null::<SDL_RWops__bindgen_ty_1__bindgen_ty_2>())).data1 as *const _
-                as usize
-        },
+        unsafe { ::core::ptr::addr_of!((*ptr).data1) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -3121,10 +2317,7 @@ fn bindgen_test_layout_SDL_RWops__bindgen_ty_1__bindgen_ty_2() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::core::ptr::null::<SDL_RWops__bindgen_ty_1__bindgen_ty_2>())).data2 as *const _
-                as usize
-        },
+        unsafe { ::core::ptr::addr_of!((*ptr).data2) as usize - ptr as usize },
         8usize,
         concat!(
             "Offset of field: ",
@@ -3136,6 +2329,9 @@ fn bindgen_test_layout_SDL_RWops__bindgen_ty_1__bindgen_ty_2() {
 }
 #[test]
 fn bindgen_test_layout_SDL_RWops__bindgen_ty_1() {
+    const UNINIT: ::core::mem::MaybeUninit<SDL_RWops__bindgen_ty_1> =
+        ::core::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::core::mem::size_of::<SDL_RWops__bindgen_ty_1>(),
         24usize,
@@ -3147,7 +2343,7 @@ fn bindgen_test_layout_SDL_RWops__bindgen_ty_1() {
         concat!("Alignment of ", stringify!(SDL_RWops__bindgen_ty_1))
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_RWops__bindgen_ty_1>())).mem as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).mem) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -3157,9 +2353,7 @@ fn bindgen_test_layout_SDL_RWops__bindgen_ty_1() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::core::ptr::null::<SDL_RWops__bindgen_ty_1>())).unknown as *const _ as usize
-        },
+        unsafe { ::core::ptr::addr_of!((*ptr).unknown) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -3171,6 +2365,8 @@ fn bindgen_test_layout_SDL_RWops__bindgen_ty_1() {
 }
 #[test]
 fn bindgen_test_layout_SDL_RWops() {
+    const UNINIT: ::core::mem::MaybeUninit<SDL_RWops> = ::core::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::core::mem::size_of::<SDL_RWops>(),
         72usize,
@@ -3182,7 +2378,7 @@ fn bindgen_test_layout_SDL_RWops() {
         concat!("Alignment of ", stringify!(SDL_RWops))
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_RWops>())).size as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -3192,7 +2388,7 @@ fn bindgen_test_layout_SDL_RWops() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_RWops>())).seek as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).seek) as usize - ptr as usize },
         8usize,
         concat!(
             "Offset of field: ",
@@ -3202,7 +2398,7 @@ fn bindgen_test_layout_SDL_RWops() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_RWops>())).read as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).read) as usize - ptr as usize },
         16usize,
         concat!(
             "Offset of field: ",
@@ -3212,7 +2408,7 @@ fn bindgen_test_layout_SDL_RWops() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_RWops>())).write as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).write) as usize - ptr as usize },
         24usize,
         concat!(
             "Offset of field: ",
@@ -3222,7 +2418,7 @@ fn bindgen_test_layout_SDL_RWops() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_RWops>())).close as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).close) as usize - ptr as usize },
         32usize,
         concat!(
             "Offset of field: ",
@@ -3232,7 +2428,7 @@ fn bindgen_test_layout_SDL_RWops() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_RWops>())).type_ as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
         40usize,
         concat!(
             "Offset of field: ",
@@ -3242,7 +2438,7 @@ fn bindgen_test_layout_SDL_RWops() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_RWops>())).hidden as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).hidden) as usize - ptr as usize },
         48usize,
         concat!(
             "Offset of field: ",
@@ -3253,683 +2449,138 @@ fn bindgen_test_layout_SDL_RWops() {
     );
 }
 extern "C" {
-    #[doc = " Use this function to create a new SDL_RWops structure for reading from"]
-    #[doc = " and/or writing to a named file."]
-    #[doc = ""]
-    #[doc = " The `mode` string is treated roughly the same as in a call to the C"]
-    #[doc = " library's fopen(), even if SDL doesn't happen to use fopen() behind the"]
-    #[doc = " scenes."]
-    #[doc = ""]
-    #[doc = " Available `mode` strings:"]
-    #[doc = ""]
-    #[doc = " - \"r\": Open a file for reading. The file must exist."]
-    #[doc = " - \"w\": Create an empty file for writing. If a file with the same name"]
-    #[doc = "   already exists its content is erased and the file is treated as a new"]
-    #[doc = "   empty file."]
-    #[doc = " - \"a\": Append to a file. Writing operations append data at the end of the"]
-    #[doc = "   file. The file is created if it does not exist."]
-    #[doc = " - \"r+\": Open a file for update both reading and writing. The file must"]
-    #[doc = "   exist."]
-    #[doc = " - \"w+\": Create an empty file for both reading and writing. If a file with"]
-    #[doc = "   the same name already exists its content is erased and the file is"]
-    #[doc = "   treated as a new empty file."]
-    #[doc = " - \"a+\": Open a file for reading and appending. All writing operations are"]
-    #[doc = "   performed at the end of the file, protecting the previous content to be"]
-    #[doc = "   overwritten. You can reposition (fseek, rewind) the internal pointer to"]
-    #[doc = "   anywhere in the file for reading, but writing operations will move it"]
-    #[doc = "   back to the end of file. The file is created if it does not exist."]
-    #[doc = ""]
-    #[doc = " **NOTE**: In order to open a file as a binary file, a \"b\" character has to"]
-    #[doc = " be included in the `mode` string. This additional \"b\" character can either"]
-    #[doc = " be appended at the end of the string (thus making the following compound"]
-    #[doc = " modes: \"rb\", \"wb\", \"ab\", \"r+b\", \"w+b\", \"a+b\") or be inserted between the"]
-    #[doc = " letter and the \"+\" sign for the mixed modes (\"rb+\", \"wb+\", \"ab+\")."]
-    #[doc = " Additional characters may follow the sequence, although they should have no"]
-    #[doc = " effect. For example, \"t\" is sometimes appended to make explicit the file is"]
-    #[doc = " a text file."]
-    #[doc = ""]
-    #[doc = " This function supports Unicode filenames, but they must be encoded in UTF-8"]
-    #[doc = " format, regardless of the underlying operating system."]
-    #[doc = ""]
-    #[doc = " As a fallback, SDL_RWFromFile() will transparently open a matching filename"]
-    #[doc = " in an Android app's `assets`."]
-    #[doc = ""]
-    #[doc = " Closing the SDL_RWops will close the file handle SDL is holding internally."]
-    #[doc = ""]
-    #[doc = " \\param file a UTF-8 string representing the filename to open"]
-    #[doc = " \\param mode an ASCII string representing the mode to be used for opening"]
-    #[doc = "             the file."]
-    #[doc = " \\returns a pointer to the SDL_RWops structure that is created, or NULL on"]
-    #[doc = "          failure; call SDL_GetError() for more information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_RWclose"]
-    #[doc = " \\sa SDL_RWFromConstMem"]
-    #[doc = " \\sa SDL_RWFromFP"]
-    #[doc = " \\sa SDL_RWFromMem"]
-    #[doc = " \\sa SDL_RWread"]
-    #[doc = " \\sa SDL_RWseek"]
-    #[doc = " \\sa SDL_RWtell"]
-    #[doc = " \\sa SDL_RWwrite"]
+    #[doc = " Use this function to create a new SDL_RWops structure for reading from\n and/or writing to a named file.\n\n The `mode` string is treated roughly the same as in a call to the C\n library's fopen(), even if SDL doesn't happen to use fopen() behind the\n scenes.\n\n Available `mode` strings:\n\n - \"r\": Open a file for reading. The file must exist.\n - \"w\": Create an empty file for writing. If a file with the same name\n   already exists its content is erased and the file is treated as a new\n   empty file.\n - \"a\": Append to a file. Writing operations append data at the end of the\n   file. The file is created if it does not exist.\n - \"r+\": Open a file for update both reading and writing. The file must\n   exist.\n - \"w+\": Create an empty file for both reading and writing. If a file with\n   the same name already exists its content is erased and the file is\n   treated as a new empty file.\n - \"a+\": Open a file for reading and appending. All writing operations are\n   performed at the end of the file, protecting the previous content to be\n   overwritten. You can reposition (fseek, rewind) the internal pointer to\n   anywhere in the file for reading, but writing operations will move it\n   back to the end of file. The file is created if it does not exist.\n\n **NOTE**: In order to open a file as a binary file, a \"b\" character has to\n be included in the `mode` string. This additional \"b\" character can either\n be appended at the end of the string (thus making the following compound\n modes: \"rb\", \"wb\", \"ab\", \"r+b\", \"w+b\", \"a+b\") or be inserted between the\n letter and the \"+\" sign for the mixed modes (\"rb+\", \"wb+\", \"ab+\").\n Additional characters may follow the sequence, although they should have no\n effect. For example, \"t\" is sometimes appended to make explicit the file is\n a text file.\n\n This function supports Unicode filenames, but they must be encoded in UTF-8\n format, regardless of the underlying operating system.\n\n As a fallback, SDL_RWFromFile() will transparently open a matching filename\n in an Android app's `assets`.\n\n Closing the SDL_RWops will close the file handle SDL is holding internally.\n\n \\param file a UTF-8 string representing the filename to open\n \\param mode an ASCII string representing the mode to be used for opening\n             the file.\n \\returns a pointer to the SDL_RWops structure that is created, or NULL on\n          failure; call SDL_GetError() for more information.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_RWclose\n \\sa SDL_RWFromConstMem\n \\sa SDL_RWFromFP\n \\sa SDL_RWFromMem\n \\sa SDL_RWread\n \\sa SDL_RWseek\n \\sa SDL_RWtell\n \\sa SDL_RWwrite"]
     pub fn SDL_RWFromFile(file: *const libc::c_char, mode: *const libc::c_char) -> *mut SDL_RWops;
 }
 extern "C" {
-    #[doc = " Use this function to create an SDL_RWops structure from a standard I/O file"]
-    #[doc = " pointer (stdio.h's `FILE*`)."]
-    #[doc = ""]
-    #[doc = " This function is not available on Windows, since files opened in an"]
-    #[doc = " application on that platform cannot be used by a dynamically linked"]
-    #[doc = " library."]
-    #[doc = ""]
-    #[doc = " On some platforms, the first parameter is a `void*`, on others, it's a"]
-    #[doc = " `FILE*`, depending on what system headers are available to SDL. It is"]
-    #[doc = " always intended to be the `FILE*` type from the C runtime's stdio.h."]
-    #[doc = ""]
-    #[doc = " \\param fp the `FILE*` that feeds the SDL_RWops stream"]
-    #[doc = " \\param autoclose SDL_TRUE to close the `FILE*` when closing the SDL_RWops,"]
-    #[doc = "                  SDL_FALSE to leave the `FILE*` open when the RWops is"]
-    #[doc = "                  closed"]
-    #[doc = " \\returns a pointer to the SDL_RWops structure that is created, or NULL on"]
-    #[doc = "          failure; call SDL_GetError() for more information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_RWclose"]
-    #[doc = " \\sa SDL_RWFromConstMem"]
-    #[doc = " \\sa SDL_RWFromFile"]
-    #[doc = " \\sa SDL_RWFromMem"]
-    #[doc = " \\sa SDL_RWread"]
-    #[doc = " \\sa SDL_RWseek"]
-    #[doc = " \\sa SDL_RWtell"]
-    #[doc = " \\sa SDL_RWwrite"]
+    #[doc = " Use this function to create an SDL_RWops structure from a standard I/O file\n pointer (stdio.h's `FILE*`).\n\n This function is not available on Windows, since files opened in an\n application on that platform cannot be used by a dynamically linked\n library.\n\n On some platforms, the first parameter is a `void*`, on others, it's a\n `FILE*`, depending on what system headers are available to SDL. It is\n always intended to be the `FILE*` type from the C runtime's stdio.h.\n\n \\param fp the `FILE*` that feeds the SDL_RWops stream\n \\param autoclose SDL_TRUE to close the `FILE*` when closing the SDL_RWops,\n                  SDL_FALSE to leave the `FILE*` open when the RWops is\n                  closed\n \\returns a pointer to the SDL_RWops structure that is created, or NULL on\n          failure; call SDL_GetError() for more information.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_RWclose\n \\sa SDL_RWFromConstMem\n \\sa SDL_RWFromFile\n \\sa SDL_RWFromMem\n \\sa SDL_RWread\n \\sa SDL_RWseek\n \\sa SDL_RWtell\n \\sa SDL_RWwrite"]
     pub fn SDL_RWFromFP(fp: *mut libc::c_void, autoclose: SDL_bool) -> *mut SDL_RWops;
 }
 extern "C" {
-    #[doc = " Use this function to prepare a read-write memory buffer for use with"]
-    #[doc = " SDL_RWops."]
-    #[doc = ""]
-    #[doc = " This function sets up an SDL_RWops struct based on a memory area of a"]
-    #[doc = " certain size, for both read and write access."]
-    #[doc = ""]
-    #[doc = " This memory buffer is not copied by the RWops; the pointer you provide must"]
-    #[doc = " remain valid until you close the stream. Closing the stream will not free"]
-    #[doc = " the original buffer."]
-    #[doc = ""]
-    #[doc = " If you need to make sure the RWops never writes to the memory buffer, you"]
-    #[doc = " should use SDL_RWFromConstMem() with a read-only buffer of memory instead."]
-    #[doc = ""]
-    #[doc = " \\param mem a pointer to a buffer to feed an SDL_RWops stream"]
-    #[doc = " \\param size the buffer size, in bytes"]
-    #[doc = " \\returns a pointer to a new SDL_RWops structure, or NULL if it fails; call"]
-    #[doc = "          SDL_GetError() for more information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_RWclose"]
-    #[doc = " \\sa SDL_RWFromConstMem"]
-    #[doc = " \\sa SDL_RWFromFile"]
-    #[doc = " \\sa SDL_RWFromFP"]
-    #[doc = " \\sa SDL_RWFromMem"]
-    #[doc = " \\sa SDL_RWread"]
-    #[doc = " \\sa SDL_RWseek"]
-    #[doc = " \\sa SDL_RWtell"]
-    #[doc = " \\sa SDL_RWwrite"]
+    #[doc = " Use this function to prepare a read-write memory buffer for use with\n SDL_RWops.\n\n This function sets up an SDL_RWops struct based on a memory area of a\n certain size, for both read and write access.\n\n This memory buffer is not copied by the RWops; the pointer you provide must\n remain valid until you close the stream. Closing the stream will not free\n the original buffer.\n\n If you need to make sure the RWops never writes to the memory buffer, you\n should use SDL_RWFromConstMem() with a read-only buffer of memory instead.\n\n \\param mem a pointer to a buffer to feed an SDL_RWops stream\n \\param size the buffer size, in bytes\n \\returns a pointer to a new SDL_RWops structure, or NULL if it fails; call\n          SDL_GetError() for more information.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_RWclose\n \\sa SDL_RWFromConstMem\n \\sa SDL_RWFromFile\n \\sa SDL_RWFromFP\n \\sa SDL_RWFromMem\n \\sa SDL_RWread\n \\sa SDL_RWseek\n \\sa SDL_RWtell\n \\sa SDL_RWwrite"]
     pub fn SDL_RWFromMem(mem: *mut libc::c_void, size: libc::c_int) -> *mut SDL_RWops;
 }
 extern "C" {
-    #[doc = " Use this function to prepare a read-only memory buffer for use with RWops."]
-    #[doc = ""]
-    #[doc = " This function sets up an SDL_RWops struct based on a memory area of a"]
-    #[doc = " certain size. It assumes the memory area is not writable."]
-    #[doc = ""]
-    #[doc = " Attempting to write to this RWops stream will report an error without"]
-    #[doc = " writing to the memory buffer."]
-    #[doc = ""]
-    #[doc = " This memory buffer is not copied by the RWops; the pointer you provide must"]
-    #[doc = " remain valid until you close the stream. Closing the stream will not free"]
-    #[doc = " the original buffer."]
-    #[doc = ""]
-    #[doc = " If you need to write to a memory buffer, you should use SDL_RWFromMem()"]
-    #[doc = " with a writable buffer of memory instead."]
-    #[doc = ""]
-    #[doc = " \\param mem a pointer to a read-only buffer to feed an SDL_RWops stream"]
-    #[doc = " \\param size the buffer size, in bytes"]
-    #[doc = " \\returns a pointer to a new SDL_RWops structure, or NULL if it fails; call"]
-    #[doc = "          SDL_GetError() for more information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_RWclose"]
-    #[doc = " \\sa SDL_RWFromConstMem"]
-    #[doc = " \\sa SDL_RWFromFile"]
-    #[doc = " \\sa SDL_RWFromFP"]
-    #[doc = " \\sa SDL_RWFromMem"]
-    #[doc = " \\sa SDL_RWread"]
-    #[doc = " \\sa SDL_RWseek"]
-    #[doc = " \\sa SDL_RWtell"]
+    #[doc = " Use this function to prepare a read-only memory buffer for use with RWops.\n\n This function sets up an SDL_RWops struct based on a memory area of a\n certain size. It assumes the memory area is not writable.\n\n Attempting to write to this RWops stream will report an error without\n writing to the memory buffer.\n\n This memory buffer is not copied by the RWops; the pointer you provide must\n remain valid until you close the stream. Closing the stream will not free\n the original buffer.\n\n If you need to write to a memory buffer, you should use SDL_RWFromMem()\n with a writable buffer of memory instead.\n\n \\param mem a pointer to a read-only buffer to feed an SDL_RWops stream\n \\param size the buffer size, in bytes\n \\returns a pointer to a new SDL_RWops structure, or NULL if it fails; call\n          SDL_GetError() for more information.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_RWclose\n \\sa SDL_RWFromConstMem\n \\sa SDL_RWFromFile\n \\sa SDL_RWFromFP\n \\sa SDL_RWFromMem\n \\sa SDL_RWread\n \\sa SDL_RWseek\n \\sa SDL_RWtell"]
     pub fn SDL_RWFromConstMem(mem: *const libc::c_void, size: libc::c_int) -> *mut SDL_RWops;
 }
 extern "C" {
-    #[doc = " Use this function to allocate an empty, unpopulated SDL_RWops structure."]
-    #[doc = ""]
-    #[doc = " Applications do not need to use this function unless they are providing"]
-    #[doc = " their own SDL_RWops implementation. If you just need a SDL_RWops to"]
-    #[doc = " read/write a common data source, you should use the built-in"]
-    #[doc = " implementations in SDL, like SDL_RWFromFile() or SDL_RWFromMem(), etc."]
-    #[doc = ""]
-    #[doc = " You must free the returned pointer with SDL_FreeRW(). Depending on your"]
-    #[doc = " operating system and compiler, there may be a difference between the"]
-    #[doc = " malloc() and free() your program uses and the versions SDL calls"]
-    #[doc = " internally. Trying to mix the two can cause crashing such as segmentation"]
-    #[doc = " faults. Since all SDL_RWops must free themselves when their **close**"]
-    #[doc = " method is called, all SDL_RWops must be allocated through this function, so"]
-    #[doc = " they can all be freed correctly with SDL_FreeRW()."]
-    #[doc = ""]
-    #[doc = " \\returns a pointer to the allocated memory on success, or NULL on failure;"]
-    #[doc = "          call SDL_GetError() for more information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_FreeRW"]
+    #[doc = " Use this function to allocate an empty, unpopulated SDL_RWops structure.\n\n Applications do not need to use this function unless they are providing\n their own SDL_RWops implementation. If you just need a SDL_RWops to\n read/write a common data source, you should use the built-in\n implementations in SDL, like SDL_RWFromFile() or SDL_RWFromMem(), etc.\n\n You must free the returned pointer with SDL_FreeRW(). Depending on your\n operating system and compiler, there may be a difference between the\n malloc() and free() your program uses and the versions SDL calls\n internally. Trying to mix the two can cause crashing such as segmentation\n faults. Since all SDL_RWops must free themselves when their **close**\n method is called, all SDL_RWops must be allocated through this function, so\n they can all be freed correctly with SDL_FreeRW().\n\n \\returns a pointer to the allocated memory on success, or NULL on failure;\n          call SDL_GetError() for more information.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_FreeRW"]
     pub fn SDL_AllocRW() -> *mut SDL_RWops;
 }
 extern "C" {
-    #[doc = " Use this function to free an SDL_RWops structure allocated by"]
-    #[doc = " SDL_AllocRW()."]
-    #[doc = ""]
-    #[doc = " Applications do not need to use this function unless they are providing"]
-    #[doc = " their own SDL_RWops implementation. If you just need a SDL_RWops to"]
-    #[doc = " read/write a common data source, you should use the built-in"]
-    #[doc = " implementations in SDL, like SDL_RWFromFile() or SDL_RWFromMem(), etc, and"]
-    #[doc = " call the **close** method on those SDL_RWops pointers when you are done"]
-    #[doc = " with them."]
-    #[doc = ""]
-    #[doc = " Only use SDL_FreeRW() on pointers returned by SDL_AllocRW(). The pointer is"]
-    #[doc = " invalid as soon as this function returns. Any extra memory allocated during"]
-    #[doc = " creation of the SDL_RWops is not freed by SDL_FreeRW(); the programmer must"]
-    #[doc = " be responsible for managing that memory in their **close** method."]
-    #[doc = ""]
-    #[doc = " \\param area the SDL_RWops structure to be freed"]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_AllocRW"]
+    #[doc = " Use this function to free an SDL_RWops structure allocated by\n SDL_AllocRW().\n\n Applications do not need to use this function unless they are providing\n their own SDL_RWops implementation. If you just need a SDL_RWops to\n read/write a common data source, you should use the built-in\n implementations in SDL, like SDL_RWFromFile() or SDL_RWFromMem(), etc, and\n call the **close** method on those SDL_RWops pointers when you are done\n with them.\n\n Only use SDL_FreeRW() on pointers returned by SDL_AllocRW(). The pointer is\n invalid as soon as this function returns. Any extra memory allocated during\n creation of the SDL_RWops is not freed by SDL_FreeRW(); the programmer must\n be responsible for managing that memory in their **close** method.\n\n \\param area the SDL_RWops structure to be freed\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_AllocRW"]
     pub fn SDL_FreeRW(area: *mut SDL_RWops);
 }
 extern "C" {
-    #[doc = " Use this function to get the size of the data stream in an SDL_RWops."]
-    #[doc = ""]
-    #[doc = " Prior to SDL 2.0.10, this function was a macro."]
-    #[doc = ""]
-    #[doc = " \\param context the SDL_RWops to get the size of the data stream from"]
-    #[doc = " \\returns the size of the data stream in the SDL_RWops on success, -1 if"]
-    #[doc = "          unknown or a negative error code on failure; call SDL_GetError()"]
-    #[doc = "          for more information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.10."]
+    #[doc = " Use this function to get the size of the data stream in an SDL_RWops.\n\n Prior to SDL 2.0.10, this function was a macro.\n\n \\param context the SDL_RWops to get the size of the data stream from\n \\returns the size of the data stream in the SDL_RWops on success, -1 if\n          unknown or a negative error code on failure; call SDL_GetError()\n          for more information.\n\n \\since This function is available since SDL 2.0.10."]
     pub fn SDL_RWsize(context: *mut SDL_RWops) -> Sint64;
 }
 extern "C" {
-    #[doc = " Seek within an SDL_RWops data stream."]
-    #[doc = ""]
-    #[doc = " This function seeks to byte `offset`, relative to `whence`."]
-    #[doc = ""]
-    #[doc = " `whence` may be any of the following values:"]
-    #[doc = ""]
-    #[doc = " - `RW_SEEK_SET`: seek from the beginning of data"]
-    #[doc = " - `RW_SEEK_CUR`: seek relative to current read point"]
-    #[doc = " - `RW_SEEK_END`: seek relative to the end of data"]
-    #[doc = ""]
-    #[doc = " If this stream can not seek, it will return -1."]
-    #[doc = ""]
-    #[doc = " SDL_RWseek() is actually a wrapper function that calls the SDL_RWops's"]
-    #[doc = " `seek` method appropriately, to simplify application development."]
-    #[doc = ""]
-    #[doc = " Prior to SDL 2.0.10, this function was a macro."]
-    #[doc = ""]
-    #[doc = " \\param context a pointer to an SDL_RWops structure"]
-    #[doc = " \\param offset an offset in bytes, relative to **whence** location; can be"]
-    #[doc = "               negative"]
-    #[doc = " \\param whence any of `RW_SEEK_SET`, `RW_SEEK_CUR`, `RW_SEEK_END`"]
-    #[doc = " \\returns the final offset in the data stream after the seek or -1 on error."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.10."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_RWclose"]
-    #[doc = " \\sa SDL_RWFromConstMem"]
-    #[doc = " \\sa SDL_RWFromFile"]
-    #[doc = " \\sa SDL_RWFromFP"]
-    #[doc = " \\sa SDL_RWFromMem"]
-    #[doc = " \\sa SDL_RWread"]
-    #[doc = " \\sa SDL_RWtell"]
-    #[doc = " \\sa SDL_RWwrite"]
+    #[doc = " Seek within an SDL_RWops data stream.\n\n This function seeks to byte `offset`, relative to `whence`.\n\n `whence` may be any of the following values:\n\n - `RW_SEEK_SET`: seek from the beginning of data\n - `RW_SEEK_CUR`: seek relative to current read point\n - `RW_SEEK_END`: seek relative to the end of data\n\n If this stream can not seek, it will return -1.\n\n SDL_RWseek() is actually a wrapper function that calls the SDL_RWops's\n `seek` method appropriately, to simplify application development.\n\n Prior to SDL 2.0.10, this function was a macro.\n\n \\param context a pointer to an SDL_RWops structure\n \\param offset an offset in bytes, relative to **whence** location; can be\n               negative\n \\param whence any of `RW_SEEK_SET`, `RW_SEEK_CUR`, `RW_SEEK_END`\n \\returns the final offset in the data stream after the seek or -1 on error.\n\n \\since This function is available since SDL 2.0.10.\n\n \\sa SDL_RWclose\n \\sa SDL_RWFromConstMem\n \\sa SDL_RWFromFile\n \\sa SDL_RWFromFP\n \\sa SDL_RWFromMem\n \\sa SDL_RWread\n \\sa SDL_RWtell\n \\sa SDL_RWwrite"]
     pub fn SDL_RWseek(context: *mut SDL_RWops, offset: Sint64, whence: libc::c_int) -> Sint64;
 }
 extern "C" {
-    #[doc = " Determine the current read/write offset in an SDL_RWops data stream."]
-    #[doc = ""]
-    #[doc = " SDL_RWtell is actually a wrapper function that calls the SDL_RWops's `seek`"]
-    #[doc = " method, with an offset of 0 bytes from `RW_SEEK_CUR`, to simplify"]
-    #[doc = " application development."]
-    #[doc = ""]
-    #[doc = " Prior to SDL 2.0.10, this function was a macro."]
-    #[doc = ""]
-    #[doc = " \\param context a SDL_RWops data stream object from which to get the current"]
-    #[doc = "                offset"]
-    #[doc = " \\returns the current offset in the stream, or -1 if the information can not"]
-    #[doc = "          be determined."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.10."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_RWclose"]
-    #[doc = " \\sa SDL_RWFromConstMem"]
-    #[doc = " \\sa SDL_RWFromFile"]
-    #[doc = " \\sa SDL_RWFromFP"]
-    #[doc = " \\sa SDL_RWFromMem"]
-    #[doc = " \\sa SDL_RWread"]
-    #[doc = " \\sa SDL_RWseek"]
-    #[doc = " \\sa SDL_RWwrite"]
+    #[doc = " Determine the current read/write offset in an SDL_RWops data stream.\n\n SDL_RWtell is actually a wrapper function that calls the SDL_RWops's `seek`\n method, with an offset of 0 bytes from `RW_SEEK_CUR`, to simplify\n application development.\n\n Prior to SDL 2.0.10, this function was a macro.\n\n \\param context a SDL_RWops data stream object from which to get the current\n                offset\n \\returns the current offset in the stream, or -1 if the information can not\n          be determined.\n\n \\since This function is available since SDL 2.0.10.\n\n \\sa SDL_RWclose\n \\sa SDL_RWFromConstMem\n \\sa SDL_RWFromFile\n \\sa SDL_RWFromFP\n \\sa SDL_RWFromMem\n \\sa SDL_RWread\n \\sa SDL_RWseek\n \\sa SDL_RWwrite"]
     pub fn SDL_RWtell(context: *mut SDL_RWops) -> Sint64;
 }
 extern "C" {
-    #[doc = " Read from a data source."]
-    #[doc = ""]
-    #[doc = " This function reads up to `maxnum` objects each of size `size` from the"]
-    #[doc = " data source to the area pointed at by `ptr`. This function may read less"]
-    #[doc = " objects than requested. It will return zero when there has been an error or"]
-    #[doc = " the data stream is completely read."]
-    #[doc = ""]
-    #[doc = " SDL_RWread() is actually a function wrapper that calls the SDL_RWops's"]
-    #[doc = " `read` method appropriately, to simplify application development."]
-    #[doc = ""]
-    #[doc = " Prior to SDL 2.0.10, this function was a macro."]
-    #[doc = ""]
-    #[doc = " \\param context a pointer to an SDL_RWops structure"]
-    #[doc = " \\param ptr a pointer to a buffer to read data into"]
-    #[doc = " \\param size the size of each object to read, in bytes"]
-    #[doc = " \\param maxnum the maximum number of objects to be read"]
-    #[doc = " \\returns the number of objects read, or 0 at error or end of file; call"]
-    #[doc = "          SDL_GetError() for more information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.10."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_RWclose"]
-    #[doc = " \\sa SDL_RWFromConstMem"]
-    #[doc = " \\sa SDL_RWFromFile"]
-    #[doc = " \\sa SDL_RWFromFP"]
-    #[doc = " \\sa SDL_RWFromMem"]
-    #[doc = " \\sa SDL_RWseek"]
-    #[doc = " \\sa SDL_RWwrite"]
+    #[doc = " Read from a data source.\n\n This function reads up to `maxnum` objects each of size `size` from the\n data source to the area pointed at by `ptr`. This function may read less\n objects than requested. It will return zero when there has been an error or\n the data stream is completely read.\n\n SDL_RWread() is actually a function wrapper that calls the SDL_RWops's\n `read` method appropriately, to simplify application development.\n\n Prior to SDL 2.0.10, this function was a macro.\n\n \\param context a pointer to an SDL_RWops structure\n \\param ptr a pointer to a buffer to read data into\n \\param size the size of each object to read, in bytes\n \\param maxnum the maximum number of objects to be read\n \\returns the number of objects read, or 0 at error or end of file; call\n          SDL_GetError() for more information.\n\n \\since This function is available since SDL 2.0.10.\n\n \\sa SDL_RWclose\n \\sa SDL_RWFromConstMem\n \\sa SDL_RWFromFile\n \\sa SDL_RWFromFP\n \\sa SDL_RWFromMem\n \\sa SDL_RWseek\n \\sa SDL_RWwrite"]
     pub fn SDL_RWread(
         context: *mut SDL_RWops,
         ptr: *mut libc::c_void,
-        size: size_t,
-        maxnum: size_t,
-    ) -> size_t;
-}
-extern "C" {
-    #[doc = " Write to an SDL_RWops data stream."]
-    #[doc = ""]
-    #[doc = " This function writes exactly `num` objects each of size `size` from the"]
-    #[doc = " area pointed at by `ptr` to the stream. If this fails for any reason, it'll"]
-    #[doc = " return less than `num` to demonstrate how far the write progressed. On"]
-    #[doc = " success, it returns `num`."]
-    #[doc = ""]
-    #[doc = " SDL_RWwrite is actually a function wrapper that calls the SDL_RWops's"]
-    #[doc = " `write` method appropriately, to simplify application development."]
-    #[doc = ""]
-    #[doc = " Prior to SDL 2.0.10, this function was a macro."]
-    #[doc = ""]
-    #[doc = " \\param context a pointer to an SDL_RWops structure"]
-    #[doc = " \\param ptr a pointer to a buffer containing data to write"]
-    #[doc = " \\param size the size of an object to write, in bytes"]
-    #[doc = " \\param num the number of objects to write"]
-    #[doc = " \\returns the number of objects written, which will be less than **num** on"]
-    #[doc = "          error; call SDL_GetError() for more information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.10."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_RWclose"]
-    #[doc = " \\sa SDL_RWFromConstMem"]
-    #[doc = " \\sa SDL_RWFromFile"]
-    #[doc = " \\sa SDL_RWFromFP"]
-    #[doc = " \\sa SDL_RWFromMem"]
-    #[doc = " \\sa SDL_RWread"]
-    #[doc = " \\sa SDL_RWseek"]
+        size: usize,
+        maxnum: usize,
+    ) -> usize;
+}
+extern "C" {
+    #[doc = " Write to an SDL_RWops data stream.\n\n This function writes exactly `num` objects each of size `size` from the\n area pointed at by `ptr` to the stream. If this fails for any reason, it'll\n return less than `num` to demonstrate how far the write progressed. On\n success, it returns `num`.\n\n SDL_RWwrite is actually a function wrapper that calls the SDL_RWops's\n `write` method appropriately, to simplify application development.\n\n Prior to SDL 2.0.10, this function was a macro.\n\n \\param context a pointer to an SDL_RWops structure\n \\param ptr a pointer to a buffer containing data to write\n \\param size the size of an object to write, in bytes\n \\param num the number of objects to write\n \\returns the number of objects written, which will be less than **num** on\n          error; call SDL_GetError() for more information.\n\n \\since This function is available since SDL 2.0.10.\n\n \\sa SDL_RWclose\n \\sa SDL_RWFromConstMem\n \\sa SDL_RWFromFile\n \\sa SDL_RWFromFP\n \\sa SDL_RWFromMem\n \\sa SDL_RWread\n \\sa SDL_RWseek"]
     pub fn SDL_RWwrite(
         context: *mut SDL_RWops,
         ptr: *const libc::c_void,
-        size: size_t,
-        num: size_t,
-    ) -> size_t;
-}
-extern "C" {
-    #[doc = " Close and free an allocated SDL_RWops structure."]
-    #[doc = ""]
-    #[doc = " SDL_RWclose() closes and cleans up the SDL_RWops stream. It releases any"]
-    #[doc = " resources used by the stream and frees the SDL_RWops itself with"]
-    #[doc = " SDL_FreeRW(). This returns 0 on success, or -1 if the stream failed to"]
-    #[doc = " flush to its output (e.g. to disk)."]
-    #[doc = ""]
-    #[doc = " Note that if this fails to flush the stream to disk, this function reports"]
-    #[doc = " an error, but the SDL_RWops is still invalid once this function returns."]
-    #[doc = ""]
-    #[doc = " Prior to SDL 2.0.10, this function was a macro."]
-    #[doc = ""]
-    #[doc = " \\param context SDL_RWops structure to close"]
-    #[doc = " \\returns 0 on success or a negative error code on failure; call"]
-    #[doc = "          SDL_GetError() for more information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.10."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_RWFromConstMem"]
-    #[doc = " \\sa SDL_RWFromFile"]
-    #[doc = " \\sa SDL_RWFromFP"]
-    #[doc = " \\sa SDL_RWFromMem"]
-    #[doc = " \\sa SDL_RWread"]
-    #[doc = " \\sa SDL_RWseek"]
-    #[doc = " \\sa SDL_RWwrite"]
+        size: usize,
+        num: usize,
+    ) -> usize;
+}
+extern "C" {
+    #[doc = " Close and free an allocated SDL_RWops structure.\n\n SDL_RWclose() closes and cleans up the SDL_RWops stream. It releases any\n resources used by the stream and frees the SDL_RWops itself with\n SDL_FreeRW(). This returns 0 on success, or -1 if the stream failed to\n flush to its output (e.g. to disk).\n\n Note that if this fails to flush the stream to disk, this function reports\n an error, but the SDL_RWops is still invalid once this function returns.\n\n Prior to SDL 2.0.10, this function was a macro.\n\n \\param context SDL_RWops structure to close\n \\returns 0 on success or a negative error code on failure; call\n          SDL_GetError() for more information.\n\n \\since This function is available since SDL 2.0.10.\n\n \\sa SDL_RWFromConstMem\n \\sa SDL_RWFromFile\n \\sa SDL_RWFromFP\n \\sa SDL_RWFromMem\n \\sa SDL_RWread\n \\sa SDL_RWseek\n \\sa SDL_RWwrite"]
     pub fn SDL_RWclose(context: *mut SDL_RWops) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Load all the data from an SDL data stream."]
-    #[doc = ""]
-    #[doc = " The data is allocated with a zero byte at the end (null terminated) for"]
-    #[doc = " convenience. This extra byte is not included in the value reported via"]
-    #[doc = " `datasize`."]
-    #[doc = ""]
-    #[doc = " The data should be freed with SDL_free()."]
-    #[doc = ""]
-    #[doc = " \\param src the SDL_RWops to read all available data from"]
-    #[doc = " \\param datasize if not NULL, will store the number of bytes read"]
-    #[doc = " \\param freesrc if non-zero, calls SDL_RWclose() on `src` before returning"]
-    #[doc = " \\returns the data, or NULL if there was an error."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.6."]
+    #[doc = " Load all the data from an SDL data stream.\n\n The data is allocated with a zero byte at the end (null terminated) for\n convenience. This extra byte is not included in the value reported via\n `datasize`.\n\n The data should be freed with SDL_free().\n\n \\param src the SDL_RWops to read all available data from\n \\param datasize if not NULL, will store the number of bytes read\n \\param freesrc if non-zero, calls SDL_RWclose() on `src` before returning\n \\returns the data, or NULL if there was an error.\n\n \\since This function is available since SDL 2.0.6."]
     pub fn SDL_LoadFile_RW(
         src: *mut SDL_RWops,
-        datasize: *mut size_t,
+        datasize: *mut usize,
         freesrc: libc::c_int,
     ) -> *mut libc::c_void;
 }
 extern "C" {
-    #[doc = " Load all the data from a file path."]
-    #[doc = ""]
-    #[doc = " The data is allocated with a zero byte at the end (null terminated) for"]
-    #[doc = " convenience. This extra byte is not included in the value reported via"]
-    #[doc = " `datasize`."]
-    #[doc = ""]
-    #[doc = " The data should be freed with SDL_free()."]
-    #[doc = ""]
-    #[doc = " Prior to SDL 2.0.10, this function was a macro wrapping around"]
-    #[doc = " SDL_LoadFile_RW."]
-    #[doc = ""]
-    #[doc = " \\param file the path to read all available data from"]
-    #[doc = " \\param datasize if not NULL, will store the number of bytes read"]
-    #[doc = " \\returns the data, or NULL if there was an error."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.10."]
-    pub fn SDL_LoadFile(file: *const libc::c_char, datasize: *mut size_t) -> *mut libc::c_void;
-}
-extern "C" {
-    #[doc = " Use this function to read a byte from an SDL_RWops."]
-    #[doc = ""]
-    #[doc = " \\param src the SDL_RWops to read from"]
-    #[doc = " \\returns the read byte on success or 0 on failure; call SDL_GetError() for"]
-    #[doc = "          more information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_WriteU8"]
+    #[doc = " Load all the data from a file path.\n\n The data is allocated with a zero byte at the end (null terminated) for\n convenience. This extra byte is not included in the value reported via\n `datasize`.\n\n The data should be freed with SDL_free().\n\n Prior to SDL 2.0.10, this function was a macro wrapping around\n SDL_LoadFile_RW.\n\n \\param file the path to read all available data from\n \\param datasize if not NULL, will store the number of bytes read\n \\returns the data, or NULL if there was an error.\n\n \\since This function is available since SDL 2.0.10."]
+    pub fn SDL_LoadFile(file: *const libc::c_char, datasize: *mut usize) -> *mut libc::c_void;
+}
+extern "C" {
+    #[doc = " Use this function to read a byte from an SDL_RWops.\n\n \\param src the SDL_RWops to read from\n \\returns the read byte on success or 0 on failure; call SDL_GetError() for\n          more information.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_WriteU8"]
     pub fn SDL_ReadU8(src: *mut SDL_RWops) -> Uint8;
 }
 extern "C" {
-    #[doc = " Use this function to read 16 bits of little-endian data from an SDL_RWops"]
-    #[doc = " and return in native format."]
-    #[doc = ""]
-    #[doc = " SDL byteswaps the data only if necessary, so the data returned will be in"]
-    #[doc = " the native byte order."]
-    #[doc = ""]
-    #[doc = " \\param src the stream from which to read data"]
-    #[doc = " \\returns 16 bits of data in the native byte order of the platform."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_ReadBE16"]
+    #[doc = " Use this function to read 16 bits of little-endian data from an SDL_RWops\n and return in native format.\n\n SDL byteswaps the data only if necessary, so the data returned will be in\n the native byte order.\n\n \\param src the stream from which to read data\n \\returns 16 bits of data in the native byte order of the platform.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_ReadBE16"]
     pub fn SDL_ReadLE16(src: *mut SDL_RWops) -> Uint16;
 }
 extern "C" {
-    #[doc = " Use this function to read 16 bits of big-endian data from an SDL_RWops and"]
-    #[doc = " return in native format."]
-    #[doc = ""]
-    #[doc = " SDL byteswaps the data only if necessary, so the data returned will be in"]
-    #[doc = " the native byte order."]
-    #[doc = ""]
-    #[doc = " \\param src the stream from which to read data"]
-    #[doc = " \\returns 16 bits of data in the native byte order of the platform."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_ReadLE16"]
+    #[doc = " Use this function to read 16 bits of big-endian data from an SDL_RWops and\n return in native format.\n\n SDL byteswaps the data only if necessary, so the data returned will be in\n the native byte order.\n\n \\param src the stream from which to read data\n \\returns 16 bits of data in the native byte order of the platform.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_ReadLE16"]
     pub fn SDL_ReadBE16(src: *mut SDL_RWops) -> Uint16;
 }
 extern "C" {
-    #[doc = " Use this function to read 32 bits of little-endian data from an SDL_RWops"]
-    #[doc = " and return in native format."]
-    #[doc = ""]
-    #[doc = " SDL byteswaps the data only if necessary, so the data returned will be in"]
-    #[doc = " the native byte order."]
-    #[doc = ""]
-    #[doc = " \\param src the stream from which to read data"]
-    #[doc = " \\returns 32 bits of data in the native byte order of the platform."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_ReadBE32"]
+    #[doc = " Use this function to read 32 bits of little-endian data from an SDL_RWops\n and return in native format.\n\n SDL byteswaps the data only if necessary, so the data returned will be in\n the native byte order.\n\n \\param src the stream from which to read data\n \\returns 32 bits of data in the native byte order of the platform.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_ReadBE32"]
     pub fn SDL_ReadLE32(src: *mut SDL_RWops) -> Uint32;
 }
 extern "C" {
-    #[doc = " Use this function to read 32 bits of big-endian data from an SDL_RWops and"]
-    #[doc = " return in native format."]
-    #[doc = ""]
-    #[doc = " SDL byteswaps the data only if necessary, so the data returned will be in"]
-    #[doc = " the native byte order."]
-    #[doc = ""]
-    #[doc = " \\param src the stream from which to read data"]
-    #[doc = " \\returns 32 bits of data in the native byte order of the platform."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_ReadLE32"]
+    #[doc = " Use this function to read 32 bits of big-endian data from an SDL_RWops and\n return in native format.\n\n SDL byteswaps the data only if necessary, so the data returned will be in\n the native byte order.\n\n \\param src the stream from which to read data\n \\returns 32 bits of data in the native byte order of the platform.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_ReadLE32"]
     pub fn SDL_ReadBE32(src: *mut SDL_RWops) -> Uint32;
 }
 extern "C" {
-    #[doc = " Use this function to read 64 bits of little-endian data from an SDL_RWops"]
-    #[doc = " and return in native format."]
-    #[doc = ""]
-    #[doc = " SDL byteswaps the data only if necessary, so the data returned will be in"]
-    #[doc = " the native byte order."]
-    #[doc = ""]
-    #[doc = " \\param src the stream from which to read data"]
-    #[doc = " \\returns 64 bits of data in the native byte order of the platform."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_ReadBE64"]
+    #[doc = " Use this function to read 64 bits of little-endian data from an SDL_RWops\n and return in native format.\n\n SDL byteswaps the data only if necessary, so the data returned will be in\n the native byte order.\n\n \\param src the stream from which to read data\n \\returns 64 bits of data in the native byte order of the platform.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_ReadBE64"]
     pub fn SDL_ReadLE64(src: *mut SDL_RWops) -> Uint64;
 }
 extern "C" {
-    #[doc = " Use this function to read 64 bits of big-endian data from an SDL_RWops and"]
-    #[doc = " return in native format."]
-    #[doc = ""]
-    #[doc = " SDL byteswaps the data only if necessary, so the data returned will be in"]
-    #[doc = " the native byte order."]
-    #[doc = ""]
-    #[doc = " \\param src the stream from which to read data"]
-    #[doc = " \\returns 64 bits of data in the native byte order of the platform."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_ReadLE64"]
+    #[doc = " Use this function to read 64 bits of big-endian data from an SDL_RWops and\n return in native format.\n\n SDL byteswaps the data only if necessary, so the data returned will be in\n the native byte order.\n\n \\param src the stream from which to read data\n \\returns 64 bits of data in the native byte order of the platform.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_ReadLE64"]
     pub fn SDL_ReadBE64(src: *mut SDL_RWops) -> Uint64;
 }
 extern "C" {
-    #[doc = " Use this function to write a byte to an SDL_RWops."]
-    #[doc = ""]
-    #[doc = " \\param dst the SDL_RWops to write to"]
-    #[doc = " \\param value the byte value to write"]
-    #[doc = " \\returns 1 on success or 0 on failure; call SDL_GetError() for more"]
-    #[doc = "          information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_ReadU8"]
-    pub fn SDL_WriteU8(dst: *mut SDL_RWops, value: Uint8) -> size_t;
-}
-extern "C" {
-    #[doc = " Use this function to write 16 bits in native format to a SDL_RWops as"]
-    #[doc = " little-endian data."]
-    #[doc = ""]
-    #[doc = " SDL byteswaps the data only if necessary, so the application always"]
-    #[doc = " specifies native format, and the data written will be in little-endian"]
-    #[doc = " format."]
-    #[doc = ""]
-    #[doc = " \\param dst the stream to which data will be written"]
-    #[doc = " \\param value the data to be written, in native format"]
-    #[doc = " \\returns 1 on successful write, 0 on error."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_WriteBE16"]
-    pub fn SDL_WriteLE16(dst: *mut SDL_RWops, value: Uint16) -> size_t;
-}
-extern "C" {
-    #[doc = " Use this function to write 16 bits in native format to a SDL_RWops as"]
-    #[doc = " big-endian data."]
-    #[doc = ""]
-    #[doc = " SDL byteswaps the data only if necessary, so the application always"]
-    #[doc = " specifies native format, and the data written will be in big-endian format."]
-    #[doc = ""]
-    #[doc = " \\param dst the stream to which data will be written"]
-    #[doc = " \\param value the data to be written, in native format"]
-    #[doc = " \\returns 1 on successful write, 0 on error."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_WriteLE16"]
-    pub fn SDL_WriteBE16(dst: *mut SDL_RWops, value: Uint16) -> size_t;
-}
-extern "C" {
-    #[doc = " Use this function to write 32 bits in native format to a SDL_RWops as"]
-    #[doc = " little-endian data."]
-    #[doc = ""]
-    #[doc = " SDL byteswaps the data only if necessary, so the application always"]
-    #[doc = " specifies native format, and the data written will be in little-endian"]
-    #[doc = " format."]
-    #[doc = ""]
-    #[doc = " \\param dst the stream to which data will be written"]
-    #[doc = " \\param value the data to be written, in native format"]
-    #[doc = " \\returns 1 on successful write, 0 on error."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_WriteBE32"]
-    pub fn SDL_WriteLE32(dst: *mut SDL_RWops, value: Uint32) -> size_t;
-}
-extern "C" {
-    #[doc = " Use this function to write 32 bits in native format to a SDL_RWops as"]
-    #[doc = " big-endian data."]
-    #[doc = ""]
-    #[doc = " SDL byteswaps the data only if necessary, so the application always"]
-    #[doc = " specifies native format, and the data written will be in big-endian format."]
-    #[doc = ""]
-    #[doc = " \\param dst the stream to which data will be written"]
-    #[doc = " \\param value the data to be written, in native format"]
-    #[doc = " \\returns 1 on successful write, 0 on error."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_WriteLE32"]
-    pub fn SDL_WriteBE32(dst: *mut SDL_RWops, value: Uint32) -> size_t;
-}
-extern "C" {
-    #[doc = " Use this function to write 64 bits in native format to a SDL_RWops as"]
-    #[doc = " little-endian data."]
-    #[doc = ""]
-    #[doc = " SDL byteswaps the data only if necessary, so the application always"]
-    #[doc = " specifies native format, and the data written will be in little-endian"]
-    #[doc = " format."]
-    #[doc = ""]
-    #[doc = " \\param dst the stream to which data will be written"]
-    #[doc = " \\param value the data to be written, in native format"]
-    #[doc = " \\returns 1 on successful write, 0 on error."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_WriteBE64"]
-    pub fn SDL_WriteLE64(dst: *mut SDL_RWops, value: Uint64) -> size_t;
-}
-extern "C" {
-    #[doc = " Use this function to write 64 bits in native format to a SDL_RWops as"]
-    #[doc = " big-endian data."]
-    #[doc = ""]
-    #[doc = " SDL byteswaps the data only if necessary, so the application always"]
-    #[doc = " specifies native format, and the data written will be in big-endian format."]
-    #[doc = ""]
-    #[doc = " \\param dst the stream to which data will be written"]
-    #[doc = " \\param value the data to be written, in native format"]
-    #[doc = " \\returns 1 on successful write, 0 on error."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_WriteLE64"]
-    pub fn SDL_WriteBE64(dst: *mut SDL_RWops, value: Uint64) -> size_t;
-}
-#[doc = "  \\brief Audio format flags."]
-#[doc = ""]
-#[doc = "  These are what the 16 bits in SDL_AudioFormat currently mean..."]
-#[doc = "  (Unspecified bits are always zero)."]
-#[doc = ""]
-#[doc = "  \\verbatim"]
-#[doc = "++-----------------------sample is signed if set"]
-#[doc = "||"]
-#[doc = "||       ++-----------sample is bigendian if set"]
-#[doc = "||       ||"]
-#[doc = "||       ||          ++---sample is float if set"]
-#[doc = "||       ||          ||"]
-#[doc = "||       ||          || +---sample bit size---+"]
-#[doc = "||       ||          || |                     |"]
-#[doc = "15 14 13 12 11 10 09 08 07 06 05 04 03 02 01 00"]
-#[doc = "\\endverbatim"]
-#[doc = ""]
-#[doc = "  There are macros in SDL 2.0 and later to query these bits."]
+    #[doc = " Use this function to write a byte to an SDL_RWops.\n\n \\param dst the SDL_RWops to write to\n \\param value the byte value to write\n \\returns 1 on success or 0 on failure; call SDL_GetError() for more\n          information.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_ReadU8"]
+    pub fn SDL_WriteU8(dst: *mut SDL_RWops, value: Uint8) -> usize;
+}
+extern "C" {
+    #[doc = " Use this function to write 16 bits in native format to a SDL_RWops as\n little-endian data.\n\n SDL byteswaps the data only if necessary, so the application always\n specifies native format, and the data written will be in little-endian\n format.\n\n \\param dst the stream to which data will be written\n \\param value the data to be written, in native format\n \\returns 1 on successful write, 0 on error.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_WriteBE16"]
+    pub fn SDL_WriteLE16(dst: *mut SDL_RWops, value: Uint16) -> usize;
+}
+extern "C" {
+    #[doc = " Use this function to write 16 bits in native format to a SDL_RWops as\n big-endian data.\n\n SDL byteswaps the data only if necessary, so the application always\n specifies native format, and the data written will be in big-endian format.\n\n \\param dst the stream to which data will be written\n \\param value the data to be written, in native format\n \\returns 1 on successful write, 0 on error.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_WriteLE16"]
+    pub fn SDL_WriteBE16(dst: *mut SDL_RWops, value: Uint16) -> usize;
+}
+extern "C" {
+    #[doc = " Use this function to write 32 bits in native format to a SDL_RWops as\n little-endian data.\n\n SDL byteswaps the data only if necessary, so the application always\n specifies native format, and the data written will be in little-endian\n format.\n\n \\param dst the stream to which data will be written\n \\param value the data to be written, in native format\n \\returns 1 on successful write, 0 on error.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_WriteBE32"]
+    pub fn SDL_WriteLE32(dst: *mut SDL_RWops, value: Uint32) -> usize;
+}
+extern "C" {
+    #[doc = " Use this function to write 32 bits in native format to a SDL_RWops as\n big-endian data.\n\n SDL byteswaps the data only if necessary, so the application always\n specifies native format, and the data written will be in big-endian format.\n\n \\param dst the stream to which data will be written\n \\param value the data to be written, in native format\n \\returns 1 on successful write, 0 on error.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_WriteLE32"]
+    pub fn SDL_WriteBE32(dst: *mut SDL_RWops, value: Uint32) -> usize;
+}
+extern "C" {
+    #[doc = " Use this function to write 64 bits in native format to a SDL_RWops as\n little-endian data.\n\n SDL byteswaps the data only if necessary, so the application always\n specifies native format, and the data written will be in little-endian\n format.\n\n \\param dst the stream to which data will be written\n \\param value the data to be written, in native format\n \\returns 1 on successful write, 0 on error.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_WriteBE64"]
+    pub fn SDL_WriteLE64(dst: *mut SDL_RWops, value: Uint64) -> usize;
+}
+extern "C" {
+    #[doc = " Use this function to write 64 bits in native format to a SDL_RWops as\n big-endian data.\n\n SDL byteswaps the data only if necessary, so the application always\n specifies native format, and the data written will be in big-endian format.\n\n \\param dst the stream to which data will be written\n \\param value the data to be written, in native format\n \\returns 1 on successful write, 0 on error.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_WriteLE64"]
+    pub fn SDL_WriteBE64(dst: *mut SDL_RWops, value: Uint64) -> usize;
+}
+#[doc = "  \\brief Audio format flags.\n\n  These are what the 16 bits in SDL_AudioFormat currently mean...\n  (Unspecified bits are always zero).\n\n  \\verbatim\n++-----------------------sample is signed if set\n||\n||       ++-----------sample is bigendian if set\n||       ||\n||       ||          ++---sample is float if set\n||       ||          ||\n||       ||          || +---sample bit size---+\n||       ||          || |                     |\n15 14 13 12 11 10 09 08 07 06 05 04 03 02 01 00\n\\endverbatim\n\n  There are macros in SDL 2.0 and later to query these bits."]
 pub type SDL_AudioFormat = Uint16;
-#[doc = "  This function is called when the audio device needs more data."]
-#[doc = ""]
-#[doc = "  \\param userdata An application-specific parameter saved in"]
-#[doc = "                  the SDL_AudioSpec structure"]
-#[doc = "  \\param stream A pointer to the audio data buffer."]
-#[doc = "  \\param len    The length of that buffer in bytes."]
-#[doc = ""]
-#[doc = "  Once the callback returns, the buffer will no longer be valid."]
-#[doc = "  Stereo samples are stored in a LRLRLR ordering."]
-#[doc = ""]
-#[doc = "  You can choose to avoid callbacks and use SDL_QueueAudio() instead, if"]
-#[doc = "  you like. Just open your audio device with a NULL callback."]
+#[doc = "  This function is called when the audio device needs more data.\n\n  \\param userdata An application-specific parameter saved in\n                  the SDL_AudioSpec structure\n  \\param stream A pointer to the audio data buffer.\n  \\param len    The length of that buffer in bytes.\n\n  Once the callback returns, the buffer will no longer be valid.\n  Stereo samples are stored in a LRLRLR ordering.\n\n  You can choose to avoid callbacks and use SDL_QueueAudio() instead, if\n  you like. Just open your audio device with a NULL callback."]
 pub type SDL_AudioCallback = ::core::option::Option<
     unsafe extern "C" fn(userdata: *mut libc::c_void, stream: *mut Uint8, len: libc::c_int),
 >;
-#[doc = "  The calculated values in this structure are calculated by SDL_OpenAudio()."]
-#[doc = ""]
-#[doc = "  For multi-channel audio, the default SDL channel mapping is:"]
-#[doc = "  2:  FL FR                       (stereo)"]
-#[doc = "  3:  FL FR LFE                   (2.1 surround)"]
-#[doc = "  4:  FL FR BL BR                 (quad)"]
-#[doc = "  5:  FL FR FC BL BR              (quad + center)"]
-#[doc = "  6:  FL FR FC LFE SL SR          (5.1 surround - last two can also be BL BR)"]
-#[doc = "  7:  FL FR FC LFE BC SL SR       (6.1 surround)"]
-#[doc = "  8:  FL FR FC LFE BL BR SL SR    (7.1 surround)"]
+#[doc = "  The calculated values in this structure are calculated by SDL_OpenAudio().\n\n  For multi-channel audio, the default SDL channel mapping is:\n  2:  FL FR                       (stereo)\n  3:  FL FR LFE                   (2.1 surround)\n  4:  FL FR BL BR                 (quad)\n  5:  FL FR LFE BL BR             (4.1 surround)\n  6:  FL FR FC LFE SL SR          (5.1 surround - last two can also be BL BR)\n  7:  FL FR FC LFE BC SL SR       (6.1 surround)\n  8:  FL FR FC LFE BL BR SL SR    (7.1 surround)"]
 #[repr(C)]
 #[derive(Copy, Clone)]
 pub struct SDL_AudioSpec {
@@ -3954,6 +2605,8 @@ pub struct SDL_AudioSpec {
 }
 #[test]
 fn bindgen_test_layout_SDL_AudioSpec() {
+    const UNINIT: ::core::mem::MaybeUninit<SDL_AudioSpec> = ::core::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::core::mem::size_of::<SDL_AudioSpec>(),
         32usize,
@@ -3965,7 +2618,7 @@ fn bindgen_test_layout_SDL_AudioSpec() {
         concat!("Alignment of ", stringify!(SDL_AudioSpec))
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_AudioSpec>())).freq as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).freq) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -3975,7 +2628,7 @@ fn bindgen_test_layout_SDL_AudioSpec() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_AudioSpec>())).format as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).format) as usize - ptr as usize },
         4usize,
         concat!(
             "Offset of field: ",
@@ -3985,7 +2638,7 @@ fn bindgen_test_layout_SDL_AudioSpec() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_AudioSpec>())).channels as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).channels) as usize - ptr as usize },
         6usize,
         concat!(
             "Offset of field: ",
@@ -3995,7 +2648,7 @@ fn bindgen_test_layout_SDL_AudioSpec() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_AudioSpec>())).silence as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).silence) as usize - ptr as usize },
         7usize,
         concat!(
             "Offset of field: ",
@@ -4005,7 +2658,7 @@ fn bindgen_test_layout_SDL_AudioSpec() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_AudioSpec>())).samples as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).samples) as usize - ptr as usize },
         8usize,
         concat!(
             "Offset of field: ",
@@ -4015,7 +2668,7 @@ fn bindgen_test_layout_SDL_AudioSpec() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_AudioSpec>())).padding as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).padding) as usize - ptr as usize },
         10usize,
         concat!(
             "Offset of field: ",
@@ -4025,7 +2678,7 @@ fn bindgen_test_layout_SDL_AudioSpec() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_AudioSpec>())).size as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
         12usize,
         concat!(
             "Offset of field: ",
@@ -4035,7 +2688,7 @@ fn bindgen_test_layout_SDL_AudioSpec() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_AudioSpec>())).callback as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).callback) as usize - ptr as usize },
         16usize,
         concat!(
             "Offset of field: ",
@@ -4045,7 +2698,7 @@ fn bindgen_test_layout_SDL_AudioSpec() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_AudioSpec>())).userdata as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).userdata) as usize - ptr as usize },
         24usize,
         concat!(
             "Offset of field: ",
@@ -4085,6 +2738,8 @@ pub struct SDL_AudioCVT {
 }
 #[test]
 fn bindgen_test_layout_SDL_AudioCVT() {
+    const UNINIT: ::core::mem::MaybeUninit<SDL_AudioCVT> = ::core::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::core::mem::size_of::<SDL_AudioCVT>(),
         128usize,
@@ -4096,7 +2751,7 @@ fn bindgen_test_layout_SDL_AudioCVT() {
         concat!("Alignment of ", stringify!(SDL_AudioCVT))
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_AudioCVT>())).needed as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).needed) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -4106,7 +2761,7 @@ fn bindgen_test_layout_SDL_AudioCVT() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_AudioCVT>())).src_format as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).src_format) as usize - ptr as usize },
         4usize,
         concat!(
             "Offset of field: ",
@@ -4116,7 +2771,7 @@ fn bindgen_test_layout_SDL_AudioCVT() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_AudioCVT>())).dst_format as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).dst_format) as usize - ptr as usize },
         6usize,
         concat!(
             "Offset of field: ",
@@ -4126,7 +2781,7 @@ fn bindgen_test_layout_SDL_AudioCVT() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_AudioCVT>())).rate_incr as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).rate_incr) as usize - ptr as usize },
         8usize,
         concat!(
             "Offset of field: ",
@@ -4136,7 +2791,7 @@ fn bindgen_test_layout_SDL_AudioCVT() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_AudioCVT>())).buf as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).buf) as usize - ptr as usize },
         16usize,
         concat!(
             "Offset of field: ",
@@ -4146,7 +2801,7 @@ fn bindgen_test_layout_SDL_AudioCVT() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_AudioCVT>())).len as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).len) as usize - ptr as usize },
         24usize,
         concat!(
             "Offset of field: ",
@@ -4156,7 +2811,7 @@ fn bindgen_test_layout_SDL_AudioCVT() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_AudioCVT>())).len_cvt as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).len_cvt) as usize - ptr as usize },
         28usize,
         concat!(
             "Offset of field: ",
@@ -4166,7 +2821,7 @@ fn bindgen_test_layout_SDL_AudioCVT() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_AudioCVT>())).len_mult as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).len_mult) as usize - ptr as usize },
         32usize,
         concat!(
             "Offset of field: ",
@@ -4176,7 +2831,7 @@ fn bindgen_test_layout_SDL_AudioCVT() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_AudioCVT>())).len_ratio as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).len_ratio) as usize - ptr as usize },
         36usize,
         concat!(
             "Offset of field: ",
@@ -4186,7 +2841,7 @@ fn bindgen_test_layout_SDL_AudioCVT() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_AudioCVT>())).filters as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).filters) as usize - ptr as usize },
         44usize,
         concat!(
             "Offset of field: ",
@@ -4196,7 +2851,7 @@ fn bindgen_test_layout_SDL_AudioCVT() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_AudioCVT>())).filter_index as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).filter_index) as usize - ptr as usize },
         124usize,
         concat!(
             "Offset of field: ",
@@ -4207,244 +2862,44 @@ fn bindgen_test_layout_SDL_AudioCVT() {
     );
 }
 extern "C" {
-    #[doc = " Use this function to get the number of built-in audio drivers."]
-    #[doc = ""]
-    #[doc = " This function returns a hardcoded number. This never returns a negative"]
-    #[doc = " value; if there are no drivers compiled into this build of SDL, this"]
-    #[doc = " function returns zero. The presence of a driver in this list does not mean"]
-    #[doc = " it will function, it just means SDL is capable of interacting with that"]
-    #[doc = " interface. For example, a build of SDL might have esound support, but if"]
-    #[doc = " there's no esound server available, SDL's esound driver would fail if used."]
-    #[doc = ""]
-    #[doc = " By default, SDL tries all drivers, in its preferred order, until one is"]
-    #[doc = " found to be usable."]
-    #[doc = ""]
-    #[doc = " \\returns the number of built-in audio drivers."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_GetAudioDriver"]
+    #[doc = " Use this function to get the number of built-in audio drivers.\n\n This function returns a hardcoded number. This never returns a negative\n value; if there are no drivers compiled into this build of SDL, this\n function returns zero. The presence of a driver in this list does not mean\n it will function, it just means SDL is capable of interacting with that\n interface. For example, a build of SDL might have esound support, but if\n there's no esound server available, SDL's esound driver would fail if used.\n\n By default, SDL tries all drivers, in its preferred order, until one is\n found to be usable.\n\n \\returns the number of built-in audio drivers.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_GetAudioDriver"]
     pub fn SDL_GetNumAudioDrivers() -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Use this function to get the name of a built in audio driver."]
-    #[doc = ""]
-    #[doc = " The list of audio drivers is given in the order that they are normally"]
-    #[doc = " initialized by default; the drivers that seem more reasonable to choose"]
-    #[doc = " first (as far as the SDL developers believe) are earlier in the list."]
-    #[doc = ""]
-    #[doc = " The names of drivers are all simple, low-ASCII identifiers, like \"alsa\","]
-    #[doc = " \"coreaudio\" or \"xaudio2\". These never have Unicode characters, and are not"]
-    #[doc = " meant to be proper names."]
-    #[doc = ""]
-    #[doc = " \\param index the index of the audio driver; the value ranges from 0 to"]
-    #[doc = "              SDL_GetNumAudioDrivers() - 1"]
-    #[doc = " \\returns the name of the audio driver at the requested index, or NULL if an"]
-    #[doc = "          invalid index was specified."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_GetNumAudioDrivers"]
+    #[doc = " Use this function to get the name of a built in audio driver.\n\n The list of audio drivers is given in the order that they are normally\n initialized by default; the drivers that seem more reasonable to choose\n first (as far as the SDL developers believe) are earlier in the list.\n\n The names of drivers are all simple, low-ASCII identifiers, like \"alsa\",\n \"coreaudio\" or \"xaudio2\". These never have Unicode characters, and are not\n meant to be proper names.\n\n \\param index the index of the audio driver; the value ranges from 0 to\n              SDL_GetNumAudioDrivers() - 1\n \\returns the name of the audio driver at the requested index, or NULL if an\n          invalid index was specified.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_GetNumAudioDrivers"]
     pub fn SDL_GetAudioDriver(index: libc::c_int) -> *const libc::c_char;
 }
 extern "C" {
-    #[doc = " Use this function to initialize a particular audio driver."]
-    #[doc = ""]
-    #[doc = " This function is used internally, and should not be used unless you have a"]
-    #[doc = " specific need to designate the audio driver you want to use. You should"]
-    #[doc = " normally use SDL_Init() or SDL_InitSubSystem()."]
-    #[doc = ""]
-    #[doc = " \\param driver_name the name of the desired audio driver"]
-    #[doc = " \\returns 0 on success or a negative error code on failure; call"]
-    #[doc = "          SDL_GetError() for more information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_AudioQuit"]
+    #[doc = " Use this function to initialize a particular audio driver.\n\n This function is used internally, and should not be used unless you have a\n specific need to designate the audio driver you want to use. You should\n normally use SDL_Init() or SDL_InitSubSystem().\n\n \\param driver_name the name of the desired audio driver\n \\returns 0 on success or a negative error code on failure; call\n          SDL_GetError() for more information.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_AudioQuit"]
     pub fn SDL_AudioInit(driver_name: *const libc::c_char) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Use this function to shut down audio if you initialized it with"]
-    #[doc = " SDL_AudioInit()."]
-    #[doc = ""]
-    #[doc = " This function is used internally, and should not be used unless you have a"]
-    #[doc = " specific need to specify the audio driver you want to use. You should"]
-    #[doc = " normally use SDL_Quit() or SDL_QuitSubSystem()."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_AudioInit"]
+    #[doc = " Use this function to shut down audio if you initialized it with\n SDL_AudioInit().\n\n This function is used internally, and should not be used unless you have a\n specific need to specify the audio driver you want to use. You should\n normally use SDL_Quit() or SDL_QuitSubSystem().\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_AudioInit"]
     pub fn SDL_AudioQuit();
 }
 extern "C" {
-    #[doc = " Get the name of the current audio driver."]
-    #[doc = ""]
-    #[doc = " The returned string points to internal static memory and thus never becomes"]
-    #[doc = " invalid, even if you quit the audio subsystem and initialize a new driver"]
-    #[doc = " (although such a case would return a different static string from another"]
-    #[doc = " call to this function, of course). As such, you should not modify or free"]
-    #[doc = " the returned string."]
-    #[doc = ""]
-    #[doc = " \\returns the name of the current audio driver or NULL if no driver has been"]
-    #[doc = "          initialized."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_AudioInit"]
+    #[doc = " Get the name of the current audio driver.\n\n The returned string points to internal static memory and thus never becomes\n invalid, even if you quit the audio subsystem and initialize a new driver\n (although such a case would return a different static string from another\n call to this function, of course). As such, you should not modify or free\n the returned string.\n\n \\returns the name of the current audio driver or NULL if no driver has been\n          initialized.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_AudioInit"]
     pub fn SDL_GetCurrentAudioDriver() -> *const libc::c_char;
 }
 extern "C" {
-    #[doc = " This function is a legacy means of opening the audio device."]
-    #[doc = ""]
-    #[doc = " This function remains for compatibility with SDL 1.2, but also because it's"]
-    #[doc = " slightly easier to use than the new functions in SDL 2.0. The new, more"]
-    #[doc = " powerful, and preferred way to do this is SDL_OpenAudioDevice()."]
-    #[doc = ""]
-    #[doc = " This function is roughly equivalent to:"]
-    #[doc = ""]
-    #[doc = " ```c"]
-    #[doc = " SDL_OpenAudioDevice(NULL, 0, desired, obtained, SDL_AUDIO_ALLOW_ANY_CHANGE);"]
-    #[doc = " ```"]
-    #[doc = ""]
-    #[doc = " With two notable exceptions:"]
-    #[doc = ""]
-    #[doc = " - If `obtained` is NULL, we use `desired` (and allow no changes), which"]
-    #[doc = "   means desired will be modified to have the correct values for silence,"]
-    #[doc = "   etc, and SDL will convert any differences between your app's specific"]
-    #[doc = "   request and the hardware behind the scenes."]
-    #[doc = " - The return value is always success or failure, and not a device ID, which"]
-    #[doc = "   means you can only have one device open at a time with this function."]
-    #[doc = ""]
-    #[doc = " \\param desired an SDL_AudioSpec structure representing the desired output"]
-    #[doc = "                format. Please refer to the SDL_OpenAudioDevice"]
-    #[doc = "                documentation for details on how to prepare this structure."]
-    #[doc = " \\param obtained an SDL_AudioSpec structure filled in with the actual"]
-    #[doc = "                 parameters, or NULL."]
-    #[doc = " \\returns 0 if successful, placing the actual hardware parameters in the"]
-    #[doc = "          structure pointed to by `obtained`."]
-    #[doc = ""]
-    #[doc = "          If `obtained` is NULL, the audio data passed to the callback"]
-    #[doc = "          function will be guaranteed to be in the requested format, and"]
-    #[doc = "          will be automatically converted to the actual hardware audio"]
-    #[doc = "          format if necessary. If `obtained` is NULL, `desired` will have"]
-    #[doc = "          fields modified."]
-    #[doc = ""]
-    #[doc = "          This function returns a negative error code on failure to open the"]
-    #[doc = "          audio device or failure to set up the audio thread; call"]
-    #[doc = "          SDL_GetError() for more information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_CloseAudio"]
-    #[doc = " \\sa SDL_LockAudio"]
-    #[doc = " \\sa SDL_PauseAudio"]
-    #[doc = " \\sa SDL_UnlockAudio"]
+    #[doc = " This function is a legacy means of opening the audio device.\n\n This function remains for compatibility with SDL 1.2, but also because it's\n slightly easier to use than the new functions in SDL 2.0. The new, more\n powerful, and preferred way to do this is SDL_OpenAudioDevice().\n\n This function is roughly equivalent to:\n\n ```c\n SDL_OpenAudioDevice(NULL, 0, desired, obtained, SDL_AUDIO_ALLOW_ANY_CHANGE);\n ```\n\n With two notable exceptions:\n\n - If `obtained` is NULL, we use `desired` (and allow no changes), which\n   means desired will be modified to have the correct values for silence,\n   etc, and SDL will convert any differences between your app's specific\n   request and the hardware behind the scenes.\n - The return value is always success or failure, and not a device ID, which\n   means you can only have one device open at a time with this function.\n\n \\param desired an SDL_AudioSpec structure representing the desired output\n                format. Please refer to the SDL_OpenAudioDevice\n                documentation for details on how to prepare this structure.\n \\param obtained an SDL_AudioSpec structure filled in with the actual\n                 parameters, or NULL.\n \\returns 0 if successful, placing the actual hardware parameters in the\n          structure pointed to by `obtained`.\n\n          If `obtained` is NULL, the audio data passed to the callback\n          function will be guaranteed to be in the requested format, and\n          will be automatically converted to the actual hardware audio\n          format if necessary. If `obtained` is NULL, `desired` will have\n          fields modified.\n\n          This function returns a negative error code on failure to open the\n          audio device or failure to set up the audio thread; call\n          SDL_GetError() for more information.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_CloseAudio\n \\sa SDL_LockAudio\n \\sa SDL_PauseAudio\n \\sa SDL_UnlockAudio"]
     pub fn SDL_OpenAudio(desired: *mut SDL_AudioSpec, obtained: *mut SDL_AudioSpec) -> libc::c_int;
 }
-#[doc = "  SDL Audio Device IDs."]
-#[doc = ""]
-#[doc = "  A successful call to SDL_OpenAudio() is always device id 1, and legacy"]
-#[doc = "  SDL audio APIs assume you want this device ID. SDL_OpenAudioDevice() calls"]
-#[doc = "  always returns devices >= 2 on success. The legacy calls are good both"]
-#[doc = "  for backwards compatibility and when you don't care about multiple,"]
-#[doc = "  specific, or capture devices."]
+#[doc = "  SDL Audio Device IDs.\n\n  A successful call to SDL_OpenAudio() is always device id 1, and legacy\n  SDL audio APIs assume you want this device ID. SDL_OpenAudioDevice() calls\n  always returns devices >= 2 on success. The legacy calls are good both\n  for backwards compatibility and when you don't care about multiple,\n  specific, or capture devices."]
 pub type SDL_AudioDeviceID = Uint32;
 extern "C" {
-    #[doc = " Get the number of built-in audio devices."]
-    #[doc = ""]
-    #[doc = " This function is only valid after successfully initializing the audio"]
-    #[doc = " subsystem."]
-    #[doc = ""]
-    #[doc = " Note that audio capture support is not implemented as of SDL 2.0.4, so the"]
-    #[doc = " `iscapture` parameter is for future expansion and should always be zero for"]
-    #[doc = " now."]
-    #[doc = ""]
-    #[doc = " This function will return -1 if an explicit list of devices can't be"]
-    #[doc = " determined. Returning -1 is not an error. For example, if SDL is set up to"]
-    #[doc = " talk to a remote audio server, it can't list every one available on the"]
-    #[doc = " Internet, but it will still allow a specific host to be specified in"]
-    #[doc = " SDL_OpenAudioDevice()."]
-    #[doc = ""]
-    #[doc = " In many common cases, when this function returns a value <= 0, it can still"]
-    #[doc = " successfully open the default device (NULL for first argument of"]
-    #[doc = " SDL_OpenAudioDevice())."]
-    #[doc = ""]
-    #[doc = " This function may trigger a complete redetect of available hardware. It"]
-    #[doc = " should not be called for each iteration of a loop, but rather once at the"]
-    #[doc = " start of a loop:"]
-    #[doc = ""]
-    #[doc = " ```c"]
-    #[doc = " // Don't do this:"]
-    #[doc = " for (int i = 0; i < SDL_GetNumAudioDevices(0); i++)"]
-    #[doc = ""]
-    #[doc = " // do this instead:"]
-    #[doc = " const int count = SDL_GetNumAudioDevices(0);"]
-    #[doc = " for (int i = 0; i < count; ++i) { do_something_here(); }"]
-    #[doc = " ```"]
-    #[doc = ""]
-    #[doc = " \\param iscapture zero to request playback devices, non-zero to request"]
-    #[doc = "                  recording devices"]
-    #[doc = " \\returns the number of available devices exposed by the current driver or"]
-    #[doc = "          -1 if an explicit list of devices can't be determined. A return"]
-    #[doc = "          value of -1 does not necessarily mean an error condition."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_GetAudioDeviceName"]
-    #[doc = " \\sa SDL_OpenAudioDevice"]
+    #[doc = " Get the number of built-in audio devices.\n\n This function is only valid after successfully initializing the audio\n subsystem.\n\n Note that audio capture support is not implemented as of SDL 2.0.4, so the\n `iscapture` parameter is for future expansion and should always be zero for\n now.\n\n This function will return -1 if an explicit list of devices can't be\n determined. Returning -1 is not an error. For example, if SDL is set up to\n talk to a remote audio server, it can't list every one available on the\n Internet, but it will still allow a specific host to be specified in\n SDL_OpenAudioDevice().\n\n In many common cases, when this function returns a value <= 0, it can still\n successfully open the default device (NULL for first argument of\n SDL_OpenAudioDevice()).\n\n This function may trigger a complete redetect of available hardware. It\n should not be called for each iteration of a loop, but rather once at the\n start of a loop:\n\n ```c\n // Don't do this:\n for (int i = 0; i < SDL_GetNumAudioDevices(0); i++)\n\n // do this instead:\n const int count = SDL_GetNumAudioDevices(0);\n for (int i = 0; i < count; ++i) { do_something_here(); }\n ```\n\n \\param iscapture zero to request playback devices, non-zero to request\n                  recording devices\n \\returns the number of available devices exposed by the current driver or\n          -1 if an explicit list of devices can't be determined. A return\n          value of -1 does not necessarily mean an error condition.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_GetAudioDeviceName\n \\sa SDL_OpenAudioDevice"]
     pub fn SDL_GetNumAudioDevices(iscapture: libc::c_int) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Get the human-readable name of a specific audio device."]
-    #[doc = ""]
-    #[doc = " This function is only valid after successfully initializing the audio"]
-    #[doc = " subsystem. The values returned by this function reflect the latest call to"]
-    #[doc = " SDL_GetNumAudioDevices(); re-call that function to redetect available"]
-    #[doc = " hardware."]
-    #[doc = ""]
-    #[doc = " The string returned by this function is UTF-8 encoded, read-only, and"]
-    #[doc = " managed internally. You are not to free it. If you need to keep the string"]
-    #[doc = " for any length of time, you should make your own copy of it, as it will be"]
-    #[doc = " invalid next time any of several other SDL functions are called."]
-    #[doc = ""]
-    #[doc = " \\param index the index of the audio device; valid values range from 0 to"]
-    #[doc = "              SDL_GetNumAudioDevices() - 1"]
-    #[doc = " \\param iscapture non-zero to query the list of recording devices, zero to"]
-    #[doc = "                  query the list of output devices."]
-    #[doc = " \\returns the name of the audio device at the requested index, or NULL on"]
-    #[doc = "          error."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_GetNumAudioDevices"]
+    #[doc = " Get the human-readable name of a specific audio device.\n\n This function is only valid after successfully initializing the audio\n subsystem. The values returned by this function reflect the latest call to\n SDL_GetNumAudioDevices(); re-call that function to redetect available\n hardware.\n\n The string returned by this function is UTF-8 encoded, read-only, and\n managed internally. You are not to free it. If you need to keep the string\n for any length of time, you should make your own copy of it, as it will be\n invalid next time any of several other SDL functions are called.\n\n \\param index the index of the audio device; valid values range from 0 to\n              SDL_GetNumAudioDevices() - 1\n \\param iscapture non-zero to query the list of recording devices, zero to\n                  query the list of output devices.\n \\returns the name of the audio device at the requested index, or NULL on\n          error.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_GetNumAudioDevices\n \\sa SDL_GetDefaultAudioInfo"]
     pub fn SDL_GetAudioDeviceName(
         index: libc::c_int,
         iscapture: libc::c_int,
     ) -> *const libc::c_char;
 }
 extern "C" {
-    #[doc = " Get the preferred audio format of a specific audio device."]
-    #[doc = ""]
-    #[doc = " This function is only valid after a successfully initializing the audio"]
-    #[doc = " subsystem. The values returned by this function reflect the latest call to"]
-    #[doc = " SDL_GetNumAudioDevices(); re-call that function to redetect available"]
-    #[doc = " hardware."]
-    #[doc = ""]
-    #[doc = " `spec` will be filled with the sample rate, sample format, and channel"]
-    #[doc = " count. All other values in the structure are filled with 0. When the"]
-    #[doc = " supported struct members are 0, SDL was unable to get the property from the"]
-    #[doc = " backend."]
-    #[doc = ""]
-    #[doc = " \\param index the index of the audio device; valid values range from 0 to"]
-    #[doc = "              SDL_GetNumAudioDevices() - 1"]
-    #[doc = " \\param iscapture non-zero to query the list of recording devices, zero to"]
-    #[doc = "                  query the list of output devices."]
-    #[doc = " \\param spec The SDL_AudioSpec to be initialized by this function."]
-    #[doc = " \\returns 0 on success, nonzero on error"]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.16."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_GetNumAudioDevices"]
+    #[doc = " Get the preferred audio format of a specific audio device.\n\n This function is only valid after a successfully initializing the audio\n subsystem. The values returned by this function reflect the latest call to\n SDL_GetNumAudioDevices(); re-call that function to redetect available\n hardware.\n\n `spec` will be filled with the sample rate, sample format, and channel\n count.\n\n \\param index the index of the audio device; valid values range from 0 to\n              SDL_GetNumAudioDevices() - 1\n \\param iscapture non-zero to query the list of recording devices, zero to\n                  query the list of output devices.\n \\param spec The SDL_AudioSpec to be initialized by this function.\n \\returns 0 on success, nonzero on error\n\n \\since This function is available since SDL 2.0.16.\n\n \\sa SDL_GetNumAudioDevices\n \\sa SDL_GetDefaultAudioInfo"]
     pub fn SDL_GetAudioDeviceSpec(
         index: libc::c_int,
         iscapture: libc::c_int,
@@ -4452,114 +2907,15 @@ extern "C" {
     ) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Open a specific audio device."]
-    #[doc = ""]
-    #[doc = " SDL_OpenAudio(), unlike this function, always acts on device ID 1. As such,"]
-    #[doc = " this function will never return a 1 so as not to conflict with the legacy"]
-    #[doc = " function."]
-    #[doc = ""]
-    #[doc = " Please note that SDL 2.0 before 2.0.5 did not support recording; as such,"]
-    #[doc = " this function would fail if `iscapture` was not zero. Starting with SDL"]
-    #[doc = " 2.0.5, recording is implemented and this value can be non-zero."]
-    #[doc = ""]
-    #[doc = " Passing in a `device` name of NULL requests the most reasonable default"]
-    #[doc = " (and is equivalent to what SDL_OpenAudio() does to choose a device). The"]
-    #[doc = " `device` name is a UTF-8 string reported by SDL_GetAudioDeviceName(), but"]
-    #[doc = " some drivers allow arbitrary and driver-specific strings, such as a"]
-    #[doc = " hostname/IP address for a remote audio server, or a filename in the"]
-    #[doc = " diskaudio driver."]
-    #[doc = ""]
-    #[doc = " An opened audio device starts out paused, and should be enabled for playing"]
-    #[doc = " by calling SDL_PauseAudioDevice(devid, 0) when you are ready for your audio"]
-    #[doc = " callback function to be called. Since the audio driver may modify the"]
-    #[doc = " requested size of the audio buffer, you should allocate any local mixing"]
-    #[doc = " buffers after you open the audio device."]
-    #[doc = ""]
-    #[doc = " The audio callback runs in a separate thread in most cases; you can prevent"]
-    #[doc = " race conditions between your callback and other threads without fully"]
-    #[doc = " pausing playback with SDL_LockAudioDevice(). For more information about the"]
-    #[doc = " callback, see SDL_AudioSpec."]
-    #[doc = ""]
-    #[doc = " Managing the audio spec via 'desired' and 'obtained':"]
-    #[doc = ""]
-    #[doc = " When filling in the desired audio spec structure:"]
-    #[doc = ""]
-    #[doc = " - `desired->freq` should be the frequency in sample-frames-per-second (Hz)."]
-    #[doc = " - `desired->format` should be the audio format (`AUDIO_S16SYS`, etc)."]
-    #[doc = " - `desired->samples` is the desired size of the audio buffer, in _sample"]
-    #[doc = "   frames_ (with stereo output, two samples--left and right--would make a"]
-    #[doc = "   single sample frame). This number should be a power of two, and may be"]
-    #[doc = "   adjusted by the audio driver to a value more suitable for the hardware."]
-    #[doc = "   Good values seem to range between 512 and 8096 inclusive, depending on"]
-    #[doc = "   the application and CPU speed. Smaller values reduce latency, but can"]
-    #[doc = "   lead to underflow if the application is doing heavy processing and cannot"]
-    #[doc = "   fill the audio buffer in time. Note that the number of sample frames is"]
-    #[doc = "   directly related to time by the following formula: `ms ="]
-    #[doc = "   (sampleframes*1000)/freq`"]
-    #[doc = " - `desired->size` is the size in _bytes_ of the audio buffer, and is"]
-    #[doc = "   calculated by SDL_OpenAudioDevice(). You don't initialize this."]
-    #[doc = " - `desired->silence` is the value used to set the buffer to silence, and is"]
-    #[doc = "   calculated by SDL_OpenAudioDevice(). You don't initialize this."]
-    #[doc = " - `desired->callback` should be set to a function that will be called when"]
-    #[doc = "   the audio device is ready for more data. It is passed a pointer to the"]
-    #[doc = "   audio buffer, and the length in bytes of the audio buffer. This function"]
-    #[doc = "   usually runs in a separate thread, and so you should protect data"]
-    #[doc = "   structures that it accesses by calling SDL_LockAudioDevice() and"]
-    #[doc = "   SDL_UnlockAudioDevice() in your code. Alternately, you may pass a NULL"]
-    #[doc = "   pointer here, and call SDL_QueueAudio() with some frequency, to queue"]
-    #[doc = "   more audio samples to be played (or for capture devices, call"]
-    #[doc = "   SDL_DequeueAudio() with some frequency, to obtain audio samples)."]
-    #[doc = " - `desired->userdata` is passed as the first parameter to your callback"]
-    #[doc = "   function. If you passed a NULL callback, this value is ignored."]
-    #[doc = ""]
-    #[doc = " `allowed_changes` can have the following flags OR'd together:"]
-    #[doc = ""]
-    #[doc = " - `SDL_AUDIO_ALLOW_FREQUENCY_CHANGE`"]
-    #[doc = " - `SDL_AUDIO_ALLOW_FORMAT_CHANGE`"]
-    #[doc = " - `SDL_AUDIO_ALLOW_CHANNELS_CHANGE`"]
-    #[doc = " - `SDL_AUDIO_ALLOW_ANY_CHANGE`"]
-    #[doc = ""]
-    #[doc = " These flags specify how SDL should behave when a device cannot offer a"]
-    #[doc = " specific feature. If the application requests a feature that the hardware"]
-    #[doc = " doesn't offer, SDL will always try to get the closest equivalent."]
-    #[doc = ""]
-    #[doc = " For example, if you ask for float32 audio format, but the sound card only"]
-    #[doc = " supports int16, SDL will set the hardware to int16. If you had set"]
-    #[doc = " SDL_AUDIO_ALLOW_FORMAT_CHANGE, SDL will change the format in the `obtained`"]
-    #[doc = " structure. If that flag was *not* set, SDL will prepare to convert your"]
-    #[doc = " callback's float32 audio to int16 before feeding it to the hardware and"]
-    #[doc = " will keep the originally requested format in the `obtained` structure."]
-    #[doc = ""]
-    #[doc = " The resulting audio specs, varying depending on hardware and on what"]
-    #[doc = " changes were allowed, will then be written back to `obtained`."]
-    #[doc = ""]
-    #[doc = " If your application can only handle one specific data format, pass a zero"]
-    #[doc = " for `allowed_changes` and let SDL transparently handle any differences."]
-    #[doc = ""]
-    #[doc = " \\param device a UTF-8 string reported by SDL_GetAudioDeviceName() or a"]
-    #[doc = "               driver-specific name as appropriate. NULL requests the most"]
-    #[doc = "               reasonable default device."]
-    #[doc = " \\param iscapture non-zero to specify a device should be opened for"]
-    #[doc = "                  recording, not playback"]
-    #[doc = " \\param desired an SDL_AudioSpec structure representing the desired output"]
-    #[doc = "                format; see SDL_OpenAudio() for more information"]
-    #[doc = " \\param obtained an SDL_AudioSpec structure filled in with the actual output"]
-    #[doc = "                 format; see SDL_OpenAudio() for more information"]
-    #[doc = " \\param allowed_changes 0, or one or more flags OR'd together"]
-    #[doc = " \\returns a valid device ID that is > 0 on success or 0 on failure; call"]
-    #[doc = "          SDL_GetError() for more information."]
-    #[doc = ""]
-    #[doc = "          For compatibility with SDL 1.2, this will never return 1, since"]
-    #[doc = "          SDL reserves that ID for the legacy SDL_OpenAudio() function."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_CloseAudioDevice"]
-    #[doc = " \\sa SDL_GetAudioDeviceName"]
-    #[doc = " \\sa SDL_LockAudioDevice"]
-    #[doc = " \\sa SDL_OpenAudio"]
-    #[doc = " \\sa SDL_PauseAudioDevice"]
-    #[doc = " \\sa SDL_UnlockAudioDevice"]
+    #[doc = " Get the name and preferred format of the default audio device.\n\n Some (but not all!) platforms have an isolated mechanism to get information\n about the \"default\" device. This can actually be a completely different\n device that's not in the list you get from SDL_GetAudioDeviceSpec(). It can\n even be a network address! (This is discussed in SDL_OpenAudioDevice().)\n\n As a result, this call is not guaranteed to be performant, as it can query\n the sound server directly every time, unlike the other query functions. You\n should call this function sparingly!\n\n `spec` will be filled with the sample rate, sample format, and channel\n count, if a default device exists on the system. If `name` is provided,\n will be filled with either a dynamically-allocated UTF-8 string or NULL.\n\n \\param name A pointer to be filled with the name of the default device (can\n             be NULL). Please call SDL_free() when you are done with this\n             pointer!\n \\param spec The SDL_AudioSpec to be initialized by this function.\n \\param iscapture non-zero to query the default recording device, zero to\n                  query the default output device.\n \\returns 0 on success, nonzero on error\n\n \\since This function is available since SDL 2.24.0.\n\n \\sa SDL_GetAudioDeviceName\n \\sa SDL_GetAudioDeviceSpec\n \\sa SDL_OpenAudioDevice"]
+    pub fn SDL_GetDefaultAudioInfo(
+        name: *mut *mut libc::c_char,
+        spec: *mut SDL_AudioSpec,
+        iscapture: libc::c_int,
+    ) -> libc::c_int;
+}
+extern "C" {
+    #[doc = " Open a specific audio device.\n\n SDL_OpenAudio(), unlike this function, always acts on device ID 1. As such,\n this function will never return a 1 so as not to conflict with the legacy\n function.\n\n Please note that SDL 2.0 before 2.0.5 did not support recording; as such,\n this function would fail if `iscapture` was not zero. Starting with SDL\n 2.0.5, recording is implemented and this value can be non-zero.\n\n Passing in a `device` name of NULL requests the most reasonable default\n (and is equivalent to what SDL_OpenAudio() does to choose a device). The\n `device` name is a UTF-8 string reported by SDL_GetAudioDeviceName(), but\n some drivers allow arbitrary and driver-specific strings, such as a\n hostname/IP address for a remote audio server, or a filename in the\n diskaudio driver.\n\n An opened audio device starts out paused, and should be enabled for playing\n by calling SDL_PauseAudioDevice(devid, 0) when you are ready for your audio\n callback function to be called. Since the audio driver may modify the\n requested size of the audio buffer, you should allocate any local mixing\n buffers after you open the audio device.\n\n The audio callback runs in a separate thread in most cases; you can prevent\n race conditions between your callback and other threads without fully\n pausing playback with SDL_LockAudioDevice(). For more information about the\n callback, see SDL_AudioSpec.\n\n Managing the audio spec via 'desired' and 'obtained':\n\n When filling in the desired audio spec structure:\n\n - `desired->freq` should be the frequency in sample-frames-per-second (Hz).\n - `desired->format` should be the audio format (`AUDIO_S16SYS`, etc).\n - `desired->samples` is the desired size of the audio buffer, in _sample\n   frames_ (with stereo output, two samples--left and right--would make a\n   single sample frame). This number should be a power of two, and may be\n   adjusted by the audio driver to a value more suitable for the hardware.\n   Good values seem to range between 512 and 8096 inclusive, depending on\n   the application and CPU speed. Smaller values reduce latency, but can\n   lead to underflow if the application is doing heavy processing and cannot\n   fill the audio buffer in time. Note that the number of sample frames is\n   directly related to time by the following formula: `ms =\n   (sampleframes*1000)/freq`\n - `desired->size` is the size in _bytes_ of the audio buffer, and is\n   calculated by SDL_OpenAudioDevice(). You don't initialize this.\n - `desired->silence` is the value used to set the buffer to silence, and is\n   calculated by SDL_OpenAudioDevice(). You don't initialize this.\n - `desired->callback` should be set to a function that will be called when\n   the audio device is ready for more data. It is passed a pointer to the\n   audio buffer, and the length in bytes of the audio buffer. This function\n   usually runs in a separate thread, and so you should protect data\n   structures that it accesses by calling SDL_LockAudioDevice() and\n   SDL_UnlockAudioDevice() in your code. Alternately, you may pass a NULL\n   pointer here, and call SDL_QueueAudio() with some frequency, to queue\n   more audio samples to be played (or for capture devices, call\n   SDL_DequeueAudio() with some frequency, to obtain audio samples).\n - `desired->userdata` is passed as the first parameter to your callback\n   function. If you passed a NULL callback, this value is ignored.\n\n `allowed_changes` can have the following flags OR'd together:\n\n - `SDL_AUDIO_ALLOW_FREQUENCY_CHANGE`\n - `SDL_AUDIO_ALLOW_FORMAT_CHANGE`\n - `SDL_AUDIO_ALLOW_CHANNELS_CHANGE`\n - `SDL_AUDIO_ALLOW_SAMPLES_CHANGE`\n - `SDL_AUDIO_ALLOW_ANY_CHANGE`\n\n These flags specify how SDL should behave when a device cannot offer a\n specific feature. If the application requests a feature that the hardware\n doesn't offer, SDL will always try to get the closest equivalent.\n\n For example, if you ask for float32 audio format, but the sound card only\n supports int16, SDL will set the hardware to int16. If you had set\n SDL_AUDIO_ALLOW_FORMAT_CHANGE, SDL will change the format in the `obtained`\n structure. If that flag was *not* set, SDL will prepare to convert your\n callback's float32 audio to int16 before feeding it to the hardware and\n will keep the originally requested format in the `obtained` structure.\n\n The resulting audio specs, varying depending on hardware and on what\n changes were allowed, will then be written back to `obtained`.\n\n If your application can only handle one specific data format, pass a zero\n for `allowed_changes` and let SDL transparently handle any differences.\n\n \\param device a UTF-8 string reported by SDL_GetAudioDeviceName() or a\n               driver-specific name as appropriate. NULL requests the most\n               reasonable default device.\n \\param iscapture non-zero to specify a device should be opened for\n                  recording, not playback\n \\param desired an SDL_AudioSpec structure representing the desired output\n                format; see SDL_OpenAudio() for more information\n \\param obtained an SDL_AudioSpec structure filled in with the actual output\n                 format; see SDL_OpenAudio() for more information\n \\param allowed_changes 0, or one or more flags OR'd together\n \\returns a valid device ID that is > 0 on success or 0 on failure; call\n          SDL_GetError() for more information.\n\n          For compatibility with SDL 1.2, this will never return 1, since\n          SDL reserves that ID for the legacy SDL_OpenAudio() function.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_CloseAudioDevice\n \\sa SDL_GetAudioDeviceName\n \\sa SDL_LockAudioDevice\n \\sa SDL_OpenAudio\n \\sa SDL_PauseAudioDevice\n \\sa SDL_UnlockAudioDevice"]
     pub fn SDL_OpenAudioDevice(
         device: *const libc::c_char,
         iscapture: libc::c_int,
@@ -4569,172 +2925,30 @@ extern "C" {
     ) -> SDL_AudioDeviceID;
 }
 #[repr(u32)]
-#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
+#[derive(Copy, Clone, Hash, PartialEq, Eq)]
 pub enum SDL_AudioStatus {
     SDL_AUDIO_STOPPED = 0,
     SDL_AUDIO_PLAYING = 1,
     SDL_AUDIO_PAUSED = 2,
 }
 extern "C" {
-    #[doc = " This function is a legacy means of querying the audio device."]
-    #[doc = ""]
-    #[doc = " New programs might want to use SDL_GetAudioDeviceStatus() instead. This"]
-    #[doc = " function is equivalent to calling..."]
-    #[doc = ""]
-    #[doc = " ```c"]
-    #[doc = " SDL_GetAudioDeviceStatus(1);"]
-    #[doc = " ```"]
-    #[doc = ""]
-    #[doc = " ...and is only useful if you used the legacy SDL_OpenAudio() function."]
-    #[doc = ""]
-    #[doc = " \\returns the SDL_AudioStatus of the audio device opened by SDL_OpenAudio()."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_GetAudioDeviceStatus"]
+    #[doc = " This function is a legacy means of querying the audio device.\n\n New programs might want to use SDL_GetAudioDeviceStatus() instead. This\n function is equivalent to calling...\n\n ```c\n SDL_GetAudioDeviceStatus(1);\n ```\n\n ...and is only useful if you used the legacy SDL_OpenAudio() function.\n\n \\returns the SDL_AudioStatus of the audio device opened by SDL_OpenAudio().\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_GetAudioDeviceStatus"]
     pub fn SDL_GetAudioStatus() -> SDL_AudioStatus;
 }
 extern "C" {
-    #[doc = " Use this function to get the current audio state of an audio device."]
-    #[doc = ""]
-    #[doc = " \\param dev the ID of an audio device previously opened with"]
-    #[doc = "            SDL_OpenAudioDevice()"]
-    #[doc = " \\returns the SDL_AudioStatus of the specified audio device."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_PauseAudioDevice"]
+    #[doc = " Use this function to get the current audio state of an audio device.\n\n \\param dev the ID of an audio device previously opened with\n            SDL_OpenAudioDevice()\n \\returns the SDL_AudioStatus of the specified audio device.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_PauseAudioDevice"]
     pub fn SDL_GetAudioDeviceStatus(dev: SDL_AudioDeviceID) -> SDL_AudioStatus;
 }
 extern "C" {
-    #[doc = " This function is a legacy means of pausing the audio device."]
-    #[doc = ""]
-    #[doc = " New programs might want to use SDL_PauseAudioDevice() instead. This"]
-    #[doc = " function is equivalent to calling..."]
-    #[doc = ""]
-    #[doc = " ```c"]
-    #[doc = " SDL_PauseAudioDevice(1, pause_on);"]
-    #[doc = " ```"]
-    #[doc = ""]
-    #[doc = " ...and is only useful if you used the legacy SDL_OpenAudio() function."]
-    #[doc = ""]
-    #[doc = " \\param pause_on non-zero to pause, 0 to unpause"]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_GetAudioStatus"]
-    #[doc = " \\sa SDL_PauseAudioDevice"]
+    #[doc = " This function is a legacy means of pausing the audio device.\n\n New programs might want to use SDL_PauseAudioDevice() instead. This\n function is equivalent to calling...\n\n ```c\n SDL_PauseAudioDevice(1, pause_on);\n ```\n\n ...and is only useful if you used the legacy SDL_OpenAudio() function.\n\n \\param pause_on non-zero to pause, 0 to unpause\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_GetAudioStatus\n \\sa SDL_PauseAudioDevice"]
     pub fn SDL_PauseAudio(pause_on: libc::c_int);
 }
 extern "C" {
-    #[doc = " Use this function to pause and unpause audio playback on a specified"]
-    #[doc = " device."]
-    #[doc = ""]
-    #[doc = " This function pauses and unpauses the audio callback processing for a given"]
-    #[doc = " device. Newly-opened audio devices start in the paused state, so you must"]
-    #[doc = " call this function with **pause_on**=0 after opening the specified audio"]
-    #[doc = " device to start playing sound. This allows you to safely initialize data"]
-    #[doc = " for your callback function after opening the audio device. Silence will be"]
-    #[doc = " written to the audio device while paused, and the audio callback is"]
-    #[doc = " guaranteed to not be called. Pausing one device does not prevent other"]
-    #[doc = " unpaused devices from running their callbacks."]
-    #[doc = ""]
-    #[doc = " Pausing state does not stack; even if you pause a device several times, a"]
-    #[doc = " single unpause will start the device playing again, and vice versa. This is"]
-    #[doc = " different from how SDL_LockAudioDevice() works."]
-    #[doc = ""]
-    #[doc = " If you just need to protect a few variables from race conditions vs your"]
-    #[doc = " callback, you shouldn't pause the audio device, as it will lead to dropouts"]
-    #[doc = " in the audio playback. Instead, you should use SDL_LockAudioDevice()."]
-    #[doc = ""]
-    #[doc = " \\param dev a device opened by SDL_OpenAudioDevice()"]
-    #[doc = " \\param pause_on non-zero to pause, 0 to unpause"]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_LockAudioDevice"]
+    #[doc = " Use this function to pause and unpause audio playback on a specified\n device.\n\n This function pauses and unpauses the audio callback processing for a given\n device. Newly-opened audio devices start in the paused state, so you must\n call this function with **pause_on**=0 after opening the specified audio\n device to start playing sound. This allows you to safely initialize data\n for your callback function after opening the audio device. Silence will be\n written to the audio device while paused, and the audio callback is\n guaranteed to not be called. Pausing one device does not prevent other\n unpaused devices from running their callbacks.\n\n Pausing state does not stack; even if you pause a device several times, a\n single unpause will start the device playing again, and vice versa. This is\n different from how SDL_LockAudioDevice() works.\n\n If you just need to protect a few variables from race conditions vs your\n callback, you shouldn't pause the audio device, as it will lead to dropouts\n in the audio playback. Instead, you should use SDL_LockAudioDevice().\n\n \\param dev a device opened by SDL_OpenAudioDevice()\n \\param pause_on non-zero to pause, 0 to unpause\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_LockAudioDevice"]
     pub fn SDL_PauseAudioDevice(dev: SDL_AudioDeviceID, pause_on: libc::c_int);
 }
 extern "C" {
-    #[doc = " Load the audio data of a WAVE file into memory."]
-    #[doc = ""]
-    #[doc = " Loading a WAVE file requires `src`, `spec`, `audio_buf` and `audio_len` to"]
-    #[doc = " be valid pointers. The entire data portion of the file is then loaded into"]
-    #[doc = " memory and decoded if necessary."]
-    #[doc = ""]
-    #[doc = " If `freesrc` is non-zero, the data source gets automatically closed and"]
-    #[doc = " freed before the function returns."]
-    #[doc = ""]
-    #[doc = " Supported formats are RIFF WAVE files with the formats PCM (8, 16, 24, and"]
-    #[doc = " 32 bits), IEEE Float (32 bits), Microsoft ADPCM and IMA ADPCM (4 bits), and"]
-    #[doc = " A-law and mu-law (8 bits). Other formats are currently unsupported and"]
-    #[doc = " cause an error."]
-    #[doc = ""]
-    #[doc = " If this function succeeds, the pointer returned by it is equal to `spec`"]
-    #[doc = " and the pointer to the audio data allocated by the function is written to"]
-    #[doc = " `audio_buf` and its length in bytes to `audio_len`. The SDL_AudioSpec"]
-    #[doc = " members `freq`, `channels`, and `format` are set to the values of the audio"]
-    #[doc = " data in the buffer. The `samples` member is set to a sane default and all"]
-    #[doc = " others are set to zero."]
-    #[doc = ""]
-    #[doc = " It's necessary to use SDL_FreeWAV() to free the audio data returned in"]
-    #[doc = " `audio_buf` when it is no longer used."]
-    #[doc = ""]
-    #[doc = " Because of the underspecification of the .WAV format, there are many"]
-    #[doc = " problematic files in the wild that cause issues with strict decoders. To"]
-    #[doc = " provide compatibility with these files, this decoder is lenient in regards"]
-    #[doc = " to the truncation of the file, the fact chunk, and the size of the RIFF"]
-    #[doc = " chunk. The hints `SDL_HINT_WAVE_RIFF_CHUNK_SIZE`,"]
-    #[doc = " `SDL_HINT_WAVE_TRUNCATION`, and `SDL_HINT_WAVE_FACT_CHUNK` can be used to"]
-    #[doc = " tune the behavior of the loading process."]
-    #[doc = ""]
-    #[doc = " Any file that is invalid (due to truncation, corruption, or wrong values in"]
-    #[doc = " the headers), too big, or unsupported causes an error. Additionally, any"]
-    #[doc = " critical I/O error from the data source will terminate the loading process"]
-    #[doc = " with an error. The function returns NULL on error and in all cases (with"]
-    #[doc = " the exception of `src` being NULL), an appropriate error message will be"]
-    #[doc = " set."]
-    #[doc = ""]
-    #[doc = " It is required that the data source supports seeking."]
-    #[doc = ""]
-    #[doc = " Example:"]
-    #[doc = ""]
-    #[doc = " ```c"]
-    #[doc = " SDL_LoadWAV_RW(SDL_RWFromFile(\"sample.wav\", \"rb\"), 1, &spec, &buf, &len);"]
-    #[doc = " ```"]
-    #[doc = ""]
-    #[doc = " Note that the SDL_LoadWAV macro does this same thing for you, but in a less"]
-    #[doc = " messy way:"]
-    #[doc = ""]
-    #[doc = " ```c"]
-    #[doc = " SDL_LoadWAV(\"sample.wav\", &spec, &buf, &len);"]
-    #[doc = " ```"]
-    #[doc = ""]
-    #[doc = " \\param src The data source for the WAVE data"]
-    #[doc = " \\param freesrc If non-zero, SDL will _always_ free the data source"]
-    #[doc = " \\param spec An SDL_AudioSpec that will be filled in with the wave file's"]
-    #[doc = "             format details"]
-    #[doc = " \\param audio_buf A pointer filled with the audio data, allocated by the"]
-    #[doc = "                  function."]
-    #[doc = " \\param audio_len A pointer filled with the length of the audio data buffer"]
-    #[doc = "                  in bytes"]
-    #[doc = " \\returns This function, if successfully called, returns `spec`, which will"]
-    #[doc = "          be filled with the audio data format of the wave source data."]
-    #[doc = "          `audio_buf` will be filled with a pointer to an allocated buffer"]
-    #[doc = "          containing the audio data, and `audio_len` is filled with the"]
-    #[doc = "          length of that audio buffer in bytes."]
-    #[doc = ""]
-    #[doc = "          This function returns NULL if the .WAV file cannot be opened, uses"]
-    #[doc = "          an unknown data format, or is corrupt; call SDL_GetError() for"]
-    #[doc = "          more information."]
-    #[doc = ""]
-    #[doc = "          When the application is done with the data returned in"]
-    #[doc = "          `audio_buf`, it should call SDL_FreeWAV() to dispose of it."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_FreeWAV"]
-    #[doc = " \\sa SDL_LoadWAV"]
+    #[doc = " Load the audio data of a WAVE file into memory.\n\n Loading a WAVE file requires `src`, `spec`, `audio_buf` and `audio_len` to\n be valid pointers. The entire data portion of the file is then loaded into\n memory and decoded if necessary.\n\n If `freesrc` is non-zero, the data source gets automatically closed and\n freed before the function returns.\n\n Supported formats are RIFF WAVE files with the formats PCM (8, 16, 24, and\n 32 bits), IEEE Float (32 bits), Microsoft ADPCM and IMA ADPCM (4 bits), and\n A-law and mu-law (8 bits). Other formats are currently unsupported and\n cause an error.\n\n If this function succeeds, the pointer returned by it is equal to `spec`\n and the pointer to the audio data allocated by the function is written to\n `audio_buf` and its length in bytes to `audio_len`. The SDL_AudioSpec\n members `freq`, `channels`, and `format` are set to the values of the audio\n data in the buffer. The `samples` member is set to a sane default and all\n others are set to zero.\n\n It's necessary to use SDL_FreeWAV() to free the audio data returned in\n `audio_buf` when it is no longer used.\n\n Because of the underspecification of the .WAV format, there are many\n problematic files in the wild that cause issues with strict decoders. To\n provide compatibility with these files, this decoder is lenient in regards\n to the truncation of the file, the fact chunk, and the size of the RIFF\n chunk. The hints `SDL_HINT_WAVE_RIFF_CHUNK_SIZE`,\n `SDL_HINT_WAVE_TRUNCATION`, and `SDL_HINT_WAVE_FACT_CHUNK` can be used to\n tune the behavior of the loading process.\n\n Any file that is invalid (due to truncation, corruption, or wrong values in\n the headers), too big, or unsupported causes an error. Additionally, any\n critical I/O error from the data source will terminate the loading process\n with an error. The function returns NULL on error and in all cases (with\n the exception of `src` being NULL), an appropriate error message will be\n set.\n\n It is required that the data source supports seeking.\n\n Example:\n\n ```c\n SDL_LoadWAV_RW(SDL_RWFromFile(\"sample.wav\", \"rb\"), 1, &spec, &buf, &len);\n ```\n\n Note that the SDL_LoadWAV macro does this same thing for you, but in a less\n messy way:\n\n ```c\n SDL_LoadWAV(\"sample.wav\", &spec, &buf, &len);\n ```\n\n \\param src The data source for the WAVE data\n \\param freesrc If non-zero, SDL will _always_ free the data source\n \\param spec An SDL_AudioSpec that will be filled in with the wave file's\n             format details\n \\param audio_buf A pointer filled with the audio data, allocated by the\n                  function.\n \\param audio_len A pointer filled with the length of the audio data buffer\n                  in bytes\n \\returns This function, if successfully called, returns `spec`, which will\n          be filled with the audio data format of the wave source data.\n          `audio_buf` will be filled with a pointer to an allocated buffer\n          containing the audio data, and `audio_len` is filled with the\n          length of that audio buffer in bytes.\n\n          This function returns NULL if the .WAV file cannot be opened, uses\n          an unknown data format, or is corrupt; call SDL_GetError() for\n          more information.\n\n          When the application is done with the data returned in\n          `audio_buf`, it should call SDL_FreeWAV() to dispose of it.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_FreeWAV\n \\sa SDL_LoadWAV"]
     pub fn SDL_LoadWAV_RW(
         src: *mut SDL_RWops,
         freesrc: libc::c_int,
@@ -4744,52 +2958,11 @@ extern "C" {
     ) -> *mut SDL_AudioSpec;
 }
 extern "C" {
-    #[doc = " Free data previously allocated with SDL_LoadWAV() or SDL_LoadWAV_RW()."]
-    #[doc = ""]
-    #[doc = " After a WAVE file has been opened with SDL_LoadWAV() or SDL_LoadWAV_RW()"]
-    #[doc = " its data can eventually be freed with SDL_FreeWAV(). It is safe to call"]
-    #[doc = " this function with a NULL pointer."]
-    #[doc = ""]
-    #[doc = " \\param audio_buf a pointer to the buffer created by SDL_LoadWAV() or"]
-    #[doc = "                  SDL_LoadWAV_RW()"]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_LoadWAV"]
-    #[doc = " \\sa SDL_LoadWAV_RW"]
+    #[doc = " Free data previously allocated with SDL_LoadWAV() or SDL_LoadWAV_RW().\n\n After a WAVE file has been opened with SDL_LoadWAV() or SDL_LoadWAV_RW()\n its data can eventually be freed with SDL_FreeWAV(). It is safe to call\n this function with a NULL pointer.\n\n \\param audio_buf a pointer to the buffer created by SDL_LoadWAV() or\n                  SDL_LoadWAV_RW()\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_LoadWAV\n \\sa SDL_LoadWAV_RW"]
     pub fn SDL_FreeWAV(audio_buf: *mut Uint8);
 }
 extern "C" {
-    #[doc = " Initialize an SDL_AudioCVT structure for conversion."]
-    #[doc = ""]
-    #[doc = " Before an SDL_AudioCVT structure can be used to convert audio data it must"]
-    #[doc = " be initialized with source and destination information."]
-    #[doc = ""]
-    #[doc = " This function will zero out every field of the SDL_AudioCVT, so it must be"]
-    #[doc = " called before the application fills in the final buffer information."]
-    #[doc = ""]
-    #[doc = " Once this function has returned successfully, and reported that a"]
-    #[doc = " conversion is necessary, the application fills in the rest of the fields in"]
-    #[doc = " SDL_AudioCVT, now that it knows how large a buffer it needs to allocate,"]
-    #[doc = " and then can call SDL_ConvertAudio() to complete the conversion."]
-    #[doc = ""]
-    #[doc = " \\param cvt an SDL_AudioCVT structure filled in with audio conversion"]
-    #[doc = "            information"]
-    #[doc = " \\param src_format the source format of the audio data; for more info see"]
-    #[doc = "                   SDL_AudioFormat"]
-    #[doc = " \\param src_channels the number of channels in the source"]
-    #[doc = " \\param src_rate the frequency (sample-frames-per-second) of the source"]
-    #[doc = " \\param dst_format the destination format of the audio data; for more info"]
-    #[doc = "                   see SDL_AudioFormat"]
-    #[doc = " \\param dst_channels the number of channels in the destination"]
-    #[doc = " \\param dst_rate the frequency (sample-frames-per-second) of the destination"]
-    #[doc = " \\returns 1 if the audio filter is prepared, 0 if no conversion is needed,"]
-    #[doc = "          or a negative error code on failure; call SDL_GetError() for more"]
-    #[doc = "          information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_ConvertAudio"]
+    #[doc = " Initialize an SDL_AudioCVT structure for conversion.\n\n Before an SDL_AudioCVT structure can be used to convert audio data it must\n be initialized with source and destination information.\n\n This function will zero out every field of the SDL_AudioCVT, so it must be\n called before the application fills in the final buffer information.\n\n Once this function has returned successfully, and reported that a\n conversion is necessary, the application fills in the rest of the fields in\n SDL_AudioCVT, now that it knows how large a buffer it needs to allocate,\n and then can call SDL_ConvertAudio() to complete the conversion.\n\n \\param cvt an SDL_AudioCVT structure filled in with audio conversion\n            information\n \\param src_format the source format of the audio data; for more info see\n                   SDL_AudioFormat\n \\param src_channels the number of channels in the source\n \\param src_rate the frequency (sample-frames-per-second) of the source\n \\param dst_format the destination format of the audio data; for more info\n                   see SDL_AudioFormat\n \\param dst_channels the number of channels in the destination\n \\param dst_rate the frequency (sample-frames-per-second) of the destination\n \\returns 1 if the audio filter is prepared, 0 if no conversion is needed,\n          or a negative error code on failure; call SDL_GetError() for more\n          information.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_ConvertAudio"]
     pub fn SDL_BuildAudioCVT(
         cvt: *mut SDL_AudioCVT,
         src_format: SDL_AudioFormat,
@@ -4801,42 +2974,7 @@ extern "C" {
     ) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Convert audio data to a desired audio format."]
-    #[doc = ""]
-    #[doc = " This function does the actual audio data conversion, after the application"]
-    #[doc = " has called SDL_BuildAudioCVT() to prepare the conversion information and"]
-    #[doc = " then filled in the buffer details."]
-    #[doc = ""]
-    #[doc = " Once the application has initialized the `cvt` structure using"]
-    #[doc = " SDL_BuildAudioCVT(), allocated an audio buffer and filled it with audio"]
-    #[doc = " data in the source format, this function will convert the buffer, in-place,"]
-    #[doc = " to the desired format."]
-    #[doc = ""]
-    #[doc = " The data conversion may go through several passes; any given pass may"]
-    #[doc = " possibly temporarily increase the size of the data. For example, SDL might"]
-    #[doc = " expand 16-bit data to 32 bits before resampling to a lower frequency,"]
-    #[doc = " shrinking the data size after having grown it briefly. Since the supplied"]
-    #[doc = " buffer will be both the source and destination, converting as necessary"]
-    #[doc = " in-place, the application must allocate a buffer that will fully contain"]
-    #[doc = " the data during its largest conversion pass. After SDL_BuildAudioCVT()"]
-    #[doc = " returns, the application should set the `cvt->len` field to the size, in"]
-    #[doc = " bytes, of the source data, and allocate a buffer that is `cvt->len *"]
-    #[doc = " cvt->len_mult` bytes long for the `buf` field."]
-    #[doc = ""]
-    #[doc = " The source data should be copied into this buffer before the call to"]
-    #[doc = " SDL_ConvertAudio(). Upon successful return, this buffer will contain the"]
-    #[doc = " converted audio, and `cvt->len_cvt` will be the size of the converted data,"]
-    #[doc = " in bytes. Any bytes in the buffer past `cvt->len_cvt` are undefined once"]
-    #[doc = " this function returns."]
-    #[doc = ""]
-    #[doc = " \\param cvt an SDL_AudioCVT structure that was previously set up by"]
-    #[doc = "            SDL_BuildAudioCVT()."]
-    #[doc = " \\returns 0 if the conversion was completed successfully or a negative error"]
-    #[doc = "          code on failure; call SDL_GetError() for more information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_BuildAudioCVT"]
+    #[doc = " Convert audio data to a desired audio format.\n\n This function does the actual audio data conversion, after the application\n has called SDL_BuildAudioCVT() to prepare the conversion information and\n then filled in the buffer details.\n\n Once the application has initialized the `cvt` structure using\n SDL_BuildAudioCVT(), allocated an audio buffer and filled it with audio\n data in the source format, this function will convert the buffer, in-place,\n to the desired format.\n\n The data conversion may go through several passes; any given pass may\n possibly temporarily increase the size of the data. For example, SDL might\n expand 16-bit data to 32 bits before resampling to a lower frequency,\n shrinking the data size after having grown it briefly. Since the supplied\n buffer will be both the source and destination, converting as necessary\n in-place, the application must allocate a buffer that will fully contain\n the data during its largest conversion pass. After SDL_BuildAudioCVT()\n returns, the application should set the `cvt->len` field to the size, in\n bytes, of the source data, and allocate a buffer that is `cvt->len *\n cvt->len_mult` bytes long for the `buf` field.\n\n The source data should be copied into this buffer before the call to\n SDL_ConvertAudio(). Upon successful return, this buffer will contain the\n converted audio, and `cvt->len_cvt` will be the size of the converted data,\n in bytes. Any bytes in the buffer past `cvt->len_cvt` are undefined once\n this function returns.\n\n \\param cvt an SDL_AudioCVT structure that was previously set up by\n            SDL_BuildAudioCVT().\n \\returns 0 if the conversion was completed successfully or a negative error\n          code on failure; call SDL_GetError() for more information.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_BuildAudioCVT"]
     pub fn SDL_ConvertAudio(cvt: *mut SDL_AudioCVT) -> libc::c_int;
 }
 #[repr(C)]
@@ -4846,24 +2984,7 @@ pub struct _SDL_AudioStream {
 }
 pub type SDL_AudioStream = _SDL_AudioStream;
 extern "C" {
-    #[doc = " Create a new audio stream."]
-    #[doc = ""]
-    #[doc = " \\param src_format The format of the source audio"]
-    #[doc = " \\param src_channels The number of channels of the source audio"]
-    #[doc = " \\param src_rate The sampling rate of the source audio"]
-    #[doc = " \\param dst_format The format of the desired audio output"]
-    #[doc = " \\param dst_channels The number of channels of the desired audio output"]
-    #[doc = " \\param dst_rate The sampling rate of the desired audio output"]
-    #[doc = " \\returns 0 on success, or -1 on error."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.7."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_AudioStreamPut"]
-    #[doc = " \\sa SDL_AudioStreamGet"]
-    #[doc = " \\sa SDL_AudioStreamAvailable"]
-    #[doc = " \\sa SDL_AudioStreamFlush"]
-    #[doc = " \\sa SDL_AudioStreamClear"]
-    #[doc = " \\sa SDL_FreeAudioStream"]
+    #[doc = " Create a new audio stream.\n\n \\param src_format The format of the source audio\n \\param src_channels The number of channels of the source audio\n \\param src_rate The sampling rate of the source audio\n \\param dst_format The format of the desired audio output\n \\param dst_channels The number of channels of the desired audio output\n \\param dst_rate The sampling rate of the desired audio output\n \\returns 0 on success, or -1 on error.\n\n \\since This function is available since SDL 2.0.7.\n\n \\sa SDL_AudioStreamPut\n \\sa SDL_AudioStreamGet\n \\sa SDL_AudioStreamAvailable\n \\sa SDL_AudioStreamFlush\n \\sa SDL_AudioStreamClear\n \\sa SDL_FreeAudioStream"]
     pub fn SDL_NewAudioStream(
         src_format: SDL_AudioFormat,
         src_channels: Uint8,
@@ -4874,21 +2995,7 @@ extern "C" {
     ) -> *mut SDL_AudioStream;
 }
 extern "C" {
-    #[doc = " Add data to be converted/resampled to the stream."]
-    #[doc = ""]
-    #[doc = " \\param stream The stream the audio data is being added to"]
-    #[doc = " \\param buf A pointer to the audio data to add"]
-    #[doc = " \\param len The number of bytes to write to the stream"]
-    #[doc = " \\returns 0 on success, or -1 on error."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.7."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_NewAudioStream"]
-    #[doc = " \\sa SDL_AudioStreamGet"]
-    #[doc = " \\sa SDL_AudioStreamAvailable"]
-    #[doc = " \\sa SDL_AudioStreamFlush"]
-    #[doc = " \\sa SDL_AudioStreamClear"]
-    #[doc = " \\sa SDL_FreeAudioStream"]
+    #[doc = " Add data to be converted/resampled to the stream.\n\n \\param stream The stream the audio data is being added to\n \\param buf A pointer to the audio data to add\n \\param len The number of bytes to write to the stream\n \\returns 0 on success, or -1 on error.\n\n \\since This function is available since SDL 2.0.7.\n\n \\sa SDL_NewAudioStream\n \\sa SDL_AudioStreamGet\n \\sa SDL_AudioStreamAvailable\n \\sa SDL_AudioStreamFlush\n \\sa SDL_AudioStreamClear\n \\sa SDL_FreeAudioStream"]
     pub fn SDL_AudioStreamPut(
         stream: *mut SDL_AudioStream,
         buf: *const libc::c_void,
@@ -4896,21 +3003,7 @@ extern "C" {
     ) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Get converted/resampled data from the stream"]
-    #[doc = ""]
-    #[doc = " \\param stream The stream the audio is being requested from"]
-    #[doc = " \\param buf A buffer to fill with audio data"]
-    #[doc = " \\param len The maximum number of bytes to fill"]
-    #[doc = " \\returns the number of bytes read from the stream, or -1 on error"]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.7."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_NewAudioStream"]
-    #[doc = " \\sa SDL_AudioStreamPut"]
-    #[doc = " \\sa SDL_AudioStreamAvailable"]
-    #[doc = " \\sa SDL_AudioStreamFlush"]
-    #[doc = " \\sa SDL_AudioStreamClear"]
-    #[doc = " \\sa SDL_FreeAudioStream"]
+    #[doc = " Get converted/resampled data from the stream\n\n \\param stream The stream the audio is being requested from\n \\param buf A buffer to fill with audio data\n \\param len The maximum number of bytes to fill\n \\returns the number of bytes read from the stream, or -1 on error\n\n \\since This function is available since SDL 2.0.7.\n\n \\sa SDL_NewAudioStream\n \\sa SDL_AudioStreamPut\n \\sa SDL_AudioStreamAvailable\n \\sa SDL_AudioStreamFlush\n \\sa SDL_AudioStreamClear\n \\sa SDL_FreeAudioStream"]
     pub fn SDL_AudioStreamGet(
         stream: *mut SDL_AudioStream,
         buf: *mut libc::c_void,
@@ -4918,118 +3011,27 @@ extern "C" {
     ) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Get the number of converted/resampled bytes available."]
-    #[doc = ""]
-    #[doc = " The stream may be buffering data behind the scenes until it has enough to"]
-    #[doc = " resample correctly, so this number might be lower than what you expect, or"]
-    #[doc = " even be zero. Add more data or flush the stream if you need the data now."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.7."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_NewAudioStream"]
-    #[doc = " \\sa SDL_AudioStreamPut"]
-    #[doc = " \\sa SDL_AudioStreamGet"]
-    #[doc = " \\sa SDL_AudioStreamFlush"]
-    #[doc = " \\sa SDL_AudioStreamClear"]
-    #[doc = " \\sa SDL_FreeAudioStream"]
+    #[doc = " Get the number of converted/resampled bytes available.\n\n The stream may be buffering data behind the scenes until it has enough to\n resample correctly, so this number might be lower than what you expect, or\n even be zero. Add more data or flush the stream if you need the data now.\n\n \\since This function is available since SDL 2.0.7.\n\n \\sa SDL_NewAudioStream\n \\sa SDL_AudioStreamPut\n \\sa SDL_AudioStreamGet\n \\sa SDL_AudioStreamFlush\n \\sa SDL_AudioStreamClear\n \\sa SDL_FreeAudioStream"]
     pub fn SDL_AudioStreamAvailable(stream: *mut SDL_AudioStream) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Tell the stream that you're done sending data, and anything being buffered"]
-    #[doc = " should be converted/resampled and made available immediately."]
-    #[doc = ""]
-    #[doc = " It is legal to add more data to a stream after flushing, but there will be"]
-    #[doc = " audio gaps in the output. Generally this is intended to signal the end of"]
-    #[doc = " input, so the complete output becomes available."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.7."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_NewAudioStream"]
-    #[doc = " \\sa SDL_AudioStreamPut"]
-    #[doc = " \\sa SDL_AudioStreamGet"]
-    #[doc = " \\sa SDL_AudioStreamAvailable"]
-    #[doc = " \\sa SDL_AudioStreamClear"]
-    #[doc = " \\sa SDL_FreeAudioStream"]
+    #[doc = " Tell the stream that you're done sending data, and anything being buffered\n should be converted/resampled and made available immediately.\n\n It is legal to add more data to a stream after flushing, but there will be\n audio gaps in the output. Generally this is intended to signal the end of\n input, so the complete output becomes available.\n\n \\since This function is available since SDL 2.0.7.\n\n \\sa SDL_NewAudioStream\n \\sa SDL_AudioStreamPut\n \\sa SDL_AudioStreamGet\n \\sa SDL_AudioStreamAvailable\n \\sa SDL_AudioStreamClear\n \\sa SDL_FreeAudioStream"]
     pub fn SDL_AudioStreamFlush(stream: *mut SDL_AudioStream) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Clear any pending data in the stream without converting it"]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.7."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_NewAudioStream"]
-    #[doc = " \\sa SDL_AudioStreamPut"]
-    #[doc = " \\sa SDL_AudioStreamGet"]
-    #[doc = " \\sa SDL_AudioStreamAvailable"]
-    #[doc = " \\sa SDL_AudioStreamFlush"]
-    #[doc = " \\sa SDL_FreeAudioStream"]
+    #[doc = " Clear any pending data in the stream without converting it\n\n \\since This function is available since SDL 2.0.7.\n\n \\sa SDL_NewAudioStream\n \\sa SDL_AudioStreamPut\n \\sa SDL_AudioStreamGet\n \\sa SDL_AudioStreamAvailable\n \\sa SDL_AudioStreamFlush\n \\sa SDL_FreeAudioStream"]
     pub fn SDL_AudioStreamClear(stream: *mut SDL_AudioStream);
 }
 extern "C" {
-    #[doc = " Free an audio stream"]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.7."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_NewAudioStream"]
-    #[doc = " \\sa SDL_AudioStreamPut"]
-    #[doc = " \\sa SDL_AudioStreamGet"]
-    #[doc = " \\sa SDL_AudioStreamAvailable"]
-    #[doc = " \\sa SDL_AudioStreamFlush"]
-    #[doc = " \\sa SDL_AudioStreamClear"]
+    #[doc = " Free an audio stream\n\n \\since This function is available since SDL 2.0.7.\n\n \\sa SDL_NewAudioStream\n \\sa SDL_AudioStreamPut\n \\sa SDL_AudioStreamGet\n \\sa SDL_AudioStreamAvailable\n \\sa SDL_AudioStreamFlush\n \\sa SDL_AudioStreamClear"]
     pub fn SDL_FreeAudioStream(stream: *mut SDL_AudioStream);
 }
 extern "C" {
-    #[doc = " This function is a legacy means of mixing audio."]
-    #[doc = ""]
-    #[doc = " This function is equivalent to calling..."]
-    #[doc = ""]
-    #[doc = " ```c"]
-    #[doc = " SDL_MixAudioFormat(dst, src, format, len, volume);"]
-    #[doc = " ```"]
-    #[doc = ""]
-    #[doc = " ...where `format` is the obtained format of the audio device from the"]
-    #[doc = " legacy SDL_OpenAudio() function."]
-    #[doc = ""]
-    #[doc = " \\param dst the destination for the mixed audio"]
-    #[doc = " \\param src the source audio buffer to be mixed"]
-    #[doc = " \\param len the length of the audio buffer in bytes"]
-    #[doc = " \\param volume ranges from 0 - 128, and should be set to SDL_MIX_MAXVOLUME"]
-    #[doc = "               for full audio volume"]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_MixAudioFormat"]
+    #[doc = " This function is a legacy means of mixing audio.\n\n This function is equivalent to calling...\n\n ```c\n SDL_MixAudioFormat(dst, src, format, len, volume);\n ```\n\n ...where `format` is the obtained format of the audio device from the\n legacy SDL_OpenAudio() function.\n\n \\param dst the destination for the mixed audio\n \\param src the source audio buffer to be mixed\n \\param len the length of the audio buffer in bytes\n \\param volume ranges from 0 - 128, and should be set to SDL_MIX_MAXVOLUME\n               for full audio volume\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_MixAudioFormat"]
     pub fn SDL_MixAudio(dst: *mut Uint8, src: *const Uint8, len: Uint32, volume: libc::c_int);
 }
 extern "C" {
-    #[doc = " Mix audio data in a specified format."]
-    #[doc = ""]
-    #[doc = " This takes an audio buffer `src` of `len` bytes of `format` data and mixes"]
-    #[doc = " it into `dst`, performing addition, volume adjustment, and overflow"]
-    #[doc = " clipping. The buffer pointed to by `dst` must also be `len` bytes of"]
-    #[doc = " `format` data."]
-    #[doc = ""]
-    #[doc = " This is provided for convenience -- you can mix your own audio data."]
-    #[doc = ""]
-    #[doc = " Do not use this function for mixing together more than two streams of"]
-    #[doc = " sample data. The output from repeated application of this function may be"]
-    #[doc = " distorted by clipping, because there is no accumulator with greater range"]
-    #[doc = " than the input (not to mention this being an inefficient way of doing it)."]
-    #[doc = ""]
-    #[doc = " It is a common misconception that this function is required to write audio"]
-    #[doc = " data to an output stream in an audio callback. While you can do that,"]
-    #[doc = " SDL_MixAudioFormat() is really only needed when you're mixing a single"]
-    #[doc = " audio stream with a volume adjustment."]
-    #[doc = ""]
-    #[doc = " \\param dst the destination for the mixed audio"]
-    #[doc = " \\param src the source audio buffer to be mixed"]
-    #[doc = " \\param format the SDL_AudioFormat structure representing the desired audio"]
-    #[doc = "               format"]
-    #[doc = " \\param len the length of the audio buffer in bytes"]
-    #[doc = " \\param volume ranges from 0 - 128, and should be set to SDL_MIX_MAXVOLUME"]
-    #[doc = "               for full audio volume"]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
+    #[doc = " Mix audio data in a specified format.\n\n This takes an audio buffer `src` of `len` bytes of `format` data and mixes\n it into `dst`, performing addition, volume adjustment, and overflow\n clipping. The buffer pointed to by `dst` must also be `len` bytes of\n `format` data.\n\n This is provided for convenience -- you can mix your own audio data.\n\n Do not use this function for mixing together more than two streams of\n sample data. The output from repeated application of this function may be\n distorted by clipping, because there is no accumulator with greater range\n than the input (not to mention this being an inefficient way of doing it).\n\n It is a common misconception that this function is required to write audio\n data to an output stream in an audio callback. While you can do that,\n SDL_MixAudioFormat() is really only needed when you're mixing a single\n audio stream with a volume adjustment.\n\n \\param dst the destination for the mixed audio\n \\param src the source audio buffer to be mixed\n \\param format the SDL_AudioFormat structure representing the desired audio\n               format\n \\param len the length of the audio buffer in bytes\n \\param volume ranges from 0 - 128, and should be set to SDL_MIX_MAXVOLUME\n               for full audio volume\n\n \\since This function is available since SDL 2.0.0."]
     pub fn SDL_MixAudioFormat(
         dst: *mut Uint8,
         src: *const Uint8,
@@ -5039,50 +3041,7 @@ extern "C" {
     );
 }
 extern "C" {
-    #[doc = " Queue more audio on non-callback devices."]
-    #[doc = ""]
-    #[doc = " If you are looking to retrieve queued audio from a non-callback capture"]
-    #[doc = " device, you want SDL_DequeueAudio() instead. SDL_QueueAudio() will return"]
-    #[doc = " -1 to signify an error if you use it with capture devices."]
-    #[doc = ""]
-    #[doc = " SDL offers two ways to feed audio to the device: you can either supply a"]
-    #[doc = " callback that SDL triggers with some frequency to obtain more audio (pull"]
-    #[doc = " method), or you can supply no callback, and then SDL will expect you to"]
-    #[doc = " supply data at regular intervals (push method) with this function."]
-    #[doc = ""]
-    #[doc = " There are no limits on the amount of data you can queue, short of"]
-    #[doc = " exhaustion of address space. Queued data will drain to the device as"]
-    #[doc = " necessary without further intervention from you. If the device needs audio"]
-    #[doc = " but there is not enough queued, it will play silence to make up the"]
-    #[doc = " difference. This means you will have skips in your audio playback if you"]
-    #[doc = " aren't routinely queueing sufficient data."]
-    #[doc = ""]
-    #[doc = " This function copies the supplied data, so you are safe to free it when the"]
-    #[doc = " function returns. This function is thread-safe, but queueing to the same"]
-    #[doc = " device from two threads at once does not promise which buffer will be"]
-    #[doc = " queued first."]
-    #[doc = ""]
-    #[doc = " You may not queue audio on a device that is using an application-supplied"]
-    #[doc = " callback; doing so returns an error. You have to use the audio callback or"]
-    #[doc = " queue audio with this function, but not both."]
-    #[doc = ""]
-    #[doc = " You should not call SDL_LockAudio() on the device before queueing; SDL"]
-    #[doc = " handles locking internally for this function."]
-    #[doc = ""]
-    #[doc = " Note that SDL2 does not support planar audio. You will need to resample"]
-    #[doc = " from planar audio formats into a non-planar one (see SDL_AudioFormat)"]
-    #[doc = " before queuing audio."]
-    #[doc = ""]
-    #[doc = " \\param dev the device ID to which we will queue audio"]
-    #[doc = " \\param data the data to queue to the device for later playback"]
-    #[doc = " \\param len the number of bytes (not samples!) to which `data` points"]
-    #[doc = " \\returns 0 on success or a negative error code on failure; call"]
-    #[doc = "          SDL_GetError() for more information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.4."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_ClearQueuedAudio"]
-    #[doc = " \\sa SDL_GetQueuedAudioSize"]
+    #[doc = " Queue more audio on non-callback devices.\n\n If you are looking to retrieve queued audio from a non-callback capture\n device, you want SDL_DequeueAudio() instead. SDL_QueueAudio() will return\n -1 to signify an error if you use it with capture devices.\n\n SDL offers two ways to feed audio to the device: you can either supply a\n callback that SDL triggers with some frequency to obtain more audio (pull\n method), or you can supply no callback, and then SDL will expect you to\n supply data at regular intervals (push method) with this function.\n\n There are no limits on the amount of data you can queue, short of\n exhaustion of address space. Queued data will drain to the device as\n necessary without further intervention from you. If the device needs audio\n but there is not enough queued, it will play silence to make up the\n difference. This means you will have skips in your audio playback if you\n aren't routinely queueing sufficient data.\n\n This function copies the supplied data, so you are safe to free it when the\n function returns. This function is thread-safe, but queueing to the same\n device from two threads at once does not promise which buffer will be\n queued first.\n\n You may not queue audio on a device that is using an application-supplied\n callback; doing so returns an error. You have to use the audio callback or\n queue audio with this function, but not both.\n\n You should not call SDL_LockAudio() on the device before queueing; SDL\n handles locking internally for this function.\n\n Note that SDL2 does not support planar audio. You will need to resample\n from planar audio formats into a non-planar one (see SDL_AudioFormat)\n before queuing audio.\n\n \\param dev the device ID to which we will queue audio\n \\param data the data to queue to the device for later playback\n \\param len the number of bytes (not samples!) to which `data` points\n \\returns 0 on success or a negative error code on failure; call\n          SDL_GetError() for more information.\n\n \\since This function is available since SDL 2.0.4.\n\n \\sa SDL_ClearQueuedAudio\n \\sa SDL_GetQueuedAudioSize"]
     pub fn SDL_QueueAudio(
         dev: SDL_AudioDeviceID,
         data: *const libc::c_void,
@@ -5090,330 +3049,64 @@ extern "C" {
     ) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Dequeue more audio on non-callback devices."]
-    #[doc = ""]
-    #[doc = " If you are looking to queue audio for output on a non-callback playback"]
-    #[doc = " device, you want SDL_QueueAudio() instead. SDL_DequeueAudio() will always"]
-    #[doc = " return 0 if you use it with playback devices."]
-    #[doc = ""]
-    #[doc = " SDL offers two ways to retrieve audio from a capture device: you can either"]
-    #[doc = " supply a callback that SDL triggers with some frequency as the device"]
-    #[doc = " records more audio data, (push method), or you can supply no callback, and"]
-    #[doc = " then SDL will expect you to retrieve data at regular intervals (pull"]
-    #[doc = " method) with this function."]
-    #[doc = ""]
-    #[doc = " There are no limits on the amount of data you can queue, short of"]
-    #[doc = " exhaustion of address space. Data from the device will keep queuing as"]
-    #[doc = " necessary without further intervention from you. This means you will"]
-    #[doc = " eventually run out of memory if you aren't routinely dequeueing data."]
-    #[doc = ""]
-    #[doc = " Capture devices will not queue data when paused; if you are expecting to"]
-    #[doc = " not need captured audio for some length of time, use SDL_PauseAudioDevice()"]
-    #[doc = " to stop the capture device from queueing more data. This can be useful"]
-    #[doc = " during, say, level loading times. When unpaused, capture devices will start"]
-    #[doc = " queueing data from that point, having flushed any capturable data available"]
-    #[doc = " while paused."]
-    #[doc = ""]
-    #[doc = " This function is thread-safe, but dequeueing from the same device from two"]
-    #[doc = " threads at once does not promise which thread will dequeue data first."]
-    #[doc = ""]
-    #[doc = " You may not dequeue audio from a device that is using an"]
-    #[doc = " application-supplied callback; doing so returns an error. You have to use"]
-    #[doc = " the audio callback, or dequeue audio with this function, but not both."]
-    #[doc = ""]
-    #[doc = " You should not call SDL_LockAudio() on the device before dequeueing; SDL"]
-    #[doc = " handles locking internally for this function."]
-    #[doc = ""]
-    #[doc = " \\param dev the device ID from which we will dequeue audio"]
-    #[doc = " \\param data a pointer into where audio data should be copied"]
-    #[doc = " \\param len the number of bytes (not samples!) to which (data) points"]
-    #[doc = " \\returns the number of bytes dequeued, which could be less than requested;"]
-    #[doc = "          call SDL_GetError() for more information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.5."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_ClearQueuedAudio"]
-    #[doc = " \\sa SDL_GetQueuedAudioSize"]
+    #[doc = " Dequeue more audio on non-callback devices.\n\n If you are looking to queue audio for output on a non-callback playback\n device, you want SDL_QueueAudio() instead. SDL_DequeueAudio() will always\n return 0 if you use it with playback devices.\n\n SDL offers two ways to retrieve audio from a capture device: you can either\n supply a callback that SDL triggers with some frequency as the device\n records more audio data, (push method), or you can supply no callback, and\n then SDL will expect you to retrieve data at regular intervals (pull\n method) with this function.\n\n There are no limits on the amount of data you can queue, short of\n exhaustion of address space. Data from the device will keep queuing as\n necessary without further intervention from you. This means you will\n eventually run out of memory if you aren't routinely dequeueing data.\n\n Capture devices will not queue data when paused; if you are expecting to\n not need captured audio for some length of time, use SDL_PauseAudioDevice()\n to stop the capture device from queueing more data. This can be useful\n during, say, level loading times. When unpaused, capture devices will start\n queueing data from that point, having flushed any capturable data available\n while paused.\n\n This function is thread-safe, but dequeueing from the same device from two\n threads at once does not promise which thread will dequeue data first.\n\n You may not dequeue audio from a device that is using an\n application-supplied callback; doing so returns an error. You have to use\n the audio callback, or dequeue audio with this function, but not both.\n\n You should not call SDL_LockAudio() on the device before dequeueing; SDL\n handles locking internally for this function.\n\n \\param dev the device ID from which we will dequeue audio\n \\param data a pointer into where audio data should be copied\n \\param len the number of bytes (not samples!) to which (data) points\n \\returns the number of bytes dequeued, which could be less than requested;\n          call SDL_GetError() for more information.\n\n \\since This function is available since SDL 2.0.5.\n\n \\sa SDL_ClearQueuedAudio\n \\sa SDL_GetQueuedAudioSize"]
     pub fn SDL_DequeueAudio(dev: SDL_AudioDeviceID, data: *mut libc::c_void, len: Uint32)
         -> Uint32;
 }
 extern "C" {
-    #[doc = " Get the number of bytes of still-queued audio."]
-    #[doc = ""]
-    #[doc = " For playback devices: this is the number of bytes that have been queued for"]
-    #[doc = " playback with SDL_QueueAudio(), but have not yet been sent to the hardware."]
-    #[doc = ""]
-    #[doc = " Once we've sent it to the hardware, this function can not decide the exact"]
-    #[doc = " byte boundary of what has been played. It's possible that we just gave the"]
-    #[doc = " hardware several kilobytes right before you called this function, but it"]
-    #[doc = " hasn't played any of it yet, or maybe half of it, etc."]
-    #[doc = ""]
-    #[doc = " For capture devices, this is the number of bytes that have been captured by"]
-    #[doc = " the device and are waiting for you to dequeue. This number may grow at any"]
-    #[doc = " time, so this only informs of the lower-bound of available data."]
-    #[doc = ""]
-    #[doc = " You may not queue or dequeue audio on a device that is using an"]
-    #[doc = " application-supplied callback; calling this function on such a device"]
-    #[doc = " always returns 0. You have to use the audio callback or queue audio, but"]
-    #[doc = " not both."]
-    #[doc = ""]
-    #[doc = " You should not call SDL_LockAudio() on the device before querying; SDL"]
-    #[doc = " handles locking internally for this function."]
-    #[doc = ""]
-    #[doc = " \\param dev the device ID of which we will query queued audio size"]
-    #[doc = " \\returns the number of bytes (not samples!) of queued audio."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.4."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_ClearQueuedAudio"]
-    #[doc = " \\sa SDL_QueueAudio"]
-    #[doc = " \\sa SDL_DequeueAudio"]
+    #[doc = " Get the number of bytes of still-queued audio.\n\n For playback devices: this is the number of bytes that have been queued for\n playback with SDL_QueueAudio(), but have not yet been sent to the hardware.\n\n Once we've sent it to the hardware, this function can not decide the exact\n byte boundary of what has been played. It's possible that we just gave the\n hardware several kilobytes right before you called this function, but it\n hasn't played any of it yet, or maybe half of it, etc.\n\n For capture devices, this is the number of bytes that have been captured by\n the device and are waiting for you to dequeue. This number may grow at any\n time, so this only informs of the lower-bound of available data.\n\n You may not queue or dequeue audio on a device that is using an\n application-supplied callback; calling this function on such a device\n always returns 0. You have to use the audio callback or queue audio, but\n not both.\n\n You should not call SDL_LockAudio() on the device before querying; SDL\n handles locking internally for this function.\n\n \\param dev the device ID of which we will query queued audio size\n \\returns the number of bytes (not samples!) of queued audio.\n\n \\since This function is available since SDL 2.0.4.\n\n \\sa SDL_ClearQueuedAudio\n \\sa SDL_QueueAudio\n \\sa SDL_DequeueAudio"]
     pub fn SDL_GetQueuedAudioSize(dev: SDL_AudioDeviceID) -> Uint32;
 }
 extern "C" {
-    #[doc = " Drop any queued audio data waiting to be sent to the hardware."]
-    #[doc = ""]
-    #[doc = " Immediately after this call, SDL_GetQueuedAudioSize() will return 0. For"]
-    #[doc = " output devices, the hardware will start playing silence if more audio isn't"]
-    #[doc = " queued. For capture devices, the hardware will start filling the empty"]
-    #[doc = " queue with new data if the capture device isn't paused."]
-    #[doc = ""]
-    #[doc = " This will not prevent playback of queued audio that's already been sent to"]
-    #[doc = " the hardware, as we can not undo that, so expect there to be some fraction"]
-    #[doc = " of a second of audio that might still be heard. This can be useful if you"]
-    #[doc = " want to, say, drop any pending music or any unprocessed microphone input"]
-    #[doc = " during a level change in your game."]
-    #[doc = ""]
-    #[doc = " You may not queue or dequeue audio on a device that is using an"]
-    #[doc = " application-supplied callback; calling this function on such a device"]
-    #[doc = " always returns 0. You have to use the audio callback or queue audio, but"]
-    #[doc = " not both."]
-    #[doc = ""]
-    #[doc = " You should not call SDL_LockAudio() on the device before clearing the"]
-    #[doc = " queue; SDL handles locking internally for this function."]
-    #[doc = ""]
-    #[doc = " This function always succeeds and thus returns void."]
-    #[doc = ""]
-    #[doc = " \\param dev the device ID of which to clear the audio queue"]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.4."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_GetQueuedAudioSize"]
-    #[doc = " \\sa SDL_QueueAudio"]
-    #[doc = " \\sa SDL_DequeueAudio"]
+    #[doc = " Drop any queued audio data waiting to be sent to the hardware.\n\n Immediately after this call, SDL_GetQueuedAudioSize() will return 0. For\n output devices, the hardware will start playing silence if more audio isn't\n queued. For capture devices, the hardware will start filling the empty\n queue with new data if the capture device isn't paused.\n\n This will not prevent playback of queued audio that's already been sent to\n the hardware, as we can not undo that, so expect there to be some fraction\n of a second of audio that might still be heard. This can be useful if you\n want to, say, drop any pending music or any unprocessed microphone input\n during a level change in your game.\n\n You may not queue or dequeue audio on a device that is using an\n application-supplied callback; calling this function on such a device\n always returns 0. You have to use the audio callback or queue audio, but\n not both.\n\n You should not call SDL_LockAudio() on the device before clearing the\n queue; SDL handles locking internally for this function.\n\n This function always succeeds and thus returns void.\n\n \\param dev the device ID of which to clear the audio queue\n\n \\since This function is available since SDL 2.0.4.\n\n \\sa SDL_GetQueuedAudioSize\n \\sa SDL_QueueAudio\n \\sa SDL_DequeueAudio"]
     pub fn SDL_ClearQueuedAudio(dev: SDL_AudioDeviceID);
 }
 extern "C" {
-    #[doc = " This function is a legacy means of locking the audio device."]
-    #[doc = ""]
-    #[doc = " New programs might want to use SDL_LockAudioDevice() instead. This function"]
-    #[doc = " is equivalent to calling..."]
-    #[doc = ""]
-    #[doc = " ```c"]
-    #[doc = " SDL_LockAudioDevice(1);"]
-    #[doc = " ```"]
-    #[doc = ""]
-    #[doc = " ...and is only useful if you used the legacy SDL_OpenAudio() function."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_LockAudioDevice"]
-    #[doc = " \\sa SDL_UnlockAudio"]
-    #[doc = " \\sa SDL_UnlockAudioDevice"]
+    #[doc = " This function is a legacy means of locking the audio device.\n\n New programs might want to use SDL_LockAudioDevice() instead. This function\n is equivalent to calling...\n\n ```c\n SDL_LockAudioDevice(1);\n ```\n\n ...and is only useful if you used the legacy SDL_OpenAudio() function.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_LockAudioDevice\n \\sa SDL_UnlockAudio\n \\sa SDL_UnlockAudioDevice"]
     pub fn SDL_LockAudio();
 }
 extern "C" {
-    #[doc = " Use this function to lock out the audio callback function for a specified"]
-    #[doc = " device."]
-    #[doc = ""]
-    #[doc = " The lock manipulated by these functions protects the audio callback"]
-    #[doc = " function specified in SDL_OpenAudioDevice(). During a"]
-    #[doc = " SDL_LockAudioDevice()/SDL_UnlockAudioDevice() pair, you can be guaranteed"]
-    #[doc = " that the callback function for that device is not running, even if the"]
-    #[doc = " device is not paused. While a device is locked, any other unpaused,"]
-    #[doc = " unlocked devices may still run their callbacks."]
-    #[doc = ""]
-    #[doc = " Calling this function from inside your audio callback is unnecessary. SDL"]
-    #[doc = " obtains this lock before calling your function, and releases it when the"]
-    #[doc = " function returns."]
-    #[doc = ""]
-    #[doc = " You should not hold the lock longer than absolutely necessary. If you hold"]
-    #[doc = " it too long, you'll experience dropouts in your audio playback. Ideally,"]
-    #[doc = " your application locks the device, sets a few variables and unlocks again."]
-    #[doc = " Do not do heavy work while holding the lock for a device."]
-    #[doc = ""]
-    #[doc = " It is safe to lock the audio device multiple times, as long as you unlock"]
-    #[doc = " it an equivalent number of times. The callback will not run until the"]
-    #[doc = " device has been unlocked completely in this way. If your application fails"]
-    #[doc = " to unlock the device appropriately, your callback will never run, you might"]
-    #[doc = " hear repeating bursts of audio, and SDL_CloseAudioDevice() will probably"]
-    #[doc = " deadlock."]
-    #[doc = ""]
-    #[doc = " Internally, the audio device lock is a mutex; if you lock from two threads"]
-    #[doc = " at once, not only will you block the audio callback, you'll block the other"]
-    #[doc = " thread."]
-    #[doc = ""]
-    #[doc = " \\param dev the ID of the device to be locked"]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_UnlockAudioDevice"]
+    #[doc = " Use this function to lock out the audio callback function for a specified\n device.\n\n The lock manipulated by these functions protects the audio callback\n function specified in SDL_OpenAudioDevice(). During a\n SDL_LockAudioDevice()/SDL_UnlockAudioDevice() pair, you can be guaranteed\n that the callback function for that device is not running, even if the\n device is not paused. While a device is locked, any other unpaused,\n unlocked devices may still run their callbacks.\n\n Calling this function from inside your audio callback is unnecessary. SDL\n obtains this lock before calling your function, and releases it when the\n function returns.\n\n You should not hold the lock longer than absolutely necessary. If you hold\n it too long, you'll experience dropouts in your audio playback. Ideally,\n your application locks the device, sets a few variables and unlocks again.\n Do not do heavy work while holding the lock for a device.\n\n It is safe to lock the audio device multiple times, as long as you unlock\n it an equivalent number of times. The callback will not run until the\n device has been unlocked completely in this way. If your application fails\n to unlock the device appropriately, your callback will never run, you might\n hear repeating bursts of audio, and SDL_CloseAudioDevice() will probably\n deadlock.\n\n Internally, the audio device lock is a mutex; if you lock from two threads\n at once, not only will you block the audio callback, you'll block the other\n thread.\n\n \\param dev the ID of the device to be locked\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_UnlockAudioDevice"]
     pub fn SDL_LockAudioDevice(dev: SDL_AudioDeviceID);
 }
 extern "C" {
-    #[doc = " This function is a legacy means of unlocking the audio device."]
-    #[doc = ""]
-    #[doc = " New programs might want to use SDL_UnlockAudioDevice() instead. This"]
-    #[doc = " function is equivalent to calling..."]
-    #[doc = ""]
-    #[doc = " ```c"]
-    #[doc = " SDL_UnlockAudioDevice(1);"]
-    #[doc = " ```"]
-    #[doc = ""]
-    #[doc = " ...and is only useful if you used the legacy SDL_OpenAudio() function."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_LockAudio"]
-    #[doc = " \\sa SDL_UnlockAudioDevice"]
+    #[doc = " This function is a legacy means of unlocking the audio device.\n\n New programs might want to use SDL_UnlockAudioDevice() instead. This\n function is equivalent to calling...\n\n ```c\n SDL_UnlockAudioDevice(1);\n ```\n\n ...and is only useful if you used the legacy SDL_OpenAudio() function.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_LockAudio\n \\sa SDL_UnlockAudioDevice"]
     pub fn SDL_UnlockAudio();
 }
 extern "C" {
-    #[doc = " Use this function to unlock the audio callback function for a specified"]
-    #[doc = " device."]
-    #[doc = ""]
-    #[doc = " This function should be paired with a previous SDL_LockAudioDevice() call."]
-    #[doc = ""]
-    #[doc = " \\param dev the ID of the device to be unlocked"]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_LockAudioDevice"]
+    #[doc = " Use this function to unlock the audio callback function for a specified\n device.\n\n This function should be paired with a previous SDL_LockAudioDevice() call.\n\n \\param dev the ID of the device to be unlocked\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_LockAudioDevice"]
     pub fn SDL_UnlockAudioDevice(dev: SDL_AudioDeviceID);
 }
 extern "C" {
-    #[doc = " This function is a legacy means of closing the audio device."]
-    #[doc = ""]
-    #[doc = " This function is equivalent to calling..."]
-    #[doc = ""]
-    #[doc = " ```c"]
-    #[doc = " SDL_CloseAudioDevice(1);"]
-    #[doc = " ```"]
-    #[doc = ""]
-    #[doc = " ...and is only useful if you used the legacy SDL_OpenAudio() function."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_OpenAudio"]
+    #[doc = " This function is a legacy means of closing the audio device.\n\n This function is equivalent to calling...\n\n ```c\n SDL_CloseAudioDevice(1);\n ```\n\n ...and is only useful if you used the legacy SDL_OpenAudio() function.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_OpenAudio"]
     pub fn SDL_CloseAudio();
 }
 extern "C" {
-    #[doc = " Use this function to shut down audio processing and close the audio device."]
-    #[doc = ""]
-    #[doc = " The application should close open audio devices once they are no longer"]
-    #[doc = " needed. Calling this function will wait until the device's audio callback"]
-    #[doc = " is not running, release the audio hardware and then clean up internal"]
-    #[doc = " state. No further audio will play from this device once this function"]
-    #[doc = " returns."]
-    #[doc = ""]
-    #[doc = " This function may block briefly while pending audio data is played by the"]
-    #[doc = " hardware, so that applications don't drop the last buffer of data they"]
-    #[doc = " supplied."]
-    #[doc = ""]
-    #[doc = " The device ID is invalid as soon as the device is closed, and is eligible"]
-    #[doc = " for reuse in a new SDL_OpenAudioDevice() call immediately."]
-    #[doc = ""]
-    #[doc = " \\param dev an audio device previously opened with SDL_OpenAudioDevice()"]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_OpenAudioDevice"]
+    #[doc = " Use this function to shut down audio processing and close the audio device.\n\n The application should close open audio devices once they are no longer\n needed. Calling this function will wait until the device's audio callback\n is not running, release the audio hardware and then clean up internal\n state. No further audio will play from this device once this function\n returns.\n\n This function may block briefly while pending audio data is played by the\n hardware, so that applications don't drop the last buffer of data they\n supplied.\n\n The device ID is invalid as soon as the device is closed, and is eligible\n for reuse in a new SDL_OpenAudioDevice() call immediately.\n\n \\param dev an audio device previously opened with SDL_OpenAudioDevice()\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_OpenAudioDevice"]
     pub fn SDL_CloseAudioDevice(dev: SDL_AudioDeviceID);
 }
 extern "C" {
-    #[doc = " Put UTF-8 text into the clipboard."]
-    #[doc = ""]
-    #[doc = " \\param text the text to store in the clipboard"]
-    #[doc = " \\returns 0 on success or a negative error code on failure; call"]
-    #[doc = "          SDL_GetError() for more information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_GetClipboardText"]
-    #[doc = " \\sa SDL_HasClipboardText"]
+    #[doc = " Put UTF-8 text into the clipboard.\n\n \\param text the text to store in the clipboard\n \\returns 0 on success or a negative error code on failure; call\n          SDL_GetError() for more information.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_GetClipboardText\n \\sa SDL_HasClipboardText"]
     pub fn SDL_SetClipboardText(text: *const libc::c_char) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Get UTF-8 text from the clipboard, which must be freed with SDL_free()."]
-    #[doc = ""]
-    #[doc = " This functions returns empty string if there was not enough memory left for"]
-    #[doc = " a copy of the clipboard's content."]
-    #[doc = ""]
-    #[doc = " \\returns the clipboard text on success or an empty string on failure; call"]
-    #[doc = "          SDL_GetError() for more information. Caller must call SDL_free()"]
-    #[doc = "          on the returned pointer when done with it (even if there was an"]
-    #[doc = "          error)."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_HasClipboardText"]
-    #[doc = " \\sa SDL_SetClipboardText"]
+    #[doc = " Get UTF-8 text from the clipboard, which must be freed with SDL_free().\n\n This functions returns empty string if there was not enough memory left for\n a copy of the clipboard's content.\n\n \\returns the clipboard text on success or an empty string on failure; call\n          SDL_GetError() for more information. Caller must call SDL_free()\n          on the returned pointer when done with it (even if there was an\n          error).\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_HasClipboardText\n \\sa SDL_SetClipboardText"]
     pub fn SDL_GetClipboardText() -> *mut libc::c_char;
 }
 extern "C" {
-    #[doc = " Query whether the clipboard exists and contains a non-empty text string."]
-    #[doc = ""]
-    #[doc = " \\returns SDL_TRUE if the clipboard has text, or SDL_FALSE if it does not."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_GetClipboardText"]
-    #[doc = " \\sa SDL_SetClipboardText"]
+    #[doc = " Query whether the clipboard exists and contains a non-empty text string.\n\n \\returns SDL_TRUE if the clipboard has text, or SDL_FALSE if it does not.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_GetClipboardText\n \\sa SDL_SetClipboardText"]
     pub fn SDL_HasClipboardText() -> SDL_bool;
 }
 extern "C" {
-    #[doc = " Put UTF-8 text into the primary selection."]
-    #[doc = ""]
-    #[doc = "\\param text the text to store in the primary selection"]
-    #[doc = "\\returns 0 on success or a negative error code on failure; call"]
-    #[doc = "         SDL_GetError() for more information."]
-    #[doc = ""]
-    #[doc = "\\since This function is available since SDL 2.26.0."]
-    #[doc = ""]
-    #[doc = "\\sa SDL_GetPrimarySelectionText"]
-    #[doc = "\\sa SDL_HasPrimarySelectionText"]
+    #[doc = " Put UTF-8 text into the primary selection.\n\n \\param text the text to store in the primary selection\n \\returns 0 on success or a negative error code on failure; call\n          SDL_GetError() for more information.\n\n \\since This function is available since SDL 2.26.0.\n\n \\sa SDL_GetPrimarySelectionText\n \\sa SDL_HasPrimarySelectionText"]
     pub fn SDL_SetPrimarySelectionText(text: *const libc::c_char) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Get UTF-8 text from the primary selection, which must be freed with"]
-    #[doc = "SDL_free()."]
-    #[doc = ""]
-    #[doc = "This functions returns empty string if there was not enough memory left for"]
-    #[doc = "a copy of the primary selection's content."]
-    #[doc = ""]
-    #[doc = "\\returns the primary selection text on success or an empty string on"]
-    #[doc = "         failure; call SDL_GetError() for more information. Caller must"]
-    #[doc = "         call SDL_free() on the returned pointer when done with it (even if"]
-    #[doc = "         there was an error)."]
-    #[doc = ""]
-    #[doc = "\\since This function is available since SDL 2.26.0."]
-    #[doc = ""]
-    #[doc = "\\sa SDL_HasPrimarySelectionText"]
-    #[doc = "\\sa SDL_SetPrimarySelectionText"]
+    #[doc = " Get UTF-8 text from the primary selection, which must be freed with\n SDL_free().\n\n This functions returns empty string if there was not enough memory left for\n a copy of the primary selection's content.\n\n \\returns the primary selection text on success or an empty string on\n          failure; call SDL_GetError() for more information. Caller must\n          call SDL_free() on the returned pointer when done with it (even if\n          there was an error).\n\n \\since This function is available since SDL 2.26.0.\n\n \\sa SDL_HasPrimarySelectionText\n \\sa SDL_SetPrimarySelectionText"]
     pub fn SDL_GetPrimarySelectionText() -> *mut libc::c_char;
 }
 extern "C" {
-
-    #[doc = "Query whether the primary selection exists and contains a non-empty text"]
-    #[doc = "string."]
-    #[doc = ""]
-    #[doc = "\\returns SDL_TRUE if the primary selection has text, or SDL_FALSE if it"]
-    #[doc = "         does not."]
-    #[doc = ""]
-    #[doc = "\\since This function is available since SDL 2.26.0."]
-    #[doc = ""]
-    #[doc = "\\sa SDL_GetPrimarySelectionText"]
-    #[doc = "\\sa SDL_SetPrimarySelectionText"]
+    #[doc = " Query whether the primary selection exists and contains a non-empty text\n string.\n\n \\returns SDL_TRUE if the primary selection has text, or SDL_FALSE if it\n          does not.\n\n \\since This function is available since SDL 2.26.0.\n\n \\sa SDL_GetPrimarySelectionText\n \\sa SDL_SetPrimarySelectionText"]
     pub fn SDL_HasPrimarySelectionText() -> SDL_bool;
 }
 pub type __m64 = [libc::c_longlong; 1usize];
@@ -5438,6 +3131,8 @@ pub struct div_t {
 }
 #[test]
 fn bindgen_test_layout_div_t() {
+    const UNINIT: ::core::mem::MaybeUninit<div_t> = ::core::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::core::mem::size_of::<div_t>(),
         8usize,
@@ -5449,7 +3144,7 @@ fn bindgen_test_layout_div_t() {
         concat!("Alignment of ", stringify!(div_t))
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<div_t>())).quot as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).quot) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -5459,7 +3154,7 @@ fn bindgen_test_layout_div_t() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<div_t>())).rem as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).rem) as usize - ptr as usize },
         4usize,
         concat!(
             "Offset of field: ",
@@ -5477,6 +3172,8 @@ pub struct ldiv_t {
 }
 #[test]
 fn bindgen_test_layout_ldiv_t() {
+    const UNINIT: ::core::mem::MaybeUninit<ldiv_t> = ::core::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::core::mem::size_of::<ldiv_t>(),
         16usize,
@@ -5488,7 +3185,7 @@ fn bindgen_test_layout_ldiv_t() {
         concat!("Alignment of ", stringify!(ldiv_t))
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<ldiv_t>())).quot as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).quot) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -5498,7 +3195,7 @@ fn bindgen_test_layout_ldiv_t() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<ldiv_t>())).rem as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).rem) as usize - ptr as usize },
         8usize,
         concat!(
             "Offset of field: ",
@@ -5516,6 +3213,8 @@ pub struct lldiv_t {
 }
 #[test]
 fn bindgen_test_layout_lldiv_t() {
+    const UNINIT: ::core::mem::MaybeUninit<lldiv_t> = ::core::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::core::mem::size_of::<lldiv_t>(),
         16usize,
@@ -5527,7 +3226,7 @@ fn bindgen_test_layout_lldiv_t() {
         concat!("Alignment of ", stringify!(lldiv_t))
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<lldiv_t>())).quot as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).quot) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -5537,7 +3236,7 @@ fn bindgen_test_layout_lldiv_t() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<lldiv_t>())).rem as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).rem) as usize - ptr as usize },
         8usize,
         concat!(
             "Offset of field: ",
@@ -5548,7 +3247,7 @@ fn bindgen_test_layout_lldiv_t() {
     );
 }
 extern "C" {
-    pub fn __ctype_get_mb_cur_max() -> size_t;
+    pub fn __ctype_get_mb_cur_max() -> usize;
 }
 extern "C" {
     pub fn atof(__nptr: *const libc::c_char) -> f64;
@@ -5636,7 +3335,6 @@ pub type uid_t = __uid_t;
 pub type off_t = __off_t;
 pub type pid_t = __pid_t;
 pub type id_t = __id_t;
-pub type ssize_t = __ssize_t;
 pub type daddr_t = __daddr_t;
 pub type caddr_t = __caddr_t;
 pub type key_t = __key_t;
@@ -5659,6 +3357,8 @@ pub struct __sigset_t {
 }
 #[test]
 fn bindgen_test_layout___sigset_t() {
+    const UNINIT: ::core::mem::MaybeUninit<__sigset_t> = ::core::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::core::mem::size_of::<__sigset_t>(),
         128usize,
@@ -5670,7 +3370,7 @@ fn bindgen_test_layout___sigset_t() {
         concat!("Alignment of ", stringify!(__sigset_t))
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<__sigset_t>())).__val as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).__val) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -5689,6 +3389,8 @@ pub struct timeval {
 }
 #[test]
 fn bindgen_test_layout_timeval() {
+    const UNINIT: ::core::mem::MaybeUninit<timeval> = ::core::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::core::mem::size_of::<timeval>(),
         16usize,
@@ -5700,7 +3402,7 @@ fn bindgen_test_layout_timeval() {
         concat!("Alignment of ", stringify!(timeval))
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<timeval>())).tv_sec as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).tv_sec) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -5710,7 +3412,7 @@ fn bindgen_test_layout_timeval() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<timeval>())).tv_usec as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).tv_usec) as usize - ptr as usize },
         8usize,
         concat!(
             "Offset of field: ",
@@ -5728,6 +3430,8 @@ pub struct timespec {
 }
 #[test]
 fn bindgen_test_layout_timespec() {
+    const UNINIT: ::core::mem::MaybeUninit<timespec> = ::core::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::core::mem::size_of::<timespec>(),
         16usize,
@@ -5739,7 +3443,7 @@ fn bindgen_test_layout_timespec() {
         concat!("Alignment of ", stringify!(timespec))
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<timespec>())).tv_sec as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).tv_sec) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -5749,7 +3453,7 @@ fn bindgen_test_layout_timespec() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<timespec>())).tv_nsec as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).tv_nsec) as usize - ptr as usize },
         8usize,
         concat!(
             "Offset of field: ",
@@ -5768,6 +3472,8 @@ pub struct fd_set {
 }
 #[test]
 fn bindgen_test_layout_fd_set() {
+    const UNINIT: ::core::mem::MaybeUninit<fd_set> = ::core::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::core::mem::size_of::<fd_set>(),
         128usize,
@@ -5779,7 +3485,7 @@ fn bindgen_test_layout_fd_set() {
         concat!("Alignment of ", stringify!(fd_set))
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<fd_set>())).__fds_bits as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).__fds_bits) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -5818,7 +3524,6 @@ pub type fsfilcnt_t = __fsfilcnt_t;
 pub union __atomic_wide_counter {
     pub __value64: libc::c_ulonglong,
     pub __value32: __atomic_wide_counter__bindgen_ty_1,
-    _bindgen_union_align: u64,
 }
 #[repr(C)]
 #[derive(Copy, Clone)]
@@ -5828,6 +3533,9 @@ pub struct __atomic_wide_counter__bindgen_ty_1 {
 }
 #[test]
 fn bindgen_test_layout___atomic_wide_counter__bindgen_ty_1() {
+    const UNINIT: ::core::mem::MaybeUninit<__atomic_wide_counter__bindgen_ty_1> =
+        ::core::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::core::mem::size_of::<__atomic_wide_counter__bindgen_ty_1>(),
         8usize,
@@ -5842,10 +3550,7 @@ fn bindgen_test_layout___atomic_wide_counter__bindgen_ty_1() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::core::ptr::null::<__atomic_wide_counter__bindgen_ty_1>())).__low as *const _
-                as usize
-        },
+        unsafe { ::core::ptr::addr_of!((*ptr).__low) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -5855,10 +3560,7 @@ fn bindgen_test_layout___atomic_wide_counter__bindgen_ty_1() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::core::ptr::null::<__atomic_wide_counter__bindgen_ty_1>())).__high as *const _
-                as usize
-        },
+        unsafe { ::core::ptr::addr_of!((*ptr).__high) as usize - ptr as usize },
         4usize,
         concat!(
             "Offset of field: ",
@@ -5870,6 +3572,9 @@ fn bindgen_test_layout___atomic_wide_counter__bindgen_ty_1() {
 }
 #[test]
 fn bindgen_test_layout___atomic_wide_counter() {
+    const UNINIT: ::core::mem::MaybeUninit<__atomic_wide_counter> =
+        ::core::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::core::mem::size_of::<__atomic_wide_counter>(),
         8usize,
@@ -5881,9 +3586,7 @@ fn bindgen_test_layout___atomic_wide_counter() {
         concat!("Alignment of ", stringify!(__atomic_wide_counter))
     );
     assert_eq!(
-        unsafe {
-            &(*(::core::ptr::null::<__atomic_wide_counter>())).__value64 as *const _ as usize
-        },
+        unsafe { ::core::ptr::addr_of!((*ptr).__value64) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -5893,9 +3596,7 @@ fn bindgen_test_layout___atomic_wide_counter() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::core::ptr::null::<__atomic_wide_counter>())).__value32 as *const _ as usize
-        },
+        unsafe { ::core::ptr::addr_of!((*ptr).__value32) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -5913,6 +3614,9 @@ pub struct __pthread_internal_list {
 }
 #[test]
 fn bindgen_test_layout___pthread_internal_list() {
+    const UNINIT: ::core::mem::MaybeUninit<__pthread_internal_list> =
+        ::core::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::core::mem::size_of::<__pthread_internal_list>(),
         16usize,
@@ -5924,7 +3628,7 @@ fn bindgen_test_layout___pthread_internal_list() {
         concat!("Alignment of ", stringify!(__pthread_internal_list))
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<__pthread_internal_list>())).__prev as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).__prev) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -5934,7 +3638,7 @@ fn bindgen_test_layout___pthread_internal_list() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<__pthread_internal_list>())).__next as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).__next) as usize - ptr as usize },
         8usize,
         concat!(
             "Offset of field: ",
@@ -5952,6 +3656,9 @@ pub struct __pthread_internal_slist {
 }
 #[test]
 fn bindgen_test_layout___pthread_internal_slist() {
+    const UNINIT: ::core::mem::MaybeUninit<__pthread_internal_slist> =
+        ::core::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::core::mem::size_of::<__pthread_internal_slist>(),
         8usize,
@@ -5963,9 +3670,7 @@ fn bindgen_test_layout___pthread_internal_slist() {
         concat!("Alignment of ", stringify!(__pthread_internal_slist))
     );
     assert_eq!(
-        unsafe {
-            &(*(::core::ptr::null::<__pthread_internal_slist>())).__next as *const _ as usize
-        },
+        unsafe { ::core::ptr::addr_of!((*ptr).__next) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -5990,6 +3695,8 @@ pub struct __pthread_mutex_s {
 }
 #[test]
 fn bindgen_test_layout___pthread_mutex_s() {
+    const UNINIT: ::core::mem::MaybeUninit<__pthread_mutex_s> = ::core::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::core::mem::size_of::<__pthread_mutex_s>(),
         40usize,
@@ -6001,7 +3708,7 @@ fn bindgen_test_layout___pthread_mutex_s() {
         concat!("Alignment of ", stringify!(__pthread_mutex_s))
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<__pthread_mutex_s>())).__lock as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).__lock) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -6011,7 +3718,7 @@ fn bindgen_test_layout___pthread_mutex_s() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<__pthread_mutex_s>())).__count as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).__count) as usize - ptr as usize },
         4usize,
         concat!(
             "Offset of field: ",
@@ -6021,7 +3728,7 @@ fn bindgen_test_layout___pthread_mutex_s() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<__pthread_mutex_s>())).__owner as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).__owner) as usize - ptr as usize },
         8usize,
         concat!(
             "Offset of field: ",
@@ -6031,7 +3738,7 @@ fn bindgen_test_layout___pthread_mutex_s() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<__pthread_mutex_s>())).__nusers as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).__nusers) as usize - ptr as usize },
         12usize,
         concat!(
             "Offset of field: ",
@@ -6041,7 +3748,7 @@ fn bindgen_test_layout___pthread_mutex_s() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<__pthread_mutex_s>())).__kind as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).__kind) as usize - ptr as usize },
         16usize,
         concat!(
             "Offset of field: ",
@@ -6051,7 +3758,7 @@ fn bindgen_test_layout___pthread_mutex_s() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<__pthread_mutex_s>())).__spins as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).__spins) as usize - ptr as usize },
         20usize,
         concat!(
             "Offset of field: ",
@@ -6061,7 +3768,7 @@ fn bindgen_test_layout___pthread_mutex_s() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<__pthread_mutex_s>())).__elision as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).__elision) as usize - ptr as usize },
         22usize,
         concat!(
             "Offset of field: ",
@@ -6071,7 +3778,7 @@ fn bindgen_test_layout___pthread_mutex_s() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<__pthread_mutex_s>())).__list as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).__list) as usize - ptr as usize },
         24usize,
         concat!(
             "Offset of field: ",
@@ -6099,6 +3806,9 @@ pub struct __pthread_rwlock_arch_t {
 }
 #[test]
 fn bindgen_test_layout___pthread_rwlock_arch_t() {
+    const UNINIT: ::core::mem::MaybeUninit<__pthread_rwlock_arch_t> =
+        ::core::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::core::mem::size_of::<__pthread_rwlock_arch_t>(),
         56usize,
@@ -6110,9 +3820,7 @@ fn bindgen_test_layout___pthread_rwlock_arch_t() {
         concat!("Alignment of ", stringify!(__pthread_rwlock_arch_t))
     );
     assert_eq!(
-        unsafe {
-            &(*(::core::ptr::null::<__pthread_rwlock_arch_t>())).__readers as *const _ as usize
-        },
+        unsafe { ::core::ptr::addr_of!((*ptr).__readers) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -6122,9 +3830,7 @@ fn bindgen_test_layout___pthread_rwlock_arch_t() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::core::ptr::null::<__pthread_rwlock_arch_t>())).__writers as *const _ as usize
-        },
+        unsafe { ::core::ptr::addr_of!((*ptr).__writers) as usize - ptr as usize },
         4usize,
         concat!(
             "Offset of field: ",
@@ -6134,10 +3840,7 @@ fn bindgen_test_layout___pthread_rwlock_arch_t() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::core::ptr::null::<__pthread_rwlock_arch_t>())).__wrphase_futex as *const _
-                as usize
-        },
+        unsafe { ::core::ptr::addr_of!((*ptr).__wrphase_futex) as usize - ptr as usize },
         8usize,
         concat!(
             "Offset of field: ",
@@ -6147,10 +3850,7 @@ fn bindgen_test_layout___pthread_rwlock_arch_t() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::core::ptr::null::<__pthread_rwlock_arch_t>())).__writers_futex as *const _
-                as usize
-        },
+        unsafe { ::core::ptr::addr_of!((*ptr).__writers_futex) as usize - ptr as usize },
         12usize,
         concat!(
             "Offset of field: ",
@@ -6160,7 +3860,7 @@ fn bindgen_test_layout___pthread_rwlock_arch_t() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<__pthread_rwlock_arch_t>())).__pad3 as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).__pad3) as usize - ptr as usize },
         16usize,
         concat!(
             "Offset of field: ",
@@ -6170,7 +3870,7 @@ fn bindgen_test_layout___pthread_rwlock_arch_t() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<__pthread_rwlock_arch_t>())).__pad4 as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).__pad4) as usize - ptr as usize },
         20usize,
         concat!(
             "Offset of field: ",
@@ -6180,9 +3880,7 @@ fn bindgen_test_layout___pthread_rwlock_arch_t() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::core::ptr::null::<__pthread_rwlock_arch_t>())).__cur_writer as *const _ as usize
-        },
+        unsafe { ::core::ptr::addr_of!((*ptr).__cur_writer) as usize - ptr as usize },
         24usize,
         concat!(
             "Offset of field: ",
@@ -6192,9 +3890,7 @@ fn bindgen_test_layout___pthread_rwlock_arch_t() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::core::ptr::null::<__pthread_rwlock_arch_t>())).__shared as *const _ as usize
-        },
+        unsafe { ::core::ptr::addr_of!((*ptr).__shared) as usize - ptr as usize },
         28usize,
         concat!(
             "Offset of field: ",
@@ -6204,9 +3900,7 @@ fn bindgen_test_layout___pthread_rwlock_arch_t() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::core::ptr::null::<__pthread_rwlock_arch_t>())).__rwelision as *const _ as usize
-        },
+        unsafe { ::core::ptr::addr_of!((*ptr).__rwelision) as usize - ptr as usize },
         32usize,
         concat!(
             "Offset of field: ",
@@ -6216,7 +3910,7 @@ fn bindgen_test_layout___pthread_rwlock_arch_t() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<__pthread_rwlock_arch_t>())).__pad1 as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).__pad1) as usize - ptr as usize },
         33usize,
         concat!(
             "Offset of field: ",
@@ -6226,7 +3920,7 @@ fn bindgen_test_layout___pthread_rwlock_arch_t() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<__pthread_rwlock_arch_t>())).__pad2 as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).__pad2) as usize - ptr as usize },
         40usize,
         concat!(
             "Offset of field: ",
@@ -6236,9 +3930,7 @@ fn bindgen_test_layout___pthread_rwlock_arch_t() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::core::ptr::null::<__pthread_rwlock_arch_t>())).__flags as *const _ as usize
-        },
+        unsafe { ::core::ptr::addr_of!((*ptr).__flags) as usize - ptr as usize },
         48usize,
         concat!(
             "Offset of field: ",
@@ -6261,6 +3953,8 @@ pub struct __pthread_cond_s {
 }
 #[test]
 fn bindgen_test_layout___pthread_cond_s() {
+    const UNINIT: ::core::mem::MaybeUninit<__pthread_cond_s> = ::core::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::core::mem::size_of::<__pthread_cond_s>(),
         48usize,
@@ -6272,7 +3966,7 @@ fn bindgen_test_layout___pthread_cond_s() {
         concat!("Alignment of ", stringify!(__pthread_cond_s))
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<__pthread_cond_s>())).__wseq as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).__wseq) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -6282,7 +3976,7 @@ fn bindgen_test_layout___pthread_cond_s() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<__pthread_cond_s>())).__g1_start as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).__g1_start) as usize - ptr as usize },
         8usize,
         concat!(
             "Offset of field: ",
@@ -6292,7 +3986,7 @@ fn bindgen_test_layout___pthread_cond_s() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<__pthread_cond_s>())).__g_refs as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).__g_refs) as usize - ptr as usize },
         16usize,
         concat!(
             "Offset of field: ",
@@ -6302,7 +3996,7 @@ fn bindgen_test_layout___pthread_cond_s() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<__pthread_cond_s>())).__g_size as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).__g_size) as usize - ptr as usize },
         24usize,
         concat!(
             "Offset of field: ",
@@ -6312,9 +4006,7 @@ fn bindgen_test_layout___pthread_cond_s() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::core::ptr::null::<__pthread_cond_s>())).__g1_orig_size as *const _ as usize
-        },
+        unsafe { ::core::ptr::addr_of!((*ptr).__g1_orig_size) as usize - ptr as usize },
         32usize,
         concat!(
             "Offset of field: ",
@@ -6324,7 +4016,7 @@ fn bindgen_test_layout___pthread_cond_s() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<__pthread_cond_s>())).__wrefs as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).__wrefs) as usize - ptr as usize },
         36usize,
         concat!(
             "Offset of field: ",
@@ -6334,7 +4026,7 @@ fn bindgen_test_layout___pthread_cond_s() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<__pthread_cond_s>())).__g_signals as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).__g_signals) as usize - ptr as usize },
         40usize,
         concat!(
             "Offset of field: ",
@@ -6353,6 +4045,8 @@ pub struct __once_flag {
 }
 #[test]
 fn bindgen_test_layout___once_flag() {
+    const UNINIT: ::core::mem::MaybeUninit<__once_flag> = ::core::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::core::mem::size_of::<__once_flag>(),
         4usize,
@@ -6364,7 +4058,7 @@ fn bindgen_test_layout___once_flag() {
         concat!("Alignment of ", stringify!(__once_flag))
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<__once_flag>())).__data as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).__data) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -6380,10 +4074,12 @@ pub type pthread_t = libc::c_ulong;
 pub union pthread_mutexattr_t {
     pub __size: [libc::c_char; 4usize],
     pub __align: libc::c_int,
-    _bindgen_union_align: u32,
 }
 #[test]
 fn bindgen_test_layout_pthread_mutexattr_t() {
+    const UNINIT: ::core::mem::MaybeUninit<pthread_mutexattr_t> =
+        ::core::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::core::mem::size_of::<pthread_mutexattr_t>(),
         4usize,
@@ -6395,7 +4091,7 @@ fn bindgen_test_layout_pthread_mutexattr_t() {
         concat!("Alignment of ", stringify!(pthread_mutexattr_t))
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<pthread_mutexattr_t>())).__size as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).__size) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -6405,7 +4101,7 @@ fn bindgen_test_layout_pthread_mutexattr_t() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<pthread_mutexattr_t>())).__align as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).__align) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -6420,10 +4116,11 @@ fn bindgen_test_layout_pthread_mutexattr_t() {
 pub union pthread_condattr_t {
     pub __size: [libc::c_char; 4usize],
     pub __align: libc::c_int,
-    _bindgen_union_align: u32,
 }
 #[test]
 fn bindgen_test_layout_pthread_condattr_t() {
+    const UNINIT: ::core::mem::MaybeUninit<pthread_condattr_t> = ::core::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::core::mem::size_of::<pthread_condattr_t>(),
         4usize,
@@ -6435,7 +4132,7 @@ fn bindgen_test_layout_pthread_condattr_t() {
         concat!("Alignment of ", stringify!(pthread_condattr_t))
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<pthread_condattr_t>())).__size as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).__size) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -6445,7 +4142,7 @@ fn bindgen_test_layout_pthread_condattr_t() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<pthread_condattr_t>())).__align as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).__align) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -6462,10 +4159,11 @@ pub type pthread_once_t = libc::c_int;
 pub union pthread_attr_t {
     pub __size: [libc::c_char; 56usize],
     pub __align: libc::c_long,
-    _bindgen_union_align: [u64; 7usize],
 }
 #[test]
 fn bindgen_test_layout_pthread_attr_t() {
+    const UNINIT: ::core::mem::MaybeUninit<pthread_attr_t> = ::core::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::core::mem::size_of::<pthread_attr_t>(),
         56usize,
@@ -6477,7 +4175,7 @@ fn bindgen_test_layout_pthread_attr_t() {
         concat!("Alignment of ", stringify!(pthread_attr_t))
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<pthread_attr_t>())).__size as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).__size) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -6487,7 +4185,7 @@ fn bindgen_test_layout_pthread_attr_t() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<pthread_attr_t>())).__align as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).__align) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -6503,10 +4201,11 @@ pub union pthread_mutex_t {
     pub __data: __pthread_mutex_s,
     pub __size: [libc::c_char; 40usize],
     pub __align: libc::c_long,
-    _bindgen_union_align: [u64; 5usize],
 }
 #[test]
 fn bindgen_test_layout_pthread_mutex_t() {
+    const UNINIT: ::core::mem::MaybeUninit<pthread_mutex_t> = ::core::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::core::mem::size_of::<pthread_mutex_t>(),
         40usize,
@@ -6518,7 +4217,7 @@ fn bindgen_test_layout_pthread_mutex_t() {
         concat!("Alignment of ", stringify!(pthread_mutex_t))
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<pthread_mutex_t>())).__data as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).__data) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -6528,7 +4227,7 @@ fn bindgen_test_layout_pthread_mutex_t() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<pthread_mutex_t>())).__size as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).__size) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -6538,7 +4237,7 @@ fn bindgen_test_layout_pthread_mutex_t() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<pthread_mutex_t>())).__align as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).__align) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -6554,10 +4253,11 @@ pub union pthread_cond_t {
     pub __data: __pthread_cond_s,
     pub __size: [libc::c_char; 48usize],
     pub __align: libc::c_longlong,
-    _bindgen_union_align: [u64; 6usize],
 }
 #[test]
 fn bindgen_test_layout_pthread_cond_t() {
+    const UNINIT: ::core::mem::MaybeUninit<pthread_cond_t> = ::core::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::core::mem::size_of::<pthread_cond_t>(),
         48usize,
@@ -6569,7 +4269,7 @@ fn bindgen_test_layout_pthread_cond_t() {
         concat!("Alignment of ", stringify!(pthread_cond_t))
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<pthread_cond_t>())).__data as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).__data) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -6579,7 +4279,7 @@ fn bindgen_test_layout_pthread_cond_t() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<pthread_cond_t>())).__size as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).__size) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -6589,7 +4289,7 @@ fn bindgen_test_layout_pthread_cond_t() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<pthread_cond_t>())).__align as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).__align) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -6605,10 +4305,11 @@ pub union pthread_rwlock_t {
     pub __data: __pthread_rwlock_arch_t,
     pub __size: [libc::c_char; 56usize],
     pub __align: libc::c_long,
-    _bindgen_union_align: [u64; 7usize],
 }
 #[test]
 fn bindgen_test_layout_pthread_rwlock_t() {
+    const UNINIT: ::core::mem::MaybeUninit<pthread_rwlock_t> = ::core::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::core::mem::size_of::<pthread_rwlock_t>(),
         56usize,
@@ -6620,7 +4321,7 @@ fn bindgen_test_layout_pthread_rwlock_t() {
         concat!("Alignment of ", stringify!(pthread_rwlock_t))
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<pthread_rwlock_t>())).__data as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).__data) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -6630,7 +4331,7 @@ fn bindgen_test_layout_pthread_rwlock_t() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<pthread_rwlock_t>())).__size as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).__size) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -6640,7 +4341,7 @@ fn bindgen_test_layout_pthread_rwlock_t() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<pthread_rwlock_t>())).__align as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).__align) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -6655,10 +4356,12 @@ fn bindgen_test_layout_pthread_rwlock_t() {
 pub union pthread_rwlockattr_t {
     pub __size: [libc::c_char; 8usize],
     pub __align: libc::c_long,
-    _bindgen_union_align: u64,
 }
 #[test]
 fn bindgen_test_layout_pthread_rwlockattr_t() {
+    const UNINIT: ::core::mem::MaybeUninit<pthread_rwlockattr_t> =
+        ::core::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::core::mem::size_of::<pthread_rwlockattr_t>(),
         8usize,
@@ -6670,7 +4373,7 @@ fn bindgen_test_layout_pthread_rwlockattr_t() {
         concat!("Alignment of ", stringify!(pthread_rwlockattr_t))
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<pthread_rwlockattr_t>())).__size as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).__size) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -6680,7 +4383,7 @@ fn bindgen_test_layout_pthread_rwlockattr_t() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<pthread_rwlockattr_t>())).__align as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).__align) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -6696,10 +4399,11 @@ pub type pthread_spinlock_t = libc::c_int;
 pub union pthread_barrier_t {
     pub __size: [libc::c_char; 32usize],
     pub __align: libc::c_long,
-    _bindgen_union_align: [u64; 4usize],
 }
 #[test]
 fn bindgen_test_layout_pthread_barrier_t() {
+    const UNINIT: ::core::mem::MaybeUninit<pthread_barrier_t> = ::core::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::core::mem::size_of::<pthread_barrier_t>(),
         32usize,
@@ -6711,7 +4415,7 @@ fn bindgen_test_layout_pthread_barrier_t() {
         concat!("Alignment of ", stringify!(pthread_barrier_t))
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<pthread_barrier_t>())).__size as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).__size) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -6721,7 +4425,7 @@ fn bindgen_test_layout_pthread_barrier_t() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<pthread_barrier_t>())).__align as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).__align) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -6736,10 +4440,12 @@ fn bindgen_test_layout_pthread_barrier_t() {
 pub union pthread_barrierattr_t {
     pub __size: [libc::c_char; 4usize],
     pub __align: libc::c_int,
-    _bindgen_union_align: u32,
 }
 #[test]
 fn bindgen_test_layout_pthread_barrierattr_t() {
+    const UNINIT: ::core::mem::MaybeUninit<pthread_barrierattr_t> =
+        ::core::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::core::mem::size_of::<pthread_barrierattr_t>(),
         4usize,
@@ -6751,7 +4457,7 @@ fn bindgen_test_layout_pthread_barrierattr_t() {
         concat!("Alignment of ", stringify!(pthread_barrierattr_t))
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<pthread_barrierattr_t>())).__size as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).__size) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -6761,7 +4467,7 @@ fn bindgen_test_layout_pthread_barrierattr_t() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<pthread_barrierattr_t>())).__align as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).__align) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -6781,7 +4487,7 @@ extern "C" {
     pub fn initstate(
         __seed: libc::c_uint,
         __statebuf: *mut libc::c_char,
-        __statelen: size_t,
+        __statelen: usize,
     ) -> *mut libc::c_char;
 }
 extern "C" {
@@ -6800,6 +4506,8 @@ pub struct random_data {
 }
 #[test]
 fn bindgen_test_layout_random_data() {
+    const UNINIT: ::core::mem::MaybeUninit<random_data> = ::core::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::core::mem::size_of::<random_data>(),
         48usize,
@@ -6811,7 +4519,7 @@ fn bindgen_test_layout_random_data() {
         concat!("Alignment of ", stringify!(random_data))
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<random_data>())).fptr as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).fptr) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -6821,7 +4529,7 @@ fn bindgen_test_layout_random_data() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<random_data>())).rptr as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).rptr) as usize - ptr as usize },
         8usize,
         concat!(
             "Offset of field: ",
@@ -6831,7 +4539,7 @@ fn bindgen_test_layout_random_data() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<random_data>())).state as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).state) as usize - ptr as usize },
         16usize,
         concat!(
             "Offset of field: ",
@@ -6841,7 +4549,7 @@ fn bindgen_test_layout_random_data() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<random_data>())).rand_type as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).rand_type) as usize - ptr as usize },
         24usize,
         concat!(
             "Offset of field: ",
@@ -6851,7 +4559,7 @@ fn bindgen_test_layout_random_data() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<random_data>())).rand_deg as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).rand_deg) as usize - ptr as usize },
         28usize,
         concat!(
             "Offset of field: ",
@@ -6861,7 +4569,7 @@ fn bindgen_test_layout_random_data() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<random_data>())).rand_sep as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).rand_sep) as usize - ptr as usize },
         32usize,
         concat!(
             "Offset of field: ",
@@ -6871,7 +4579,7 @@ fn bindgen_test_layout_random_data() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<random_data>())).end_ptr as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).end_ptr) as usize - ptr as usize },
         40usize,
         concat!(
             "Offset of field: ",
@@ -6891,7 +4599,7 @@ extern "C" {
     pub fn initstate_r(
         __seed: libc::c_uint,
         __statebuf: *mut libc::c_char,
-        __statelen: size_t,
+        __statelen: usize,
         __buf: *mut random_data,
     ) -> libc::c_int;
 }
@@ -6945,6 +4653,8 @@ pub struct drand48_data {
 }
 #[test]
 fn bindgen_test_layout_drand48_data() {
+    const UNINIT: ::core::mem::MaybeUninit<drand48_data> = ::core::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::core::mem::size_of::<drand48_data>(),
         24usize,
@@ -6956,7 +4666,7 @@ fn bindgen_test_layout_drand48_data() {
         concat!("Alignment of ", stringify!(drand48_data))
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<drand48_data>())).__x as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).__x) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -6966,7 +4676,7 @@ fn bindgen_test_layout_drand48_data() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<drand48_data>())).__old_x as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).__old_x) as usize - ptr as usize },
         6usize,
         concat!(
             "Offset of field: ",
@@ -6976,7 +4686,7 @@ fn bindgen_test_layout_drand48_data() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<drand48_data>())).__c as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).__c) as usize - ptr as usize },
         12usize,
         concat!(
             "Offset of field: ",
@@ -6986,7 +4696,7 @@ fn bindgen_test_layout_drand48_data() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<drand48_data>())).__init as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).__init) as usize - ptr as usize },
         14usize,
         concat!(
             "Offset of field: ",
@@ -6996,7 +4706,7 @@ fn bindgen_test_layout_drand48_data() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<drand48_data>())).__a as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).__a) as usize - ptr as usize },
         16usize,
         concat!(
             "Offset of field: ",
@@ -7045,6 +4755,15 @@ extern "C" {
 extern "C" {
     pub fn lcong48_r(__param: *mut libc::c_ushort, __buffer: *mut drand48_data) -> libc::c_int;
 }
+extern "C" {
+    pub fn arc4random() -> __uint32_t;
+}
+extern "C" {
+    pub fn arc4random_buf(__buf: *mut libc::c_void, __size: usize);
+}
+extern "C" {
+    pub fn arc4random_uniform(__upper_bound: __uint32_t) -> __uint32_t;
+}
 extern "C" {
     pub fn malloc(__size: libc::c_ulong) -> *mut libc::c_void;
 }
@@ -7060,28 +4779,28 @@ extern "C" {
 extern "C" {
     pub fn reallocarray(
         __ptr: *mut libc::c_void,
-        __nmemb: size_t,
-        __size: size_t,
+        __nmemb: usize,
+        __size: usize,
     ) -> *mut libc::c_void;
 }
 extern "C" {
     pub fn alloca(__size: libc::c_ulong) -> *mut libc::c_void;
 }
 extern "C" {
-    pub fn valloc(__size: size_t) -> *mut libc::c_void;
+    pub fn valloc(__size: usize) -> *mut libc::c_void;
 }
 extern "C" {
     pub fn posix_memalign(
         __memptr: *mut *mut libc::c_void,
-        __alignment: size_t,
-        __size: size_t,
+        __alignment: usize,
+        __size: usize,
     ) -> libc::c_int;
 }
 extern "C" {
     pub fn aligned_alloc(__alignment: libc::c_ulong, __size: libc::c_ulong) -> *mut libc::c_void;
 }
 extern "C" {
-    pub fn abort();
+    pub fn abort() -> !;
 }
 extern "C" {
     pub fn atexit(__func: ::core::option::Option<unsafe extern "C" fn()>) -> libc::c_int;
@@ -7098,13 +4817,13 @@ extern "C" {
     ) -> libc::c_int;
 }
 extern "C" {
-    pub fn exit(__status: libc::c_int);
+    pub fn exit(__status: libc::c_int) -> !;
 }
 extern "C" {
-    pub fn quick_exit(__status: libc::c_int);
+    pub fn quick_exit(__status: libc::c_int) -> !;
 }
 extern "C" {
-    pub fn _Exit(__status: libc::c_int);
+    pub fn _Exit(__status: libc::c_int) -> !;
 }
 extern "C" {
     pub fn getenv(__name: *const libc::c_char) -> *mut libc::c_char;
@@ -7153,18 +4872,13 @@ extern "C" {
     pub fn bsearch(
         __key: *const libc::c_void,
         __base: *const libc::c_void,
-        __nmemb: size_t,
-        __size: size_t,
+        __nmemb: usize,
+        __size: usize,
         __compar: __compar_fn_t,
     ) -> *mut libc::c_void;
 }
 extern "C" {
-    pub fn qsort(
-        __base: *mut libc::c_void,
-        __nmemb: size_t,
-        __size: size_t,
-        __compar: __compar_fn_t,
-    );
+    pub fn qsort(__base: *mut libc::c_void, __nmemb: usize, __size: usize, __compar: __compar_fn_t);
 }
 extern "C" {
     pub fn abs(__x: libc::c_int) -> libc::c_int;
@@ -7234,7 +4948,7 @@ extern "C" {
         __decpt: *mut libc::c_int,
         __sign: *mut libc::c_int,
         __buf: *mut libc::c_char,
-        __len: size_t,
+        __len: usize,
     ) -> libc::c_int;
 }
 extern "C" {
@@ -7244,7 +4958,7 @@ extern "C" {
         __decpt: *mut libc::c_int,
         __sign: *mut libc::c_int,
         __buf: *mut libc::c_char,
-        __len: size_t,
+        __len: usize,
     ) -> libc::c_int;
 }
 extern "C" {
@@ -7254,7 +4968,7 @@ extern "C" {
         __decpt: *mut libc::c_int,
         __sign: *mut libc::c_int,
         __buf: *mut libc::c_char,
-        __len: size_t,
+        __len: usize,
     ) -> libc::c_int;
 }
 extern "C" {
@@ -7264,23 +4978,23 @@ extern "C" {
         __decpt: *mut libc::c_int,
         __sign: *mut libc::c_int,
         __buf: *mut libc::c_char,
-        __len: size_t,
+        __len: usize,
     ) -> libc::c_int;
 }
 extern "C" {
-    pub fn mblen(__s: *const libc::c_char, __n: size_t) -> libc::c_int;
+    pub fn mblen(__s: *const libc::c_char, __n: usize) -> libc::c_int;
 }
 extern "C" {
-    pub fn mbtowc(__pwc: *mut wchar_t, __s: *const libc::c_char, __n: size_t) -> libc::c_int;
+    pub fn mbtowc(__pwc: *mut wchar_t, __s: *const libc::c_char, __n: usize) -> libc::c_int;
 }
 extern "C" {
     pub fn wctomb(__s: *mut libc::c_char, __wchar: wchar_t) -> libc::c_int;
 }
 extern "C" {
-    pub fn mbstowcs(__pwcs: *mut wchar_t, __s: *const libc::c_char, __n: size_t) -> size_t;
+    pub fn mbstowcs(__pwcs: *mut wchar_t, __s: *const libc::c_char, __n: usize) -> usize;
 }
 extern "C" {
-    pub fn wcstombs(__s: *mut libc::c_char, __pwcs: *const wchar_t, __n: size_t) -> size_t;
+    pub fn wcstombs(__s: *mut libc::c_char, __pwcs: *const wchar_t, __n: usize) -> usize;
 }
 extern "C" {
     pub fn rpmatch(__response: *const libc::c_char) -> libc::c_int;
@@ -7316,6 +5030,11 @@ pub type __v2du = [libc::c_ulonglong; 2usize];
 pub type __v8hu = [libc::c_ushort; 8usize];
 pub type __v16qu = [libc::c_uchar; 16usize];
 pub type __v16qs = [libc::c_schar; 16usize];
+pub type __v8hf = [__BindgenFloat16; 8usize];
+pub type __m128h = [__BindgenFloat16; 8usize];
+pub type __m128h_u = [__BindgenFloat16; 8usize];
+pub type __v8bf = u128;
+pub type __m128bh = u128;
 extern "C" {
     pub fn _mm_clflush(__p: *const libc::c_void);
 }
@@ -7329,407 +5048,100 @@ extern "C" {
     pub fn _mm_pause();
 }
 extern "C" {
-    #[doc = " Get the number of CPU cores available."]
-    #[doc = ""]
-    #[doc = " \\returns the total number of logical CPU cores. On CPUs that include"]
-    #[doc = "          technologies such as hyperthreading, the number of logical cores"]
-    #[doc = "          may be more than the number of physical cores."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
+    #[doc = " Get the number of CPU cores available.\n\n \\returns the total number of logical CPU cores. On CPUs that include\n          technologies such as hyperthreading, the number of logical cores\n          may be more than the number of physical cores.\n\n \\since This function is available since SDL 2.0.0."]
     pub fn SDL_GetCPUCount() -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Determine the L1 cache line size of the CPU."]
-    #[doc = ""]
-    #[doc = " This is useful for determining multi-threaded structure padding or SIMD"]
-    #[doc = " prefetch sizes."]
-    #[doc = ""]
-    #[doc = " \\returns the L1 cache line size of the CPU, in bytes."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
+    #[doc = " Determine the L1 cache line size of the CPU.\n\n This is useful for determining multi-threaded structure padding or SIMD\n prefetch sizes.\n\n \\returns the L1 cache line size of the CPU, in bytes.\n\n \\since This function is available since SDL 2.0.0."]
     pub fn SDL_GetCPUCacheLineSize() -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Determine whether the CPU has the RDTSC instruction."]
-    #[doc = ""]
-    #[doc = " This always returns false on CPUs that aren't using Intel instruction sets."]
-    #[doc = ""]
-    #[doc = " \\returns SDL_TRUE if the CPU has the RDTSC instruction or SDL_FALSE if not."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_Has3DNow"]
-    #[doc = " \\sa SDL_HasAltiVec"]
-    #[doc = " \\sa SDL_HasAVX"]
-    #[doc = " \\sa SDL_HasAVX2"]
-    #[doc = " \\sa SDL_HasMMX"]
-    #[doc = " \\sa SDL_HasSSE"]
-    #[doc = " \\sa SDL_HasSSE2"]
-    #[doc = " \\sa SDL_HasSSE3"]
-    #[doc = " \\sa SDL_HasSSE41"]
-    #[doc = " \\sa SDL_HasSSE42"]
+    #[doc = " Determine whether the CPU has the RDTSC instruction.\n\n This always returns false on CPUs that aren't using Intel instruction sets.\n\n \\returns SDL_TRUE if the CPU has the RDTSC instruction or SDL_FALSE if not.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_Has3DNow\n \\sa SDL_HasAltiVec\n \\sa SDL_HasAVX\n \\sa SDL_HasAVX2\n \\sa SDL_HasMMX\n \\sa SDL_HasSSE\n \\sa SDL_HasSSE2\n \\sa SDL_HasSSE3\n \\sa SDL_HasSSE41\n \\sa SDL_HasSSE42"]
     pub fn SDL_HasRDTSC() -> SDL_bool;
 }
 extern "C" {
-    #[doc = " Determine whether the CPU has AltiVec features."]
-    #[doc = ""]
-    #[doc = " This always returns false on CPUs that aren't using PowerPC instruction"]
-    #[doc = " sets."]
-    #[doc = ""]
-    #[doc = " \\returns SDL_TRUE if the CPU has AltiVec features or SDL_FALSE if not."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_Has3DNow"]
-    #[doc = " \\sa SDL_HasAVX"]
-    #[doc = " \\sa SDL_HasAVX2"]
-    #[doc = " \\sa SDL_HasMMX"]
-    #[doc = " \\sa SDL_HasRDTSC"]
-    #[doc = " \\sa SDL_HasSSE"]
-    #[doc = " \\sa SDL_HasSSE2"]
-    #[doc = " \\sa SDL_HasSSE3"]
-    #[doc = " \\sa SDL_HasSSE41"]
-    #[doc = " \\sa SDL_HasSSE42"]
+    #[doc = " Determine whether the CPU has AltiVec features.\n\n This always returns false on CPUs that aren't using PowerPC instruction\n sets.\n\n \\returns SDL_TRUE if the CPU has AltiVec features or SDL_FALSE if not.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_Has3DNow\n \\sa SDL_HasAVX\n \\sa SDL_HasAVX2\n \\sa SDL_HasMMX\n \\sa SDL_HasRDTSC\n \\sa SDL_HasSSE\n \\sa SDL_HasSSE2\n \\sa SDL_HasSSE3\n \\sa SDL_HasSSE41\n \\sa SDL_HasSSE42"]
     pub fn SDL_HasAltiVec() -> SDL_bool;
 }
 extern "C" {
-    #[doc = " Determine whether the CPU has MMX features."]
-    #[doc = ""]
-    #[doc = " This always returns false on CPUs that aren't using Intel instruction sets."]
-    #[doc = ""]
-    #[doc = " \\returns SDL_TRUE if the CPU has MMX features or SDL_FALSE if not."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_Has3DNow"]
-    #[doc = " \\sa SDL_HasAltiVec"]
-    #[doc = " \\sa SDL_HasAVX"]
-    #[doc = " \\sa SDL_HasAVX2"]
-    #[doc = " \\sa SDL_HasRDTSC"]
-    #[doc = " \\sa SDL_HasSSE"]
-    #[doc = " \\sa SDL_HasSSE2"]
-    #[doc = " \\sa SDL_HasSSE3"]
-    #[doc = " \\sa SDL_HasSSE41"]
-    #[doc = " \\sa SDL_HasSSE42"]
+    #[doc = " Determine whether the CPU has MMX features.\n\n This always returns false on CPUs that aren't using Intel instruction sets.\n\n \\returns SDL_TRUE if the CPU has MMX features or SDL_FALSE if not.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_Has3DNow\n \\sa SDL_HasAltiVec\n \\sa SDL_HasAVX\n \\sa SDL_HasAVX2\n \\sa SDL_HasRDTSC\n \\sa SDL_HasSSE\n \\sa SDL_HasSSE2\n \\sa SDL_HasSSE3\n \\sa SDL_HasSSE41\n \\sa SDL_HasSSE42"]
     pub fn SDL_HasMMX() -> SDL_bool;
 }
 extern "C" {
-    #[doc = " Determine whether the CPU has 3DNow! features."]
-    #[doc = ""]
-    #[doc = " This always returns false on CPUs that aren't using AMD instruction sets."]
-    #[doc = ""]
-    #[doc = " \\returns SDL_TRUE if the CPU has 3DNow! features or SDL_FALSE if not."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_HasAltiVec"]
-    #[doc = " \\sa SDL_HasAVX"]
-    #[doc = " \\sa SDL_HasAVX2"]
-    #[doc = " \\sa SDL_HasMMX"]
-    #[doc = " \\sa SDL_HasRDTSC"]
-    #[doc = " \\sa SDL_HasSSE"]
-    #[doc = " \\sa SDL_HasSSE2"]
-    #[doc = " \\sa SDL_HasSSE3"]
-    #[doc = " \\sa SDL_HasSSE41"]
-    #[doc = " \\sa SDL_HasSSE42"]
+    #[doc = " Determine whether the CPU has 3DNow! features.\n\n This always returns false on CPUs that aren't using AMD instruction sets.\n\n \\returns SDL_TRUE if the CPU has 3DNow! features or SDL_FALSE if not.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_HasAltiVec\n \\sa SDL_HasAVX\n \\sa SDL_HasAVX2\n \\sa SDL_HasMMX\n \\sa SDL_HasRDTSC\n \\sa SDL_HasSSE\n \\sa SDL_HasSSE2\n \\sa SDL_HasSSE3\n \\sa SDL_HasSSE41\n \\sa SDL_HasSSE42"]
     pub fn SDL_Has3DNow() -> SDL_bool;
 }
 extern "C" {
-    #[doc = " Determine whether the CPU has SSE features."]
-    #[doc = ""]
-    #[doc = " This always returns false on CPUs that aren't using Intel instruction sets."]
-    #[doc = ""]
-    #[doc = " \\returns SDL_TRUE if the CPU has SSE features or SDL_FALSE if not."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_Has3DNow"]
-    #[doc = " \\sa SDL_HasAltiVec"]
-    #[doc = " \\sa SDL_HasAVX"]
-    #[doc = " \\sa SDL_HasAVX2"]
-    #[doc = " \\sa SDL_HasMMX"]
-    #[doc = " \\sa SDL_HasRDTSC"]
-    #[doc = " \\sa SDL_HasSSE2"]
-    #[doc = " \\sa SDL_HasSSE3"]
-    #[doc = " \\sa SDL_HasSSE41"]
-    #[doc = " \\sa SDL_HasSSE42"]
+    #[doc = " Determine whether the CPU has SSE features.\n\n This always returns false on CPUs that aren't using Intel instruction sets.\n\n \\returns SDL_TRUE if the CPU has SSE features or SDL_FALSE if not.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_Has3DNow\n \\sa SDL_HasAltiVec\n \\sa SDL_HasAVX\n \\sa SDL_HasAVX2\n \\sa SDL_HasMMX\n \\sa SDL_HasRDTSC\n \\sa SDL_HasSSE2\n \\sa SDL_HasSSE3\n \\sa SDL_HasSSE41\n \\sa SDL_HasSSE42"]
     pub fn SDL_HasSSE() -> SDL_bool;
 }
 extern "C" {
-    #[doc = " Determine whether the CPU has SSE2 features."]
-    #[doc = ""]
-    #[doc = " This always returns false on CPUs that aren't using Intel instruction sets."]
-    #[doc = ""]
-    #[doc = " \\returns SDL_TRUE if the CPU has SSE2 features or SDL_FALSE if not."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_Has3DNow"]
-    #[doc = " \\sa SDL_HasAltiVec"]
-    #[doc = " \\sa SDL_HasAVX"]
-    #[doc = " \\sa SDL_HasAVX2"]
-    #[doc = " \\sa SDL_HasMMX"]
-    #[doc = " \\sa SDL_HasRDTSC"]
-    #[doc = " \\sa SDL_HasSSE"]
-    #[doc = " \\sa SDL_HasSSE3"]
-    #[doc = " \\sa SDL_HasSSE41"]
-    #[doc = " \\sa SDL_HasSSE42"]
+    #[doc = " Determine whether the CPU has SSE2 features.\n\n This always returns false on CPUs that aren't using Intel instruction sets.\n\n \\returns SDL_TRUE if the CPU has SSE2 features or SDL_FALSE if not.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_Has3DNow\n \\sa SDL_HasAltiVec\n \\sa SDL_HasAVX\n \\sa SDL_HasAVX2\n \\sa SDL_HasMMX\n \\sa SDL_HasRDTSC\n \\sa SDL_HasSSE\n \\sa SDL_HasSSE3\n \\sa SDL_HasSSE41\n \\sa SDL_HasSSE42"]
     pub fn SDL_HasSSE2() -> SDL_bool;
 }
 extern "C" {
-    #[doc = " Determine whether the CPU has SSE3 features."]
-    #[doc = ""]
-    #[doc = " This always returns false on CPUs that aren't using Intel instruction sets."]
-    #[doc = ""]
-    #[doc = " \\returns SDL_TRUE if the CPU has SSE3 features or SDL_FALSE if not."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_Has3DNow"]
-    #[doc = " \\sa SDL_HasAltiVec"]
-    #[doc = " \\sa SDL_HasAVX"]
-    #[doc = " \\sa SDL_HasAVX2"]
-    #[doc = " \\sa SDL_HasMMX"]
-    #[doc = " \\sa SDL_HasRDTSC"]
-    #[doc = " \\sa SDL_HasSSE"]
-    #[doc = " \\sa SDL_HasSSE2"]
-    #[doc = " \\sa SDL_HasSSE41"]
-    #[doc = " \\sa SDL_HasSSE42"]
+    #[doc = " Determine whether the CPU has SSE3 features.\n\n This always returns false on CPUs that aren't using Intel instruction sets.\n\n \\returns SDL_TRUE if the CPU has SSE3 features or SDL_FALSE if not.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_Has3DNow\n \\sa SDL_HasAltiVec\n \\sa SDL_HasAVX\n \\sa SDL_HasAVX2\n \\sa SDL_HasMMX\n \\sa SDL_HasRDTSC\n \\sa SDL_HasSSE\n \\sa SDL_HasSSE2\n \\sa SDL_HasSSE41\n \\sa SDL_HasSSE42"]
     pub fn SDL_HasSSE3() -> SDL_bool;
 }
 extern "C" {
-    #[doc = " Determine whether the CPU has SSE4.1 features."]
-    #[doc = ""]
-    #[doc = " This always returns false on CPUs that aren't using Intel instruction sets."]
-    #[doc = ""]
-    #[doc = " \\returns SDL_TRUE if the CPU has SSE4.1 features or SDL_FALSE if not."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_Has3DNow"]
-    #[doc = " \\sa SDL_HasAltiVec"]
-    #[doc = " \\sa SDL_HasAVX"]
-    #[doc = " \\sa SDL_HasAVX2"]
-    #[doc = " \\sa SDL_HasMMX"]
-    #[doc = " \\sa SDL_HasRDTSC"]
-    #[doc = " \\sa SDL_HasSSE"]
-    #[doc = " \\sa SDL_HasSSE2"]
-    #[doc = " \\sa SDL_HasSSE3"]
-    #[doc = " \\sa SDL_HasSSE42"]
+    #[doc = " Determine whether the CPU has SSE4.1 features.\n\n This always returns false on CPUs that aren't using Intel instruction sets.\n\n \\returns SDL_TRUE if the CPU has SSE4.1 features or SDL_FALSE if not.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_Has3DNow\n \\sa SDL_HasAltiVec\n \\sa SDL_HasAVX\n \\sa SDL_HasAVX2\n \\sa SDL_HasMMX\n \\sa SDL_HasRDTSC\n \\sa SDL_HasSSE\n \\sa SDL_HasSSE2\n \\sa SDL_HasSSE3\n \\sa SDL_HasSSE42"]
     pub fn SDL_HasSSE41() -> SDL_bool;
 }
 extern "C" {
-    #[doc = " Determine whether the CPU has SSE4.2 features."]
-    #[doc = ""]
-    #[doc = " This always returns false on CPUs that aren't using Intel instruction sets."]
-    #[doc = ""]
-    #[doc = " \\returns SDL_TRUE if the CPU has SSE4.2 features or SDL_FALSE if not."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_Has3DNow"]
-    #[doc = " \\sa SDL_HasAltiVec"]
-    #[doc = " \\sa SDL_HasAVX"]
-    #[doc = " \\sa SDL_HasAVX2"]
-    #[doc = " \\sa SDL_HasMMX"]
-    #[doc = " \\sa SDL_HasRDTSC"]
-    #[doc = " \\sa SDL_HasSSE"]
-    #[doc = " \\sa SDL_HasSSE2"]
-    #[doc = " \\sa SDL_HasSSE3"]
-    #[doc = " \\sa SDL_HasSSE41"]
+    #[doc = " Determine whether the CPU has SSE4.2 features.\n\n This always returns false on CPUs that aren't using Intel instruction sets.\n\n \\returns SDL_TRUE if the CPU has SSE4.2 features or SDL_FALSE if not.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_Has3DNow\n \\sa SDL_HasAltiVec\n \\sa SDL_HasAVX\n \\sa SDL_HasAVX2\n \\sa SDL_HasMMX\n \\sa SDL_HasRDTSC\n \\sa SDL_HasSSE\n \\sa SDL_HasSSE2\n \\sa SDL_HasSSE3\n \\sa SDL_HasSSE41"]
     pub fn SDL_HasSSE42() -> SDL_bool;
 }
 extern "C" {
-    #[doc = " Determine whether the CPU has AVX features."]
-    #[doc = ""]
-    #[doc = " This always returns false on CPUs that aren't using Intel instruction sets."]
-    #[doc = ""]
-    #[doc = " \\returns SDL_TRUE if the CPU has AVX features or SDL_FALSE if not."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.2."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_Has3DNow"]
-    #[doc = " \\sa SDL_HasAltiVec"]
-    #[doc = " \\sa SDL_HasAVX2"]
-    #[doc = " \\sa SDL_HasMMX"]
-    #[doc = " \\sa SDL_HasRDTSC"]
-    #[doc = " \\sa SDL_HasSSE"]
-    #[doc = " \\sa SDL_HasSSE2"]
-    #[doc = " \\sa SDL_HasSSE3"]
-    #[doc = " \\sa SDL_HasSSE41"]
-    #[doc = " \\sa SDL_HasSSE42"]
+    #[doc = " Determine whether the CPU has AVX features.\n\n This always returns false on CPUs that aren't using Intel instruction sets.\n\n \\returns SDL_TRUE if the CPU has AVX features or SDL_FALSE if not.\n\n \\since This function is available since SDL 2.0.2.\n\n \\sa SDL_Has3DNow\n \\sa SDL_HasAltiVec\n \\sa SDL_HasAVX2\n \\sa SDL_HasMMX\n \\sa SDL_HasRDTSC\n \\sa SDL_HasSSE\n \\sa SDL_HasSSE2\n \\sa SDL_HasSSE3\n \\sa SDL_HasSSE41\n \\sa SDL_HasSSE42"]
     pub fn SDL_HasAVX() -> SDL_bool;
 }
 extern "C" {
-    #[doc = " Determine whether the CPU has AVX2 features."]
-    #[doc = ""]
-    #[doc = " This always returns false on CPUs that aren't using Intel instruction sets."]
-    #[doc = ""]
-    #[doc = " \\returns SDL_TRUE if the CPU has AVX2 features or SDL_FALSE if not."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.4."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_Has3DNow"]
-    #[doc = " \\sa SDL_HasAltiVec"]
-    #[doc = " \\sa SDL_HasAVX"]
-    #[doc = " \\sa SDL_HasMMX"]
-    #[doc = " \\sa SDL_HasRDTSC"]
-    #[doc = " \\sa SDL_HasSSE"]
-    #[doc = " \\sa SDL_HasSSE2"]
-    #[doc = " \\sa SDL_HasSSE3"]
-    #[doc = " \\sa SDL_HasSSE41"]
-    #[doc = " \\sa SDL_HasSSE42"]
+    #[doc = " Determine whether the CPU has AVX2 features.\n\n This always returns false on CPUs that aren't using Intel instruction sets.\n\n \\returns SDL_TRUE if the CPU has AVX2 features or SDL_FALSE if not.\n\n \\since This function is available since SDL 2.0.4.\n\n \\sa SDL_Has3DNow\n \\sa SDL_HasAltiVec\n \\sa SDL_HasAVX\n \\sa SDL_HasMMX\n \\sa SDL_HasRDTSC\n \\sa SDL_HasSSE\n \\sa SDL_HasSSE2\n \\sa SDL_HasSSE3\n \\sa SDL_HasSSE41\n \\sa SDL_HasSSE42"]
     pub fn SDL_HasAVX2() -> SDL_bool;
 }
 extern "C" {
-    #[doc = " Determine whether the CPU has AVX-512F (foundation) features."]
-    #[doc = ""]
-    #[doc = " This always returns false on CPUs that aren't using Intel instruction sets."]
-    #[doc = ""]
-    #[doc = " \\returns SDL_TRUE if the CPU has AVX-512F features or SDL_FALSE if not."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.9."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_HasAVX"]
+    #[doc = " Determine whether the CPU has AVX-512F (foundation) features.\n\n This always returns false on CPUs that aren't using Intel instruction sets.\n\n \\returns SDL_TRUE if the CPU has AVX-512F features or SDL_FALSE if not.\n\n \\since This function is available since SDL 2.0.9.\n\n \\sa SDL_HasAVX"]
     pub fn SDL_HasAVX512F() -> SDL_bool;
 }
 extern "C" {
-    #[doc = " Determine whether the CPU has ARM SIMD (ARMv6) features."]
-    #[doc = ""]
-    #[doc = " This is different from ARM NEON, which is a different instruction set."]
-    #[doc = ""]
-    #[doc = " This always returns false on CPUs that aren't using ARM instruction sets."]
-    #[doc = ""]
-    #[doc = " \\returns SDL_TRUE if the CPU has ARM SIMD features or SDL_FALSE if not."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.12."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_HasNEON"]
+    #[doc = " Determine whether the CPU has ARM SIMD (ARMv6) features.\n\n This is different from ARM NEON, which is a different instruction set.\n\n This always returns false on CPUs that aren't using ARM instruction sets.\n\n \\returns SDL_TRUE if the CPU has ARM SIMD features or SDL_FALSE if not.\n\n \\since This function is available since SDL 2.0.12.\n\n \\sa SDL_HasNEON"]
     pub fn SDL_HasARMSIMD() -> SDL_bool;
 }
 extern "C" {
-    #[doc = " Determine whether the CPU has NEON (ARM SIMD) features."]
-    #[doc = ""]
-    #[doc = " This always returns false on CPUs that aren't using ARM instruction sets."]
-    #[doc = ""]
-    #[doc = " \\returns SDL_TRUE if the CPU has ARM NEON features or SDL_FALSE if not."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.6."]
+    #[doc = " Determine whether the CPU has NEON (ARM SIMD) features.\n\n This always returns false on CPUs that aren't using ARM instruction sets.\n\n \\returns SDL_TRUE if the CPU has ARM NEON features or SDL_FALSE if not.\n\n \\since This function is available since SDL 2.0.6."]
     pub fn SDL_HasNEON() -> SDL_bool;
 }
 extern "C" {
-    #[doc = " Get the amount of RAM configured in the system."]
-    #[doc = ""]
-    #[doc = " \\returns the amount of RAM configured in the system in MB."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.1."]
+    #[doc = " Determine whether the CPU has LSX (LOONGARCH SIMD) features.\n\n This always returns false on CPUs that aren't using LOONGARCH instruction\n sets.\n\n \\returns SDL_TRUE if the CPU has LOONGARCH LSX features or SDL_FALSE if\n          not.\n\n \\since This function is available since SDL 2.24.0."]
+    pub fn SDL_HasLSX() -> SDL_bool;
+}
+extern "C" {
+    #[doc = " Determine whether the CPU has LASX (LOONGARCH SIMD) features.\n\n This always returns false on CPUs that aren't using LOONGARCH instruction\n sets.\n\n \\returns SDL_TRUE if the CPU has LOONGARCH LASX features or SDL_FALSE if\n          not.\n\n \\since This function is available since SDL 2.24.0."]
+    pub fn SDL_HasLASX() -> SDL_bool;
+}
+extern "C" {
+    #[doc = " Get the amount of RAM configured in the system.\n\n \\returns the amount of RAM configured in the system in MiB.\n\n \\since This function is available since SDL 2.0.1."]
     pub fn SDL_GetSystemRAM() -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Report the alignment this system needs for SIMD allocations."]
-    #[doc = ""]
-    #[doc = " This will return the minimum number of bytes to which a pointer must be"]
-    #[doc = " aligned to be compatible with SIMD instructions on the current machine. For"]
-    #[doc = " example, if the machine supports SSE only, it will return 16, but if it"]
-    #[doc = " supports AVX-512F, it'll return 64 (etc). This only reports values for"]
-    #[doc = " instruction sets SDL knows about, so if your SDL build doesn't have"]
-    #[doc = " SDL_HasAVX512F(), then it might return 16 for the SSE support it sees and"]
-    #[doc = " not 64 for the AVX-512 instructions that exist but SDL doesn't know about."]
-    #[doc = " Plan accordingly."]
-    #[doc = ""]
-    #[doc = " \\returns the alignment in bytes needed for available, known SIMD"]
-    #[doc = "          instructions."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.10."]
-    pub fn SDL_SIMDGetAlignment() -> size_t;
-}
-extern "C" {
-    #[doc = " Allocate memory in a SIMD-friendly way."]
-    #[doc = ""]
-    #[doc = " This will allocate a block of memory that is suitable for use with SIMD"]
-    #[doc = " instructions. Specifically, it will be properly aligned and padded for the"]
-    #[doc = " system's supported vector instructions."]
-    #[doc = ""]
-    #[doc = " The memory returned will be padded such that it is safe to read or write an"]
-    #[doc = " incomplete vector at the end of the memory block. This can be useful so you"]
-    #[doc = " don't have to drop back to a scalar fallback at the end of your SIMD"]
-    #[doc = " processing loop to deal with the final elements without overflowing the"]
-    #[doc = " allocated buffer."]
-    #[doc = ""]
-    #[doc = " You must free this memory with SDL_FreeSIMD(), not free() or SDL_free() or"]
-    #[doc = " delete[], etc."]
-    #[doc = ""]
-    #[doc = " Note that SDL will only deal with SIMD instruction sets it is aware of; for"]
-    #[doc = " example, SDL 2.0.8 knows that SSE wants 16-byte vectors (SDL_HasSSE()), and"]
-    #[doc = " AVX2 wants 32 bytes (SDL_HasAVX2()), but doesn't know that AVX-512 wants"]
-    #[doc = " 64. To be clear: if you can't decide to use an instruction set with an"]
-    #[doc = " SDL_Has*() function, don't use that instruction set with memory allocated"]
-    #[doc = " through here."]
-    #[doc = ""]
-    #[doc = " SDL_AllocSIMD(0) will return a non-NULL pointer, assuming the system isn't"]
-    #[doc = " out of memory, but you are not allowed to dereference it (because you only"]
-    #[doc = " own zero bytes of that buffer)."]
-    #[doc = ""]
-    #[doc = " \\param len The length, in bytes, of the block to allocate. The actual"]
-    #[doc = "            allocated block might be larger due to padding, etc."]
-    #[doc = " \\returns a pointer to the newly-allocated block, NULL if out of memory."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.10."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_SIMDAlignment"]
-    #[doc = " \\sa SDL_SIMDRealloc"]
-    #[doc = " \\sa SDL_SIMDFree"]
-    pub fn SDL_SIMDAlloc(len: size_t) -> *mut libc::c_void;
-}
-extern "C" {
-    #[doc = " Reallocate memory obtained from SDL_SIMDAlloc"]
-    #[doc = ""]
-    #[doc = " It is not valid to use this function on a pointer from anything but"]
-    #[doc = " SDL_SIMDAlloc(). It can't be used on pointers from malloc, realloc,"]
-    #[doc = " SDL_malloc, memalign, new[], etc."]
-    #[doc = ""]
-    #[doc = " \\param mem The pointer obtained from SDL_SIMDAlloc. This function also"]
-    #[doc = "            accepts NULL, at which point this function is the same as"]
-    #[doc = "            calling SDL_SIMDAlloc with a NULL pointer."]
-    #[doc = " \\param len The length, in bytes, of the block to allocated. The actual"]
-    #[doc = "            allocated block might be larger due to padding, etc. Passing 0"]
-    #[doc = "            will return a non-NULL pointer, assuming the system isn't out of"]
-    #[doc = "            memory."]
-    #[doc = " \\returns a pointer to the newly-reallocated block, NULL if out of memory."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.14."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_SIMDAlignment"]
-    #[doc = " \\sa SDL_SIMDAlloc"]
-    #[doc = " \\sa SDL_SIMDFree"]
-    pub fn SDL_SIMDRealloc(mem: *mut libc::c_void, len: size_t) -> *mut libc::c_void;
-}
-extern "C" {
-    #[doc = " Deallocate memory obtained from SDL_SIMDAlloc"]
-    #[doc = ""]
-    #[doc = " It is not valid to use this function on a pointer from anything but"]
-    #[doc = " SDL_SIMDAlloc() or SDL_SIMDRealloc(). It can't be used on pointers from"]
-    #[doc = " malloc, realloc, SDL_malloc, memalign, new[], etc."]
-    #[doc = ""]
-    #[doc = " However, SDL_SIMDFree(NULL) is a legal no-op."]
-    #[doc = ""]
-    #[doc = " The memory pointed to by `ptr` is no longer valid for access upon return,"]
-    #[doc = " and may be returned to the system or reused by a future allocation. The"]
-    #[doc = " pointer passed to this function is no longer safe to dereference once this"]
-    #[doc = " function returns, and should be discarded."]
-    #[doc = ""]
-    #[doc = " \\param ptr The pointer, returned from SDL_SIMDAlloc or SDL_SIMDRealloc, to"]
-    #[doc = "            deallocate. NULL is a legal no-op."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.10."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_SIMDAlloc"]
-    #[doc = " \\sa SDL_SIMDRealloc"]
+    #[doc = " Report the alignment this system needs for SIMD allocations.\n\n This will return the minimum number of bytes to which a pointer must be\n aligned to be compatible with SIMD instructions on the current machine. For\n example, if the machine supports SSE only, it will return 16, but if it\n supports AVX-512F, it'll return 64 (etc). This only reports values for\n instruction sets SDL knows about, so if your SDL build doesn't have\n SDL_HasAVX512F(), then it might return 16 for the SSE support it sees and\n not 64 for the AVX-512 instructions that exist but SDL doesn't know about.\n Plan accordingly.\n\n \\returns the alignment in bytes needed for available, known SIMD\n          instructions.\n\n \\since This function is available since SDL 2.0.10."]
+    pub fn SDL_SIMDGetAlignment() -> usize;
+}
+extern "C" {
+    #[doc = " Allocate memory in a SIMD-friendly way.\n\n This will allocate a block of memory that is suitable for use with SIMD\n instructions. Specifically, it will be properly aligned and padded for the\n system's supported vector instructions.\n\n The memory returned will be padded such that it is safe to read or write an\n incomplete vector at the end of the memory block. This can be useful so you\n don't have to drop back to a scalar fallback at the end of your SIMD\n processing loop to deal with the final elements without overflowing the\n allocated buffer.\n\n You must free this memory with SDL_FreeSIMD(), not free() or SDL_free() or\n delete[], etc.\n\n Note that SDL will only deal with SIMD instruction sets it is aware of; for\n example, SDL 2.0.8 knows that SSE wants 16-byte vectors (SDL_HasSSE()), and\n AVX2 wants 32 bytes (SDL_HasAVX2()), but doesn't know that AVX-512 wants\n 64. To be clear: if you can't decide to use an instruction set with an\n SDL_Has*() function, don't use that instruction set with memory allocated\n through here.\n\n SDL_AllocSIMD(0) will return a non-NULL pointer, assuming the system isn't\n out of memory, but you are not allowed to dereference it (because you only\n own zero bytes of that buffer).\n\n \\param len The length, in bytes, of the block to allocate. The actual\n            allocated block might be larger due to padding, etc.\n \\returns a pointer to the newly-allocated block, NULL if out of memory.\n\n \\since This function is available since SDL 2.0.10.\n\n \\sa SDL_SIMDGetAlignment\n \\sa SDL_SIMDRealloc\n \\sa SDL_SIMDFree"]
+    pub fn SDL_SIMDAlloc(len: usize) -> *mut libc::c_void;
+}
+extern "C" {
+    #[doc = " Reallocate memory obtained from SDL_SIMDAlloc\n\n It is not valid to use this function on a pointer from anything but\n SDL_SIMDAlloc(). It can't be used on pointers from malloc, realloc,\n SDL_malloc, memalign, new[], etc.\n\n \\param mem The pointer obtained from SDL_SIMDAlloc. This function also\n            accepts NULL, at which point this function is the same as\n            calling SDL_SIMDAlloc with a NULL pointer.\n \\param len The length, in bytes, of the block to allocated. The actual\n            allocated block might be larger due to padding, etc. Passing 0\n            will return a non-NULL pointer, assuming the system isn't out of\n            memory.\n \\returns a pointer to the newly-reallocated block, NULL if out of memory.\n\n \\since This function is available since SDL 2.0.14.\n\n \\sa SDL_SIMDGetAlignment\n \\sa SDL_SIMDAlloc\n \\sa SDL_SIMDFree"]
+    pub fn SDL_SIMDRealloc(mem: *mut libc::c_void, len: usize) -> *mut libc::c_void;
+}
+extern "C" {
+    #[doc = " Deallocate memory obtained from SDL_SIMDAlloc\n\n It is not valid to use this function on a pointer from anything but\n SDL_SIMDAlloc() or SDL_SIMDRealloc(). It can't be used on pointers from\n malloc, realloc, SDL_malloc, memalign, new[], etc.\n\n However, SDL_SIMDFree(NULL) is a legal no-op.\n\n The memory pointed to by `ptr` is no longer valid for access upon return,\n and may be returned to the system or reused by a future allocation. The\n pointer passed to this function is no longer safe to dereference once this\n function returns, and should be discarded.\n\n \\param ptr The pointer, returned from SDL_SIMDAlloc or SDL_SIMDRealloc, to\n            deallocate. NULL is a legal no-op.\n\n \\since This function is available since SDL 2.0.10.\n\n \\sa SDL_SIMDAlloc\n \\sa SDL_SIMDRealloc"]
     pub fn SDL_SIMDFree(ptr: *mut libc::c_void);
 }
 #[repr(u32)]
 #[doc = " Pixel type."]
-#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
+#[derive(Copy, Clone, Hash, PartialEq, Eq)]
 pub enum SDL_PixelType {
     SDL_PIXELTYPE_UNKNOWN = 0,
     SDL_PIXELTYPE_INDEX1 = 1,
@@ -7746,7 +5158,7 @@ pub enum SDL_PixelType {
 }
 #[repr(u32)]
 #[doc = " Bitmap pixel order, high bit -> low bit."]
-#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
+#[derive(Copy, Clone, Hash, PartialEq, Eq)]
 pub enum SDL_BitmapOrder {
     SDL_BITMAPORDER_NONE = 0,
     SDL_BITMAPORDER_4321 = 1,
@@ -7754,7 +5166,7 @@ pub enum SDL_BitmapOrder {
 }
 #[repr(u32)]
 #[doc = " Packed component order, high bit -> low bit."]
-#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
+#[derive(Copy, Clone, Hash, PartialEq, Eq)]
 pub enum SDL_PackedOrder {
     SDL_PACKEDORDER_NONE = 0,
     SDL_PACKEDORDER_XRGB = 1,
@@ -7768,7 +5180,7 @@ pub enum SDL_PackedOrder {
 }
 #[repr(u32)]
 #[doc = " Array component order, low byte -> high byte."]
-#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
+#[derive(Copy, Clone, Hash, PartialEq, Eq)]
 pub enum SDL_ArrayOrder {
     SDL_ARRAYORDER_NONE = 0,
     SDL_ARRAYORDER_RGB = 1,
@@ -7780,7 +5192,7 @@ pub enum SDL_ArrayOrder {
 }
 #[repr(u32)]
 #[doc = " Packed component layout."]
-#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
+#[derive(Copy, Clone, Hash, PartialEq, Eq)]
 pub enum SDL_PackedLayout {
     SDL_PACKEDLAYOUT_NONE = 0,
     SDL_PACKEDLAYOUT_332 = 1,
@@ -7833,7 +5245,7 @@ impl SDL_PixelFormatEnum {
         SDL_PixelFormatEnum::SDL_PIXELFORMAT_RGBA8888;
 }
 #[repr(u32)]
-#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
+#[derive(Copy, Clone, Hash, PartialEq, Eq)]
 pub enum SDL_PixelFormatEnum {
     SDL_PIXELFORMAT_UNKNOWN = 0,
     SDL_PIXELFORMAT_INDEX1LSB = 286261504,
@@ -7884,9 +5296,7 @@ pub enum SDL_PixelFormatEnum {
     #[doc = "< Android video texture format"]
     SDL_PIXELFORMAT_EXTERNAL_OES = 542328143,
 }
-#[doc = " The bits of this structure can be directly reinterpreted as an integer-packed"]
-#[doc = " color which uses the SDL_PIXELFORMAT_RGBA32 format (SDL_PIXELFORMAT_ABGR8888"]
-#[doc = " on little-endian systems and SDL_PIXELFORMAT_RGBA8888 on big-endian systems)."]
+#[doc = " The bits of this structure can be directly reinterpreted as an integer-packed\n color which uses the SDL_PIXELFORMAT_RGBA32 format (SDL_PIXELFORMAT_ABGR8888\n on little-endian systems and SDL_PIXELFORMAT_RGBA8888 on big-endian systems)."]
 #[repr(C)]
 #[derive(Copy, Clone)]
 pub struct SDL_Color {
@@ -7897,6 +5307,8 @@ pub struct SDL_Color {
 }
 #[test]
 fn bindgen_test_layout_SDL_Color() {
+    const UNINIT: ::core::mem::MaybeUninit<SDL_Color> = ::core::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::core::mem::size_of::<SDL_Color>(),
         4usize,
@@ -7908,7 +5320,7 @@ fn bindgen_test_layout_SDL_Color() {
         concat!("Alignment of ", stringify!(SDL_Color))
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_Color>())).r as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).r) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -7918,7 +5330,7 @@ fn bindgen_test_layout_SDL_Color() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_Color>())).g as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).g) as usize - ptr as usize },
         1usize,
         concat!(
             "Offset of field: ",
@@ -7928,7 +5340,7 @@ fn bindgen_test_layout_SDL_Color() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_Color>())).b as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).b) as usize - ptr as usize },
         2usize,
         concat!(
             "Offset of field: ",
@@ -7938,7 +5350,7 @@ fn bindgen_test_layout_SDL_Color() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_Color>())).a as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).a) as usize - ptr as usize },
         3usize,
         concat!(
             "Offset of field: ",
@@ -7958,6 +5370,8 @@ pub struct SDL_Palette {
 }
 #[test]
 fn bindgen_test_layout_SDL_Palette() {
+    const UNINIT: ::core::mem::MaybeUninit<SDL_Palette> = ::core::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::core::mem::size_of::<SDL_Palette>(),
         24usize,
@@ -7969,7 +5383,7 @@ fn bindgen_test_layout_SDL_Palette() {
         concat!("Alignment of ", stringify!(SDL_Palette))
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_Palette>())).ncolors as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).ncolors) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -7979,7 +5393,7 @@ fn bindgen_test_layout_SDL_Palette() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_Palette>())).colors as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).colors) as usize - ptr as usize },
         8usize,
         concat!(
             "Offset of field: ",
@@ -7989,7 +5403,7 @@ fn bindgen_test_layout_SDL_Palette() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_Palette>())).version as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).version) as usize - ptr as usize },
         16usize,
         concat!(
             "Offset of field: ",
@@ -7999,7 +5413,7 @@ fn bindgen_test_layout_SDL_Palette() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_Palette>())).refcount as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).refcount) as usize - ptr as usize },
         20usize,
         concat!(
             "Offset of field: ",
@@ -8035,6 +5449,8 @@ pub struct SDL_PixelFormat {
 }
 #[test]
 fn bindgen_test_layout_SDL_PixelFormat() {
+    const UNINIT: ::core::mem::MaybeUninit<SDL_PixelFormat> = ::core::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::core::mem::size_of::<SDL_PixelFormat>(),
         56usize,
@@ -8046,7 +5462,7 @@ fn bindgen_test_layout_SDL_PixelFormat() {
         concat!("Alignment of ", stringify!(SDL_PixelFormat))
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_PixelFormat>())).format as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).format) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -8056,7 +5472,7 @@ fn bindgen_test_layout_SDL_PixelFormat() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_PixelFormat>())).palette as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).palette) as usize - ptr as usize },
         8usize,
         concat!(
             "Offset of field: ",
@@ -8066,7 +5482,7 @@ fn bindgen_test_layout_SDL_PixelFormat() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_PixelFormat>())).BitsPerPixel as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).BitsPerPixel) as usize - ptr as usize },
         16usize,
         concat!(
             "Offset of field: ",
@@ -8076,7 +5492,7 @@ fn bindgen_test_layout_SDL_PixelFormat() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_PixelFormat>())).BytesPerPixel as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).BytesPerPixel) as usize - ptr as usize },
         17usize,
         concat!(
             "Offset of field: ",
@@ -8086,7 +5502,7 @@ fn bindgen_test_layout_SDL_PixelFormat() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_PixelFormat>())).padding as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).padding) as usize - ptr as usize },
         18usize,
         concat!(
             "Offset of field: ",
@@ -8096,7 +5512,7 @@ fn bindgen_test_layout_SDL_PixelFormat() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_PixelFormat>())).Rmask as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).Rmask) as usize - ptr as usize },
         20usize,
         concat!(
             "Offset of field: ",
@@ -8106,7 +5522,7 @@ fn bindgen_test_layout_SDL_PixelFormat() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_PixelFormat>())).Gmask as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).Gmask) as usize - ptr as usize },
         24usize,
         concat!(
             "Offset of field: ",
@@ -8116,7 +5532,7 @@ fn bindgen_test_layout_SDL_PixelFormat() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_PixelFormat>())).Bmask as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).Bmask) as usize - ptr as usize },
         28usize,
         concat!(
             "Offset of field: ",
@@ -8126,7 +5542,7 @@ fn bindgen_test_layout_SDL_PixelFormat() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_PixelFormat>())).Amask as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).Amask) as usize - ptr as usize },
         32usize,
         concat!(
             "Offset of field: ",
@@ -8136,7 +5552,7 @@ fn bindgen_test_layout_SDL_PixelFormat() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_PixelFormat>())).Rloss as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).Rloss) as usize - ptr as usize },
         36usize,
         concat!(
             "Offset of field: ",
@@ -8146,7 +5562,7 @@ fn bindgen_test_layout_SDL_PixelFormat() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_PixelFormat>())).Gloss as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).Gloss) as usize - ptr as usize },
         37usize,
         concat!(
             "Offset of field: ",
@@ -8156,7 +5572,7 @@ fn bindgen_test_layout_SDL_PixelFormat() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_PixelFormat>())).Bloss as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).Bloss) as usize - ptr as usize },
         38usize,
         concat!(
             "Offset of field: ",
@@ -8166,7 +5582,7 @@ fn bindgen_test_layout_SDL_PixelFormat() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_PixelFormat>())).Aloss as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).Aloss) as usize - ptr as usize },
         39usize,
         concat!(
             "Offset of field: ",
@@ -8176,7 +5592,7 @@ fn bindgen_test_layout_SDL_PixelFormat() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_PixelFormat>())).Rshift as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).Rshift) as usize - ptr as usize },
         40usize,
         concat!(
             "Offset of field: ",
@@ -8186,7 +5602,7 @@ fn bindgen_test_layout_SDL_PixelFormat() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_PixelFormat>())).Gshift as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).Gshift) as usize - ptr as usize },
         41usize,
         concat!(
             "Offset of field: ",
@@ -8196,7 +5612,7 @@ fn bindgen_test_layout_SDL_PixelFormat() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_PixelFormat>())).Bshift as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).Bshift) as usize - ptr as usize },
         42usize,
         concat!(
             "Offset of field: ",
@@ -8206,7 +5622,7 @@ fn bindgen_test_layout_SDL_PixelFormat() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_PixelFormat>())).Ashift as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).Ashift) as usize - ptr as usize },
         43usize,
         concat!(
             "Offset of field: ",
@@ -8216,7 +5632,7 @@ fn bindgen_test_layout_SDL_PixelFormat() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_PixelFormat>())).refcount as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).refcount) as usize - ptr as usize },
         44usize,
         concat!(
             "Offset of field: ",
@@ -8226,7 +5642,7 @@ fn bindgen_test_layout_SDL_PixelFormat() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_PixelFormat>())).next as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).next) as usize - ptr as usize },
         48usize,
         concat!(
             "Offset of field: ",
@@ -8237,30 +5653,11 @@ fn bindgen_test_layout_SDL_PixelFormat() {
     );
 }
 extern "C" {
-    #[doc = " Get the human readable name of a pixel format."]
-    #[doc = ""]
-    #[doc = " \\param format the pixel format to query"]
-    #[doc = " \\returns the human readable name of the specified pixel format or"]
-    #[doc = "          `SDL_PIXELFORMAT_UNKNOWN` if the format isn't recognized."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
+    #[doc = " Get the human readable name of a pixel format.\n\n \\param format the pixel format to query\n \\returns the human readable name of the specified pixel format or\n          `SDL_PIXELFORMAT_UNKNOWN` if the format isn't recognized.\n\n \\since This function is available since SDL 2.0.0."]
     pub fn SDL_GetPixelFormatName(format: Uint32) -> *const libc::c_char;
 }
 extern "C" {
-    #[doc = " Convert one of the enumerated pixel formats to a bpp value and RGBA masks."]
-    #[doc = ""]
-    #[doc = " \\param format one of the SDL_PixelFormatEnum values"]
-    #[doc = " \\param bpp a bits per pixel value; usually 15, 16, or 32"]
-    #[doc = " \\param Rmask a pointer filled in with the red mask for the format"]
-    #[doc = " \\param Gmask a pointer filled in with the green mask for the format"]
-    #[doc = " \\param Bmask a pointer filled in with the blue mask for the format"]
-    #[doc = " \\param Amask a pointer filled in with the alpha mask for the format"]
-    #[doc = " \\returns SDL_TRUE on success or SDL_FALSE if the conversion wasn't"]
-    #[doc = "          possible; call SDL_GetError() for more information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_MasksToPixelFormatEnum"]
+    #[doc = " Convert one of the enumerated pixel formats to a bpp value and RGBA masks.\n\n \\param format one of the SDL_PixelFormatEnum values\n \\param bpp a bits per pixel value; usually 15, 16, or 32\n \\param Rmask a pointer filled in with the red mask for the format\n \\param Gmask a pointer filled in with the green mask for the format\n \\param Bmask a pointer filled in with the blue mask for the format\n \\param Amask a pointer filled in with the alpha mask for the format\n \\returns SDL_TRUE on success or SDL_FALSE if the conversion wasn't\n          possible; call SDL_GetError() for more information.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_MasksToPixelFormatEnum"]
     pub fn SDL_PixelFormatEnumToMasks(
         format: Uint32,
         bpp: *mut libc::c_int,
@@ -8271,21 +5668,7 @@ extern "C" {
     ) -> SDL_bool;
 }
 extern "C" {
-    #[doc = " Convert a bpp value and RGBA masks to an enumerated pixel format."]
-    #[doc = ""]
-    #[doc = " This will return `SDL_PIXELFORMAT_UNKNOWN` if the conversion wasn't"]
-    #[doc = " possible."]
-    #[doc = ""]
-    #[doc = " \\param bpp a bits per pixel value; usually 15, 16, or 32"]
-    #[doc = " \\param Rmask the red mask for the format"]
-    #[doc = " \\param Gmask the green mask for the format"]
-    #[doc = " \\param Bmask the blue mask for the format"]
-    #[doc = " \\param Amask the alpha mask for the format"]
-    #[doc = " \\returns one of the SDL_PixelFormatEnum values"]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_PixelFormatEnumToMasks"]
+    #[doc = " Convert a bpp value and RGBA masks to an enumerated pixel format.\n\n This will return `SDL_PIXELFORMAT_UNKNOWN` if the conversion wasn't\n possible.\n\n \\param bpp a bits per pixel value; usually 15, 16, or 32\n \\param Rmask the red mask for the format\n \\param Gmask the green mask for the format\n \\param Bmask the blue mask for the format\n \\param Amask the alpha mask for the format\n \\returns one of the SDL_PixelFormatEnum values\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_PixelFormatEnumToMasks"]
     pub fn SDL_MasksToPixelFormatEnum(
         bpp: libc::c_int,
         Rmask: Uint32,
@@ -8295,77 +5678,26 @@ extern "C" {
     ) -> Uint32;
 }
 extern "C" {
-    #[doc = " Create an SDL_PixelFormat structure corresponding to a pixel format."]
-    #[doc = ""]
-    #[doc = " Returned structure may come from a shared global cache (i.e. not newly"]
-    #[doc = " allocated), and hence should not be modified, especially the palette. Weird"]
-    #[doc = " errors such as `Blit combination not supported` may occur."]
-    #[doc = ""]
-    #[doc = " \\param pixel_format one of the SDL_PixelFormatEnum values"]
-    #[doc = " \\returns the new SDL_PixelFormat structure or NULL on failure; call"]
-    #[doc = "          SDL_GetError() for more information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_FreeFormat"]
+    #[doc = " Create an SDL_PixelFormat structure corresponding to a pixel format.\n\n Returned structure may come from a shared global cache (i.e. not newly\n allocated), and hence should not be modified, especially the palette. Weird\n errors such as `Blit combination not supported` may occur.\n\n \\param pixel_format one of the SDL_PixelFormatEnum values\n \\returns the new SDL_PixelFormat structure or NULL on failure; call\n          SDL_GetError() for more information.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_FreeFormat"]
     pub fn SDL_AllocFormat(pixel_format: Uint32) -> *mut SDL_PixelFormat;
 }
 extern "C" {
-    #[doc = " Free an SDL_PixelFormat structure allocated by SDL_AllocFormat()."]
-    #[doc = ""]
-    #[doc = " \\param format the SDL_PixelFormat structure to free"]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_AllocFormat"]
+    #[doc = " Free an SDL_PixelFormat structure allocated by SDL_AllocFormat().\n\n \\param format the SDL_PixelFormat structure to free\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_AllocFormat"]
     pub fn SDL_FreeFormat(format: *mut SDL_PixelFormat);
 }
 extern "C" {
-    #[doc = " Create a palette structure with the specified number of color entries."]
-    #[doc = ""]
-    #[doc = " The palette entries are initialized to white."]
-    #[doc = ""]
-    #[doc = " \\param ncolors represents the number of color entries in the color palette"]
-    #[doc = " \\returns a new SDL_Palette structure on success or NULL on failure (e.g. if"]
-    #[doc = "          there wasn't enough memory); call SDL_GetError() for more"]
-    #[doc = "          information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_FreePalette"]
+    #[doc = " Create a palette structure with the specified number of color entries.\n\n The palette entries are initialized to white.\n\n \\param ncolors represents the number of color entries in the color palette\n \\returns a new SDL_Palette structure on success or NULL on failure (e.g. if\n          there wasn't enough memory); call SDL_GetError() for more\n          information.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_FreePalette"]
     pub fn SDL_AllocPalette(ncolors: libc::c_int) -> *mut SDL_Palette;
 }
 extern "C" {
-    #[doc = " Set the palette for a pixel format structure."]
-    #[doc = ""]
-    #[doc = " \\param format the SDL_PixelFormat structure that will use the palette"]
-    #[doc = " \\param palette the SDL_Palette structure that will be used"]
-    #[doc = " \\returns 0 on success or a negative error code on failure; call"]
-    #[doc = "          SDL_GetError() for more information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_AllocPalette"]
-    #[doc = " \\sa SDL_FreePalette"]
+    #[doc = " Set the palette for a pixel format structure.\n\n \\param format the SDL_PixelFormat structure that will use the palette\n \\param palette the SDL_Palette structure that will be used\n \\returns 0 on success or a negative error code on failure; call\n          SDL_GetError() for more information.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_AllocPalette\n \\sa SDL_FreePalette"]
     pub fn SDL_SetPixelFormatPalette(
         format: *mut SDL_PixelFormat,
         palette: *mut SDL_Palette,
     ) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Set a range of colors in a palette."]
-    #[doc = ""]
-    #[doc = " \\param palette the SDL_Palette structure to modify"]
-    #[doc = " \\param colors an array of SDL_Color structures to copy into the palette"]
-    #[doc = " \\param firstcolor the index of the first palette entry to modify"]
-    #[doc = " \\param ncolors the number of entries to modify"]
-    #[doc = " \\returns 0 on success or a negative error code if not all of the colors"]
-    #[doc = "          could be set; call SDL_GetError() for more information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_AllocPalette"]
-    #[doc = " \\sa SDL_CreateRGBSurface"]
+    #[doc = " Set a range of colors in a palette.\n\n \\param palette the SDL_Palette structure to modify\n \\param colors an array of SDL_Color structures to copy into the palette\n \\param firstcolor the index of the first palette entry to modify\n \\param ncolors the number of entries to modify\n \\returns 0 on success or a negative error code if not all of the colors\n          could be set; call SDL_GetError() for more information.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_AllocPalette\n \\sa SDL_CreateRGBSurface"]
     pub fn SDL_SetPaletteColors(
         palette: *mut SDL_Palette,
         colors: *const SDL_Color,
@@ -8374,77 +5706,15 @@ extern "C" {
     ) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Free a palette created with SDL_AllocPalette()."]
-    #[doc = ""]
-    #[doc = " \\param palette the SDL_Palette structure to be freed"]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_AllocPalette"]
+    #[doc = " Free a palette created with SDL_AllocPalette().\n\n \\param palette the SDL_Palette structure to be freed\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_AllocPalette"]
     pub fn SDL_FreePalette(palette: *mut SDL_Palette);
 }
 extern "C" {
-    #[doc = " Map an RGB triple to an opaque pixel value for a given pixel format."]
-    #[doc = ""]
-    #[doc = " This function maps the RGB color value to the specified pixel format and"]
-    #[doc = " returns the pixel value best approximating the given RGB color value for"]
-    #[doc = " the given pixel format."]
-    #[doc = ""]
-    #[doc = " If the format has a palette (8-bit) the index of the closest matching color"]
-    #[doc = " in the palette will be returned."]
-    #[doc = ""]
-    #[doc = " If the specified pixel format has an alpha component it will be returned as"]
-    #[doc = " all 1 bits (fully opaque)."]
-    #[doc = ""]
-    #[doc = " If the pixel format bpp (color depth) is less than 32-bpp then the unused"]
-    #[doc = " upper bits of the return value can safely be ignored (e.g., with a 16-bpp"]
-    #[doc = " format the return value can be assigned to a Uint16, and similarly a Uint8"]
-    #[doc = " for an 8-bpp format)."]
-    #[doc = ""]
-    #[doc = " \\param format an SDL_PixelFormat structure describing the pixel format"]
-    #[doc = " \\param r the red component of the pixel in the range 0-255"]
-    #[doc = " \\param g the green component of the pixel in the range 0-255"]
-    #[doc = " \\param b the blue component of the pixel in the range 0-255"]
-    #[doc = " \\returns a pixel value"]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_GetRGB"]
-    #[doc = " \\sa SDL_GetRGBA"]
-    #[doc = " \\sa SDL_MapRGBA"]
+    #[doc = " Map an RGB triple to an opaque pixel value for a given pixel format.\n\n This function maps the RGB color value to the specified pixel format and\n returns the pixel value best approximating the given RGB color value for\n the given pixel format.\n\n If the format has a palette (8-bit) the index of the closest matching color\n in the palette will be returned.\n\n If the specified pixel format has an alpha component it will be returned as\n all 1 bits (fully opaque).\n\n If the pixel format bpp (color depth) is less than 32-bpp then the unused\n upper bits of the return value can safely be ignored (e.g., with a 16-bpp\n format the return value can be assigned to a Uint16, and similarly a Uint8\n for an 8-bpp format).\n\n \\param format an SDL_PixelFormat structure describing the pixel format\n \\param r the red component of the pixel in the range 0-255\n \\param g the green component of the pixel in the range 0-255\n \\param b the blue component of the pixel in the range 0-255\n \\returns a pixel value\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_GetRGB\n \\sa SDL_GetRGBA\n \\sa SDL_MapRGBA"]
     pub fn SDL_MapRGB(format: *const SDL_PixelFormat, r: Uint8, g: Uint8, b: Uint8) -> Uint32;
 }
 extern "C" {
-    #[doc = " Map an RGBA quadruple to a pixel value for a given pixel format."]
-    #[doc = ""]
-    #[doc = " This function maps the RGBA color value to the specified pixel format and"]
-    #[doc = " returns the pixel value best approximating the given RGBA color value for"]
-    #[doc = " the given pixel format."]
-    #[doc = ""]
-    #[doc = " If the specified pixel format has no alpha component the alpha value will"]
-    #[doc = " be ignored (as it will be in formats with a palette)."]
-    #[doc = ""]
-    #[doc = " If the format has a palette (8-bit) the index of the closest matching color"]
-    #[doc = " in the palette will be returned."]
-    #[doc = ""]
-    #[doc = " If the pixel format bpp (color depth) is less than 32-bpp then the unused"]
-    #[doc = " upper bits of the return value can safely be ignored (e.g., with a 16-bpp"]
-    #[doc = " format the return value can be assigned to a Uint16, and similarly a Uint8"]
-    #[doc = " for an 8-bpp format)."]
-    #[doc = ""]
-    #[doc = " \\param format an SDL_PixelFormat structure describing the format of the"]
-    #[doc = "               pixel"]
-    #[doc = " \\param r the red component of the pixel in the range 0-255"]
-    #[doc = " \\param g the green component of the pixel in the range 0-255"]
-    #[doc = " \\param b the blue component of the pixel in the range 0-255"]
-    #[doc = " \\param a the alpha component of the pixel in the range 0-255"]
-    #[doc = " \\returns a pixel value"]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_GetRGB"]
-    #[doc = " \\sa SDL_GetRGBA"]
-    #[doc = " \\sa SDL_MapRGB"]
+    #[doc = " Map an RGBA quadruple to a pixel value for a given pixel format.\n\n This function maps the RGBA color value to the specified pixel format and\n returns the pixel value best approximating the given RGBA color value for\n the given pixel format.\n\n If the specified pixel format has no alpha component the alpha value will\n be ignored (as it will be in formats with a palette).\n\n If the format has a palette (8-bit) the index of the closest matching color\n in the palette will be returned.\n\n If the pixel format bpp (color depth) is less than 32-bpp then the unused\n upper bits of the return value can safely be ignored (e.g., with a 16-bpp\n format the return value can be assigned to a Uint16, and similarly a Uint8\n for an 8-bpp format).\n\n \\param format an SDL_PixelFormat structure describing the format of the\n               pixel\n \\param r the red component of the pixel in the range 0-255\n \\param g the green component of the pixel in the range 0-255\n \\param b the blue component of the pixel in the range 0-255\n \\param a the alpha component of the pixel in the range 0-255\n \\returns a pixel value\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_GetRGB\n \\sa SDL_GetRGBA\n \\sa SDL_MapRGB"]
     pub fn SDL_MapRGBA(
         format: *const SDL_PixelFormat,
         r: Uint8,
@@ -8454,25 +5724,7 @@ extern "C" {
     ) -> Uint32;
 }
 extern "C" {
-    #[doc = " Get RGB values from a pixel in the specified format."]
-    #[doc = ""]
-    #[doc = " This function uses the entire 8-bit [0..255] range when converting color"]
-    #[doc = " components from pixel formats with less than 8-bits per RGB component"]
-    #[doc = " (e.g., a completely white pixel in 16-bit RGB565 format would return [0xff,"]
-    #[doc = " 0xff, 0xff] not [0xf8, 0xfc, 0xf8])."]
-    #[doc = ""]
-    #[doc = " \\param pixel a pixel value"]
-    #[doc = " \\param format an SDL_PixelFormat structure describing the format of the"]
-    #[doc = "               pixel"]
-    #[doc = " \\param r a pointer filled in with the red component"]
-    #[doc = " \\param g a pointer filled in with the green component"]
-    #[doc = " \\param b a pointer filled in with the blue component"]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_GetRGBA"]
-    #[doc = " \\sa SDL_MapRGB"]
-    #[doc = " \\sa SDL_MapRGBA"]
+    #[doc = " Get RGB values from a pixel in the specified format.\n\n This function uses the entire 8-bit [0..255] range when converting color\n components from pixel formats with less than 8-bits per RGB component\n (e.g., a completely white pixel in 16-bit RGB565 format would return [0xff,\n 0xff, 0xff] not [0xf8, 0xfc, 0xf8]).\n\n \\param pixel a pixel value\n \\param format an SDL_PixelFormat structure describing the format of the\n               pixel\n \\param r a pointer filled in with the red component\n \\param g a pointer filled in with the green component\n \\param b a pointer filled in with the blue component\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_GetRGBA\n \\sa SDL_MapRGB\n \\sa SDL_MapRGBA"]
     pub fn SDL_GetRGB(
         pixel: Uint32,
         format: *const SDL_PixelFormat,
@@ -8482,29 +5734,7 @@ extern "C" {
     );
 }
 extern "C" {
-    #[doc = " Get RGBA values from a pixel in the specified format."]
-    #[doc = ""]
-    #[doc = " This function uses the entire 8-bit [0..255] range when converting color"]
-    #[doc = " components from pixel formats with less than 8-bits per RGB component"]
-    #[doc = " (e.g., a completely white pixel in 16-bit RGB565 format would return [0xff,"]
-    #[doc = " 0xff, 0xff] not [0xf8, 0xfc, 0xf8])."]
-    #[doc = ""]
-    #[doc = " If the surface has no alpha component, the alpha will be returned as 0xff"]
-    #[doc = " (100% opaque)."]
-    #[doc = ""]
-    #[doc = " \\param pixel a pixel value"]
-    #[doc = " \\param format an SDL_PixelFormat structure describing the format of the"]
-    #[doc = "               pixel"]
-    #[doc = " \\param r a pointer filled in with the red component"]
-    #[doc = " \\param g a pointer filled in with the green component"]
-    #[doc = " \\param b a pointer filled in with the blue component"]
-    #[doc = " \\param a a pointer filled in with the alpha component"]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_GetRGB"]
-    #[doc = " \\sa SDL_MapRGB"]
-    #[doc = " \\sa SDL_MapRGBA"]
+    #[doc = " Get RGBA values from a pixel in the specified format.\n\n This function uses the entire 8-bit [0..255] range when converting color\n components from pixel formats with less than 8-bits per RGB component\n (e.g., a completely white pixel in 16-bit RGB565 format would return [0xff,\n 0xff, 0xff] not [0xf8, 0xfc, 0xf8]).\n\n If the surface has no alpha component, the alpha will be returned as 0xff\n (100% opaque).\n\n \\param pixel a pixel value\n \\param format an SDL_PixelFormat structure describing the format of the\n               pixel\n \\param r a pointer filled in with the red component\n \\param g a pointer filled in with the green component\n \\param b a pointer filled in with the blue component\n \\param a a pointer filled in with the alpha component\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_GetRGB\n \\sa SDL_MapRGB\n \\sa SDL_MapRGBA"]
     pub fn SDL_GetRGBA(
         pixel: Uint32,
         format: *const SDL_PixelFormat,
@@ -8515,20 +5745,10 @@ extern "C" {
     );
 }
 extern "C" {
-    #[doc = " Calculate a 256 entry gamma ramp for a gamma value."]
-    #[doc = ""]
-    #[doc = " \\param gamma a gamma value where 0.0 is black and 1.0 is identity"]
-    #[doc = " \\param ramp an array of 256 values filled in with the gamma ramp"]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_SetWindowGammaRamp"]
+    #[doc = " Calculate a 256 entry gamma ramp for a gamma value.\n\n \\param gamma a gamma value where 0.0 is black and 1.0 is identity\n \\param ramp an array of 256 values filled in with the gamma ramp\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_SetWindowGammaRamp"]
     pub fn SDL_CalculateGammaRamp(gamma: f32, ramp: *mut Uint16);
 }
-#[doc = " The structure that defines a point (integer)"]
-#[doc = ""]
-#[doc = " \\sa SDL_EnclosePoints"]
-#[doc = " \\sa SDL_PointInRect"]
+#[doc = " The structure that defines a point (integer)\n\n \\sa SDL_EnclosePoints\n \\sa SDL_PointInRect"]
 #[repr(C)]
 #[derive(Copy, Clone)]
 pub struct SDL_Point {
@@ -8537,6 +5757,8 @@ pub struct SDL_Point {
 }
 #[test]
 fn bindgen_test_layout_SDL_Point() {
+    const UNINIT: ::core::mem::MaybeUninit<SDL_Point> = ::core::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::core::mem::size_of::<SDL_Point>(),
         8usize,
@@ -8548,7 +5770,7 @@ fn bindgen_test_layout_SDL_Point() {
         concat!("Alignment of ", stringify!(SDL_Point))
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_Point>())).x as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).x) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -8558,7 +5780,7 @@ fn bindgen_test_layout_SDL_Point() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_Point>())).y as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).y) as usize - ptr as usize },
         4usize,
         concat!(
             "Offset of field: ",
@@ -8568,10 +5790,7 @@ fn bindgen_test_layout_SDL_Point() {
         )
     );
 }
-#[doc = " The structure that defines a point (floating point)"]
-#[doc = ""]
-#[doc = " \\sa SDL_EnclosePoints"]
-#[doc = " \\sa SDL_PointInRect"]
+#[doc = " The structure that defines a point (floating point)\n\n \\sa SDL_EncloseFPoints\n \\sa SDL_PointInFRect"]
 #[repr(C)]
 #[derive(Copy, Clone)]
 pub struct SDL_FPoint {
@@ -8580,6 +5799,8 @@ pub struct SDL_FPoint {
 }
 #[test]
 fn bindgen_test_layout_SDL_FPoint() {
+    const UNINIT: ::core::mem::MaybeUninit<SDL_FPoint> = ::core::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::core::mem::size_of::<SDL_FPoint>(),
         8usize,
@@ -8591,7 +5812,7 @@ fn bindgen_test_layout_SDL_FPoint() {
         concat!("Alignment of ", stringify!(SDL_FPoint))
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_FPoint>())).x as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).x) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -8601,7 +5822,7 @@ fn bindgen_test_layout_SDL_FPoint() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_FPoint>())).y as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).y) as usize - ptr as usize },
         4usize,
         concat!(
             "Offset of field: ",
@@ -8611,14 +5832,7 @@ fn bindgen_test_layout_SDL_FPoint() {
         )
     );
 }
-#[doc = " A rectangle, with the origin at the upper left (integer)."]
-#[doc = ""]
-#[doc = " \\sa SDL_RectEmpty"]
-#[doc = " \\sa SDL_RectEquals"]
-#[doc = " \\sa SDL_HasIntersection"]
-#[doc = " \\sa SDL_IntersectRect"]
-#[doc = " \\sa SDL_UnionRect"]
-#[doc = " \\sa SDL_EnclosePoints"]
+#[doc = " A rectangle, with the origin at the upper left (integer).\n\n \\sa SDL_RectEmpty\n \\sa SDL_RectEquals\n \\sa SDL_HasIntersection\n \\sa SDL_IntersectRect\n \\sa SDL_IntersectRectAndLine\n \\sa SDL_UnionRect\n \\sa SDL_EnclosePoints"]
 #[repr(C)]
 #[derive(Copy, Clone)]
 pub struct SDL_Rect {
@@ -8629,6 +5843,8 @@ pub struct SDL_Rect {
 }
 #[test]
 fn bindgen_test_layout_SDL_Rect() {
+    const UNINIT: ::core::mem::MaybeUninit<SDL_Rect> = ::core::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::core::mem::size_of::<SDL_Rect>(),
         16usize,
@@ -8640,7 +5856,7 @@ fn bindgen_test_layout_SDL_Rect() {
         concat!("Alignment of ", stringify!(SDL_Rect))
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_Rect>())).x as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).x) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -8650,7 +5866,7 @@ fn bindgen_test_layout_SDL_Rect() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_Rect>())).y as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).y) as usize - ptr as usize },
         4usize,
         concat!(
             "Offset of field: ",
@@ -8660,7 +5876,7 @@ fn bindgen_test_layout_SDL_Rect() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_Rect>())).w as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).w) as usize - ptr as usize },
         8usize,
         concat!(
             "Offset of field: ",
@@ -8670,7 +5886,7 @@ fn bindgen_test_layout_SDL_Rect() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_Rect>())).h as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).h) as usize - ptr as usize },
         12usize,
         concat!(
             "Offset of field: ",
@@ -8680,7 +5896,7 @@ fn bindgen_test_layout_SDL_Rect() {
         )
     );
 }
-#[doc = " A rectangle, with the origin at the upper left (floating point)."]
+#[doc = " A rectangle, with the origin at the upper left (floating point).\n\n \\sa SDL_FRectEmpty\n \\sa SDL_FRectEquals\n \\sa SDL_FRectEqualsEpsilon\n \\sa SDL_HasIntersectionF\n \\sa SDL_IntersectFRect\n \\sa SDL_IntersectFRectAndLine\n \\sa SDL_UnionFRect\n \\sa SDL_EncloseFPoints\n \\sa SDL_PointInFRect"]
 #[repr(C)]
 #[derive(Copy, Clone)]
 pub struct SDL_FRect {
@@ -8691,6 +5907,8 @@ pub struct SDL_FRect {
 }
 #[test]
 fn bindgen_test_layout_SDL_FRect() {
+    const UNINIT: ::core::mem::MaybeUninit<SDL_FRect> = ::core::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::core::mem::size_of::<SDL_FRect>(),
         16usize,
@@ -8702,7 +5920,7 @@ fn bindgen_test_layout_SDL_FRect() {
         concat!("Alignment of ", stringify!(SDL_FRect))
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_FRect>())).x as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).x) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -8712,7 +5930,7 @@ fn bindgen_test_layout_SDL_FRect() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_FRect>())).y as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).y) as usize - ptr as usize },
         4usize,
         concat!(
             "Offset of field: ",
@@ -8722,7 +5940,7 @@ fn bindgen_test_layout_SDL_FRect() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_FRect>())).w as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).w) as usize - ptr as usize },
         8usize,
         concat!(
             "Offset of field: ",
@@ -8732,7 +5950,7 @@ fn bindgen_test_layout_SDL_FRect() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_FRect>())).h as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).h) as usize - ptr as usize },
         12usize,
         concat!(
             "Offset of field: ",
@@ -8743,33 +5961,11 @@ fn bindgen_test_layout_SDL_FRect() {
     );
 }
 extern "C" {
-    #[doc = " Determine whether two rectangles intersect."]
-    #[doc = ""]
-    #[doc = " If either pointer is NULL the function will return SDL_FALSE."]
-    #[doc = ""]
-    #[doc = " \\param A an SDL_Rect structure representing the first rectangle"]
-    #[doc = " \\param B an SDL_Rect structure representing the second rectangle"]
-    #[doc = " \\returns SDL_TRUE if there is an intersection, SDL_FALSE otherwise."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_IntersectRect"]
+    #[doc = " Determine whether two rectangles intersect.\n\n If either pointer is NULL the function will return SDL_FALSE.\n\n \\param A an SDL_Rect structure representing the first rectangle\n \\param B an SDL_Rect structure representing the second rectangle\n \\returns SDL_TRUE if there is an intersection, SDL_FALSE otherwise.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_IntersectRect"]
     pub fn SDL_HasIntersection(A: *const SDL_Rect, B: *const SDL_Rect) -> SDL_bool;
 }
 extern "C" {
-    #[doc = " Calculate the intersection of two rectangles."]
-    #[doc = ""]
-    #[doc = " If `result` is NULL then this function will return SDL_FALSE."]
-    #[doc = ""]
-    #[doc = " \\param A an SDL_Rect structure representing the first rectangle"]
-    #[doc = " \\param B an SDL_Rect structure representing the second rectangle"]
-    #[doc = " \\param result an SDL_Rect structure filled in with the intersection of"]
-    #[doc = "               rectangles `A` and `B`"]
-    #[doc = " \\returns SDL_TRUE if there is an intersection, SDL_FALSE otherwise."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_HasIntersection"]
+    #[doc = " Calculate the intersection of two rectangles.\n\n If `result` is NULL then this function will return SDL_FALSE.\n\n \\param A an SDL_Rect structure representing the first rectangle\n \\param B an SDL_Rect structure representing the second rectangle\n \\param result an SDL_Rect structure filled in with the intersection of\n               rectangles `A` and `B`\n \\returns SDL_TRUE if there is an intersection, SDL_FALSE otherwise.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_HasIntersection"]
     pub fn SDL_IntersectRect(
         A: *const SDL_Rect,
         B: *const SDL_Rect,
@@ -8777,32 +5973,11 @@ extern "C" {
     ) -> SDL_bool;
 }
 extern "C" {
-    #[doc = " Calculate the union of two rectangles."]
-    #[doc = ""]
-    #[doc = " \\param A an SDL_Rect structure representing the first rectangle"]
-    #[doc = " \\param B an SDL_Rect structure representing the second rectangle"]
-    #[doc = " \\param result an SDL_Rect structure filled in with the union of rectangles"]
-    #[doc = "               `A` and `B`"]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
+    #[doc = " Calculate the union of two rectangles.\n\n \\param A an SDL_Rect structure representing the first rectangle\n \\param B an SDL_Rect structure representing the second rectangle\n \\param result an SDL_Rect structure filled in with the union of rectangles\n               `A` and `B`\n\n \\since This function is available since SDL 2.0.0."]
     pub fn SDL_UnionRect(A: *const SDL_Rect, B: *const SDL_Rect, result: *mut SDL_Rect);
 }
 extern "C" {
-    #[doc = " Calculate a minimal rectangle enclosing a set of points."]
-    #[doc = ""]
-    #[doc = " If `clip` is not NULL then only points inside of the clipping rectangle are"]
-    #[doc = " considered."]
-    #[doc = ""]
-    #[doc = " \\param points an array of SDL_Point structures representing points to be"]
-    #[doc = "               enclosed"]
-    #[doc = " \\param count the number of structures in the `points` array"]
-    #[doc = " \\param clip an SDL_Rect used for clipping or NULL to enclose all points"]
-    #[doc = " \\param result an SDL_Rect structure filled in with the minimal enclosing"]
-    #[doc = "               rectangle"]
-    #[doc = " \\returns SDL_TRUE if any points were enclosed or SDL_FALSE if all the"]
-    #[doc = "          points were outside of the clipping rectangle."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
+    #[doc = " Calculate a minimal rectangle enclosing a set of points.\n\n If `clip` is not NULL then only points inside of the clipping rectangle are\n considered.\n\n \\param points an array of SDL_Point structures representing points to be\n               enclosed\n \\param count the number of structures in the `points` array\n \\param clip an SDL_Rect used for clipping or NULL to enclose all points\n \\param result an SDL_Rect structure filled in with the minimal enclosing\n               rectangle\n \\returns SDL_TRUE if any points were enclosed or SDL_FALSE if all the\n          points were outside of the clipping rectangle.\n\n \\since This function is available since SDL 2.0.0."]
     pub fn SDL_EnclosePoints(
         points: *const SDL_Point,
         count: libc::c_int,
@@ -8811,22 +5986,7 @@ extern "C" {
     ) -> SDL_bool;
 }
 extern "C" {
-    #[doc = " Calculate the intersection of a rectangle and line segment."]
-    #[doc = ""]
-    #[doc = " This function is used to clip a line segment to a rectangle. A line segment"]
-    #[doc = " contained entirely within the rectangle or that does not intersect will"]
-    #[doc = " remain unchanged. A line segment that crosses the rectangle at either or"]
-    #[doc = " both ends will be clipped to the boundary of the rectangle and the new"]
-    #[doc = " coordinates saved in `X1`, `Y1`, `X2`, and/or `Y2` as necessary."]
-    #[doc = ""]
-    #[doc = " \\param rect an SDL_Rect structure representing the rectangle to intersect"]
-    #[doc = " \\param X1 a pointer to the starting X-coordinate of the line"]
-    #[doc = " \\param Y1 a pointer to the starting Y-coordinate of the line"]
-    #[doc = " \\param X2 a pointer to the ending X-coordinate of the line"]
-    #[doc = " \\param Y2 a pointer to the ending Y-coordinate of the line"]
-    #[doc = " \\returns SDL_TRUE if there is an intersection, SDL_FALSE otherwise."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
+    #[doc = " Calculate the intersection of a rectangle and line segment.\n\n This function is used to clip a line segment to a rectangle. A line segment\n contained entirely within the rectangle or that does not intersect will\n remain unchanged. A line segment that crosses the rectangle at either or\n both ends will be clipped to the boundary of the rectangle and the new\n coordinates saved in `X1`, `Y1`, `X2`, and/or `Y2` as necessary.\n\n \\param rect an SDL_Rect structure representing the rectangle to intersect\n \\param X1 a pointer to the starting X-coordinate of the line\n \\param Y1 a pointer to the starting Y-coordinate of the line\n \\param X2 a pointer to the ending X-coordinate of the line\n \\param Y2 a pointer to the ending Y-coordinate of the line\n \\returns SDL_TRUE if there is an intersection, SDL_FALSE otherwise.\n\n \\since This function is available since SDL 2.0.0."]
     pub fn SDL_IntersectRectAndLine(
         rect: *const SDL_Rect,
         X1: *mut libc::c_int,
@@ -8835,34 +5995,60 @@ extern "C" {
         Y2: *mut libc::c_int,
     ) -> SDL_bool;
 }
+extern "C" {
+    #[doc = " Determine whether two rectangles intersect with float precision.\n\n If either pointer is NULL the function will return SDL_FALSE.\n\n \\param A an SDL_FRect structure representing the first rectangle\n \\param B an SDL_FRect structure representing the second rectangle\n \\returns SDL_TRUE if there is an intersection, SDL_FALSE otherwise.\n\n \\since This function is available since SDL 2.0.22.\n\n \\sa SDL_IntersectRect"]
+    pub fn SDL_HasIntersectionF(A: *const SDL_FRect, B: *const SDL_FRect) -> SDL_bool;
+}
+extern "C" {
+    #[doc = " Calculate the intersection of two rectangles with float precision.\n\n If `result` is NULL then this function will return SDL_FALSE.\n\n \\param A an SDL_FRect structure representing the first rectangle\n \\param B an SDL_FRect structure representing the second rectangle\n \\param result an SDL_FRect structure filled in with the intersection of\n               rectangles `A` and `B`\n \\returns SDL_TRUE if there is an intersection, SDL_FALSE otherwise.\n\n \\since This function is available since SDL 2.0.22.\n\n \\sa SDL_HasIntersectionF"]
+    pub fn SDL_IntersectFRect(
+        A: *const SDL_FRect,
+        B: *const SDL_FRect,
+        result: *mut SDL_FRect,
+    ) -> SDL_bool;
+}
+extern "C" {
+    #[doc = " Calculate the union of two rectangles with float precision.\n\n \\param A an SDL_FRect structure representing the first rectangle\n \\param B an SDL_FRect structure representing the second rectangle\n \\param result an SDL_FRect structure filled in with the union of rectangles\n               `A` and `B`\n\n \\since This function is available since SDL 2.0.22."]
+    pub fn SDL_UnionFRect(A: *const SDL_FRect, B: *const SDL_FRect, result: *mut SDL_FRect);
+}
+extern "C" {
+    #[doc = " Calculate a minimal rectangle enclosing a set of points with float\n precision.\n\n If `clip` is not NULL then only points inside of the clipping rectangle are\n considered.\n\n \\param points an array of SDL_FPoint structures representing points to be\n               enclosed\n \\param count the number of structures in the `points` array\n \\param clip an SDL_FRect used for clipping or NULL to enclose all points\n \\param result an SDL_FRect structure filled in with the minimal enclosing\n               rectangle\n \\returns SDL_TRUE if any points were enclosed or SDL_FALSE if all the\n          points were outside of the clipping rectangle.\n\n \\since This function is available since SDL 2.0.22."]
+    pub fn SDL_EncloseFPoints(
+        points: *const SDL_FPoint,
+        count: libc::c_int,
+        clip: *const SDL_FRect,
+        result: *mut SDL_FRect,
+    ) -> SDL_bool;
+}
+extern "C" {
+    #[doc = " Calculate the intersection of a rectangle and line segment with float\n precision.\n\n This function is used to clip a line segment to a rectangle. A line segment\n contained entirely within the rectangle or that does not intersect will\n remain unchanged. A line segment that crosses the rectangle at either or\n both ends will be clipped to the boundary of the rectangle and the new\n coordinates saved in `X1`, `Y1`, `X2`, and/or `Y2` as necessary.\n\n \\param rect an SDL_FRect structure representing the rectangle to intersect\n \\param X1 a pointer to the starting X-coordinate of the line\n \\param Y1 a pointer to the starting Y-coordinate of the line\n \\param X2 a pointer to the ending X-coordinate of the line\n \\param Y2 a pointer to the ending Y-coordinate of the line\n \\returns SDL_TRUE if there is an intersection, SDL_FALSE otherwise.\n\n \\since This function is available since SDL 2.0.22."]
+    pub fn SDL_IntersectFRectAndLine(
+        rect: *const SDL_FRect,
+        X1: *mut f32,
+        Y1: *mut f32,
+        X2: *mut f32,
+        Y2: *mut f32,
+    ) -> SDL_bool;
+}
 #[repr(u32)]
 #[doc = "  \\brief The blend mode used in SDL_RenderCopy() and drawing operations."]
-#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
+#[derive(Copy, Clone, Hash, PartialEq, Eq)]
 pub enum SDL_BlendMode {
-    #[doc = "< no blending"]
-    #[doc = "dstRGBA = srcRGBA"]
+    #[doc = "< no blending\ndstRGBA = srcRGBA"]
     SDL_BLENDMODE_NONE = 0,
-    #[doc = "< alpha blending"]
-    #[doc = "dstRGB = (srcRGB * srcA) + (dstRGB * (1-srcA))"]
-    #[doc = "dstA = srcA + (dstA * (1-srcA))"]
+    #[doc = "< alpha blending\ndstRGB = (srcRGB * srcA) + (dstRGB * (1-srcA))\ndstA = srcA + (dstA * (1-srcA))"]
     SDL_BLENDMODE_BLEND = 1,
-    #[doc = "< additive blending"]
-    #[doc = "dstRGB = (srcRGB * srcA) + dstRGB"]
-    #[doc = "dstA = dstA"]
+    #[doc = "< additive blending\ndstRGB = (srcRGB * srcA) + dstRGB\ndstA = dstA"]
     SDL_BLENDMODE_ADD = 2,
-    #[doc = "< color modulate"]
-    #[doc = "dstRGB = srcRGB * dstRGB"]
-    #[doc = "dstA = dstA"]
+    #[doc = "< color modulate\ndstRGB = srcRGB * dstRGB\ndstA = dstA"]
     SDL_BLENDMODE_MOD = 4,
-    #[doc = "< color multiply"]
-    #[doc = "dstRGB = (srcRGB * dstRGB) + (dstRGB * (1-srcA))"]
-    #[doc = "dstA = (srcA * dstA) + (dstA * (1-srcA))"]
+    #[doc = "< color multiply\ndstRGB = (srcRGB * dstRGB) + (dstRGB * (1-srcA))\ndstA = (srcA * dstA) + (dstA * (1-srcA))"]
     SDL_BLENDMODE_MUL = 8,
     SDL_BLENDMODE_INVALID = 2147483647,
 }
 #[repr(u32)]
 #[doc = "  \\brief The blend operation used when combining source and destination pixel components"]
-#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
+#[derive(Copy, Clone, Hash, PartialEq, Eq)]
 pub enum SDL_BlendOperation {
     #[doc = "< dst + src: supported by all renderers"]
     SDL_BLENDOPERATION_ADD = 1,
@@ -8870,14 +6056,14 @@ pub enum SDL_BlendOperation {
     SDL_BLENDOPERATION_SUBTRACT = 2,
     #[doc = "< src - dst : supported by D3D9, D3D11, OpenGL, OpenGLES"]
     SDL_BLENDOPERATION_REV_SUBTRACT = 3,
-    #[doc = "< min(dst, src) : supported by D3D11"]
+    #[doc = "< min(dst, src) : supported by D3D9, D3D11"]
     SDL_BLENDOPERATION_MINIMUM = 4,
-    #[doc = "< max(dst, src) : supported by D3D11"]
+    #[doc = "< max(dst, src) : supported by D3D9, D3D11"]
     SDL_BLENDOPERATION_MAXIMUM = 5,
 }
 #[repr(u32)]
 #[doc = "  \\brief The normalized factor used to multiply pixel components"]
-#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
+#[derive(Copy, Clone, Hash, PartialEq, Eq)]
 pub enum SDL_BlendFactor {
     #[doc = "< 0, 0, 0, 0"]
     SDL_BLENDFACTOR_ZERO = 1,
@@ -8901,96 +6087,7 @@ pub enum SDL_BlendFactor {
     SDL_BLENDFACTOR_ONE_MINUS_DST_ALPHA = 10,
 }
 extern "C" {
-    #[doc = " Compose a custom blend mode for renderers."]
-    #[doc = ""]
-    #[doc = " The functions SDL_SetRenderDrawBlendMode and SDL_SetTextureBlendMode accept"]
-    #[doc = " the SDL_BlendMode returned by this function if the renderer supports it."]
-    #[doc = ""]
-    #[doc = " A blend mode controls how the pixels from a drawing operation (source) get"]
-    #[doc = " combined with the pixels from the render target (destination). First, the"]
-    #[doc = " components of the source and destination pixels get multiplied with their"]
-    #[doc = " blend factors. Then, the blend operation takes the two products and"]
-    #[doc = " calculates the result that will get stored in the render target."]
-    #[doc = ""]
-    #[doc = " Expressed in pseudocode, it would look like this:"]
-    #[doc = ""]
-    #[doc = " ```c"]
-    #[doc = " dstRGB = colorOperation(srcRGB * srcColorFactor, dstRGB * dstColorFactor);"]
-    #[doc = " dstA = alphaOperation(srcA * srcAlphaFactor, dstA * dstAlphaFactor);"]
-    #[doc = " ```"]
-    #[doc = ""]
-    #[doc = " Where the functions `colorOperation(src, dst)` and `alphaOperation(src,"]
-    #[doc = " dst)` can return one of the following:"]
-    #[doc = ""]
-    #[doc = " - `src + dst`"]
-    #[doc = " - `src - dst`"]
-    #[doc = " - `dst - src`"]
-    #[doc = " - `min(src, dst)`"]
-    #[doc = " - `max(src, dst)`"]
-    #[doc = ""]
-    #[doc = " The red, green, and blue components are always multiplied with the first,"]
-    #[doc = " second, and third components of the SDL_BlendFactor, respectively. The"]
-    #[doc = " fourth component is not used."]
-    #[doc = ""]
-    #[doc = " The alpha component is always multiplied with the fourth component of the"]
-    #[doc = " SDL_BlendFactor. The other components are not used in the alpha"]
-    #[doc = " calculation."]
-    #[doc = ""]
-    #[doc = " Support for these blend modes varies for each renderer. To check if a"]
-    #[doc = " specific SDL_BlendMode is supported, create a renderer and pass it to"]
-    #[doc = " either SDL_SetRenderDrawBlendMode or SDL_SetTextureBlendMode. They will"]
-    #[doc = " return with an error if the blend mode is not supported."]
-    #[doc = ""]
-    #[doc = " This list describes the support of custom blend modes for each renderer in"]
-    #[doc = " SDL 2.0.6. All renderers support the four blend modes listed in the"]
-    #[doc = " SDL_BlendMode enumeration."]
-    #[doc = ""]
-    #[doc = " - **direct3d**: Supports `SDL_BLENDOPERATION_ADD` with all factors."]
-    #[doc = " - **direct3d11**: Supports all operations with all factors. However, some"]
-    #[doc = "   factors produce unexpected results with `SDL_BLENDOPERATION_MINIMUM` and"]
-    #[doc = "   `SDL_BLENDOPERATION_MAXIMUM`."]
-    #[doc = " - **opengl**: Supports the `SDL_BLENDOPERATION_ADD` operation with all"]
-    #[doc = "   factors. OpenGL versions 1.1, 1.2, and 1.3 do not work correctly with SDL"]
-    #[doc = "   2.0.6."]
-    #[doc = " - **opengles**: Supports the `SDL_BLENDOPERATION_ADD` operation with all"]
-    #[doc = "   factors. Color and alpha factors need to be the same. OpenGL ES 1"]
-    #[doc = "   implementation specific: May also support `SDL_BLENDOPERATION_SUBTRACT`"]
-    #[doc = "   and `SDL_BLENDOPERATION_REV_SUBTRACT`. May support color and alpha"]
-    #[doc = "   operations being different from each other. May support color and alpha"]
-    #[doc = "   factors being different from each other."]
-    #[doc = " - **opengles2**: Supports the `SDL_BLENDOPERATION_ADD`,"]
-    #[doc = "   `SDL_BLENDOPERATION_SUBTRACT`, `SDL_BLENDOPERATION_REV_SUBTRACT`"]
-    #[doc = "   operations with all factors."]
-    #[doc = " - **psp**: No custom blend mode support."]
-    #[doc = " - **software**: No custom blend mode support."]
-    #[doc = ""]
-    #[doc = " Some renderers do not provide an alpha component for the default render"]
-    #[doc = " target. The `SDL_BLENDFACTOR_DST_ALPHA` and"]
-    #[doc = " `SDL_BLENDFACTOR_ONE_MINUS_DST_ALPHA` factors do not have an effect in this"]
-    #[doc = " case."]
-    #[doc = ""]
-    #[doc = " \\param srcColorFactor the SDL_BlendFactor applied to the red, green, and"]
-    #[doc = "                       blue components of the source pixels"]
-    #[doc = " \\param dstColorFactor the SDL_BlendFactor applied to the red, green, and"]
-    #[doc = "                       blue components of the destination pixels"]
-    #[doc = " \\param colorOperation the SDL_BlendOperation used to combine the red,"]
-    #[doc = "                       green, and blue components of the source and"]
-    #[doc = "                       destination pixels"]
-    #[doc = " \\param srcAlphaFactor the SDL_BlendFactor applied to the alpha component of"]
-    #[doc = "                       the source pixels"]
-    #[doc = " \\param dstAlphaFactor the SDL_BlendFactor applied to the alpha component of"]
-    #[doc = "                       the destination pixels"]
-    #[doc = " \\param alphaOperation the SDL_BlendOperation used to combine the alpha"]
-    #[doc = "                       component of the source and destination pixels"]
-    #[doc = " \\returns an SDL_BlendMode that represents the chosen factors and"]
-    #[doc = "          operations."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.6."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_SetRenderDrawBlendMode"]
-    #[doc = " \\sa SDL_GetRenderDrawBlendMode"]
-    #[doc = " \\sa SDL_SetTextureBlendMode"]
-    #[doc = " \\sa SDL_GetTextureBlendMode"]
+    #[doc = " Compose a custom blend mode for renderers.\n\n The functions SDL_SetRenderDrawBlendMode and SDL_SetTextureBlendMode accept\n the SDL_BlendMode returned by this function if the renderer supports it.\n\n A blend mode controls how the pixels from a drawing operation (source) get\n combined with the pixels from the render target (destination). First, the\n components of the source and destination pixels get multiplied with their\n blend factors. Then, the blend operation takes the two products and\n calculates the result that will get stored in the render target.\n\n Expressed in pseudocode, it would look like this:\n\n ```c\n dstRGB = colorOperation(srcRGB * srcColorFactor, dstRGB * dstColorFactor);\n dstA = alphaOperation(srcA * srcAlphaFactor, dstA * dstAlphaFactor);\n ```\n\n Where the functions `colorOperation(src, dst)` and `alphaOperation(src,\n dst)` can return one of the following:\n\n - `src + dst`\n - `src - dst`\n - `dst - src`\n - `min(src, dst)`\n - `max(src, dst)`\n\n The red, green, and blue components are always multiplied with the first,\n second, and third components of the SDL_BlendFactor, respectively. The\n fourth component is not used.\n\n The alpha component is always multiplied with the fourth component of the\n SDL_BlendFactor. The other components are not used in the alpha\n calculation.\n\n Support for these blend modes varies for each renderer. To check if a\n specific SDL_BlendMode is supported, create a renderer and pass it to\n either SDL_SetRenderDrawBlendMode or SDL_SetTextureBlendMode. They will\n return with an error if the blend mode is not supported.\n\n This list describes the support of custom blend modes for each renderer in\n SDL 2.0.6. All renderers support the four blend modes listed in the\n SDL_BlendMode enumeration.\n\n - **direct3d**: Supports all operations with all factors. However, some\n   factors produce unexpected results with `SDL_BLENDOPERATION_MINIMUM` and\n   `SDL_BLENDOPERATION_MAXIMUM`.\n - **direct3d11**: Same as Direct3D 9.\n - **opengl**: Supports the `SDL_BLENDOPERATION_ADD` operation with all\n   factors. OpenGL versions 1.1, 1.2, and 1.3 do not work correctly with SDL\n   2.0.6.\n - **opengles**: Supports the `SDL_BLENDOPERATION_ADD` operation with all\n   factors. Color and alpha factors need to be the same. OpenGL ES 1\n   implementation specific: May also support `SDL_BLENDOPERATION_SUBTRACT`\n   and `SDL_BLENDOPERATION_REV_SUBTRACT`. May support color and alpha\n   operations being different from each other. May support color and alpha\n   factors being different from each other.\n - **opengles2**: Supports the `SDL_BLENDOPERATION_ADD`,\n   `SDL_BLENDOPERATION_SUBTRACT`, `SDL_BLENDOPERATION_REV_SUBTRACT`\n   operations with all factors.\n - **psp**: No custom blend mode support.\n - **software**: No custom blend mode support.\n\n Some renderers do not provide an alpha component for the default render\n target. The `SDL_BLENDFACTOR_DST_ALPHA` and\n `SDL_BLENDFACTOR_ONE_MINUS_DST_ALPHA` factors do not have an effect in this\n case.\n\n \\param srcColorFactor the SDL_BlendFactor applied to the red, green, and\n                       blue components of the source pixels\n \\param dstColorFactor the SDL_BlendFactor applied to the red, green, and\n                       blue components of the destination pixels\n \\param colorOperation the SDL_BlendOperation used to combine the red,\n                       green, and blue components of the source and\n                       destination pixels\n \\param srcAlphaFactor the SDL_BlendFactor applied to the alpha component of\n                       the source pixels\n \\param dstAlphaFactor the SDL_BlendFactor applied to the alpha component of\n                       the destination pixels\n \\param alphaOperation the SDL_BlendOperation used to combine the alpha\n                       component of the source and destination pixels\n \\returns an SDL_BlendMode that represents the chosen factors and\n          operations.\n\n \\since This function is available since SDL 2.0.6.\n\n \\sa SDL_SetRenderDrawBlendMode\n \\sa SDL_GetRenderDrawBlendMode\n \\sa SDL_SetTextureBlendMode\n \\sa SDL_GetTextureBlendMode"]
     pub fn SDL_ComposeCustomBlendMode(
         srcColorFactor: SDL_BlendFactor,
         dstColorFactor: SDL_BlendFactor,
@@ -9000,10 +6097,12 @@ extern "C" {
         alphaOperation: SDL_BlendOperation,
     ) -> SDL_BlendMode;
 }
-#[doc = " \\brief A collection of pixels used in software blitting."]
-#[doc = ""]
-#[doc = " \\note  This structure should be treated as read-only, except for \\c pixels,"]
-#[doc = "        which, if not NULL, contains the raw pixel data for the surface."]
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct SDL_BlitMap {
+    _unused: [u8; 0],
+}
+#[doc = " \\brief A collection of pixels used in software blitting.\n\n \\note  This structure should be treated as read-only, except for \\c pixels,\n        which, if not NULL, contains the raw pixel data for the surface."]
 #[repr(C)]
 #[derive(Copy, Clone)]
 pub struct SDL_Surface {
@@ -9034,6 +6133,8 @@ pub struct SDL_Surface {
 }
 #[test]
 fn bindgen_test_layout_SDL_Surface() {
+    const UNINIT: ::core::mem::MaybeUninit<SDL_Surface> = ::core::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::core::mem::size_of::<SDL_Surface>(),
         96usize,
@@ -9045,7 +6146,7 @@ fn bindgen_test_layout_SDL_Surface() {
         concat!("Alignment of ", stringify!(SDL_Surface))
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_Surface>())).flags as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -9055,7 +6156,7 @@ fn bindgen_test_layout_SDL_Surface() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_Surface>())).format as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).format) as usize - ptr as usize },
         8usize,
         concat!(
             "Offset of field: ",
@@ -9065,7 +6166,7 @@ fn bindgen_test_layout_SDL_Surface() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_Surface>())).w as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).w) as usize - ptr as usize },
         16usize,
         concat!(
             "Offset of field: ",
@@ -9075,7 +6176,7 @@ fn bindgen_test_layout_SDL_Surface() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_Surface>())).h as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).h) as usize - ptr as usize },
         20usize,
         concat!(
             "Offset of field: ",
@@ -9085,7 +6186,7 @@ fn bindgen_test_layout_SDL_Surface() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_Surface>())).pitch as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).pitch) as usize - ptr as usize },
         24usize,
         concat!(
             "Offset of field: ",
@@ -9095,7 +6196,7 @@ fn bindgen_test_layout_SDL_Surface() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_Surface>())).pixels as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).pixels) as usize - ptr as usize },
         32usize,
         concat!(
             "Offset of field: ",
@@ -9105,7 +6206,7 @@ fn bindgen_test_layout_SDL_Surface() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_Surface>())).userdata as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).userdata) as usize - ptr as usize },
         40usize,
         concat!(
             "Offset of field: ",
@@ -9115,7 +6216,7 @@ fn bindgen_test_layout_SDL_Surface() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_Surface>())).locked as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).locked) as usize - ptr as usize },
         48usize,
         concat!(
             "Offset of field: ",
@@ -9125,7 +6226,7 @@ fn bindgen_test_layout_SDL_Surface() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_Surface>())).list_blitmap as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).list_blitmap) as usize - ptr as usize },
         56usize,
         concat!(
             "Offset of field: ",
@@ -9135,7 +6236,7 @@ fn bindgen_test_layout_SDL_Surface() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_Surface>())).clip_rect as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).clip_rect) as usize - ptr as usize },
         64usize,
         concat!(
             "Offset of field: ",
@@ -9145,7 +6246,7 @@ fn bindgen_test_layout_SDL_Surface() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_Surface>())).map as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).map) as usize - ptr as usize },
         80usize,
         concat!(
             "Offset of field: ",
@@ -9155,7 +6256,7 @@ fn bindgen_test_layout_SDL_Surface() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_Surface>())).refcount as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).refcount) as usize - ptr as usize },
         88usize,
         concat!(
             "Offset of field: ",
@@ -9176,7 +6277,7 @@ pub type SDL_blit = ::core::option::Option<
 >;
 #[repr(u32)]
 #[doc = " \\brief The formula used for converting between YUV and RGB"]
-#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
+#[derive(Copy, Clone, Hash, PartialEq, Eq)]
 pub enum SDL_YUV_CONVERSION_MODE {
     #[doc = "< Full range JPEG"]
     SDL_YUV_CONVERSION_JPEG = 0,
@@ -9188,48 +6289,7 @@ pub enum SDL_YUV_CONVERSION_MODE {
     SDL_YUV_CONVERSION_AUTOMATIC = 3,
 }
 extern "C" {
-    #[doc = " Allocate a new RGB surface."]
-    #[doc = ""]
-    #[doc = " If `depth` is 4 or 8 bits, an empty palette is allocated for the surface."]
-    #[doc = " If `depth` is greater than 8 bits, the pixel format is set using the"]
-    #[doc = " [RGBA]mask parameters."]
-    #[doc = ""]
-    #[doc = " The [RGBA]mask parameters are the bitmasks used to extract that color from"]
-    #[doc = " a pixel. For instance, `Rmask` being 0xFF000000 means the red data is"]
-    #[doc = " stored in the most significant byte. Using zeros for the RGB masks sets a"]
-    #[doc = " default value, based on the depth. For example:"]
-    #[doc = ""]
-    #[doc = " ```c++"]
-    #[doc = " SDL_CreateRGBSurface(0,w,h,32,0,0,0,0);"]
-    #[doc = " ```"]
-    #[doc = ""]
-    #[doc = " However, using zero for the Amask results in an Amask of 0."]
-    #[doc = ""]
-    #[doc = " By default surfaces with an alpha mask are set up for blending as with:"]
-    #[doc = ""]
-    #[doc = " ```c++"]
-    #[doc = " SDL_SetSurfaceBlendMode(surface, SDL_BLENDMODE_BLEND)"]
-    #[doc = " ```"]
-    #[doc = ""]
-    #[doc = " You can change this by calling SDL_SetSurfaceBlendMode() and selecting a"]
-    #[doc = " different `blendMode`."]
-    #[doc = ""]
-    #[doc = " \\param flags the flags are unused and should be set to 0"]
-    #[doc = " \\param width the width of the surface"]
-    #[doc = " \\param height the height of the surface"]
-    #[doc = " \\param depth the depth of the surface in bits"]
-    #[doc = " \\param Rmask the red mask for the pixels"]
-    #[doc = " \\param Gmask the green mask for the pixels"]
-    #[doc = " \\param Bmask the blue mask for the pixels"]
-    #[doc = " \\param Amask the alpha mask for the pixels"]
-    #[doc = " \\returns the new SDL_Surface structure that is created or NULL if it fails;"]
-    #[doc = "          call SDL_GetError() for more information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_CreateRGBSurfaceFrom"]
-    #[doc = " \\sa SDL_CreateRGBSurfaceWithFormat"]
-    #[doc = " \\sa SDL_FreeSurface"]
+    #[doc = " Allocate a new RGB surface.\n\n If `depth` is 4 or 8 bits, an empty palette is allocated for the surface.\n If `depth` is greater than 8 bits, the pixel format is set using the\n [RGBA]mask parameters.\n\n The [RGBA]mask parameters are the bitmasks used to extract that color from\n a pixel. For instance, `Rmask` being 0xFF000000 means the red data is\n stored in the most significant byte. Using zeros for the RGB masks sets a\n default value, based on the depth. For example:\n\n ```c++\n SDL_CreateRGBSurface(0,w,h,32,0,0,0,0);\n ```\n\n However, using zero for the Amask results in an Amask of 0.\n\n By default surfaces with an alpha mask are set up for blending as with:\n\n ```c++\n SDL_SetSurfaceBlendMode(surface, SDL_BLENDMODE_BLEND)\n ```\n\n You can change this by calling SDL_SetSurfaceBlendMode() and selecting a\n different `blendMode`.\n\n \\param flags the flags are unused and should be set to 0\n \\param width the width of the surface\n \\param height the height of the surface\n \\param depth the depth of the surface in bits\n \\param Rmask the red mask for the pixels\n \\param Gmask the green mask for the pixels\n \\param Bmask the blue mask for the pixels\n \\param Amask the alpha mask for the pixels\n \\returns the new SDL_Surface structure that is created or NULL if it fails;\n          call SDL_GetError() for more information.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_CreateRGBSurfaceFrom\n \\sa SDL_CreateRGBSurfaceWithFormat\n \\sa SDL_FreeSurface"]
     pub fn SDL_CreateRGBSurface(
         flags: Uint32,
         width: libc::c_int,
@@ -9242,25 +6302,7 @@ extern "C" {
     ) -> *mut SDL_Surface;
 }
 extern "C" {
-    #[doc = " Allocate a new RGB surface with a specific pixel format."]
-    #[doc = ""]
-    #[doc = " This function operates mostly like SDL_CreateRGBSurface(), except instead"]
-    #[doc = " of providing pixel color masks, you provide it with a predefined format"]
-    #[doc = " from SDL_PixelFormatEnum."]
-    #[doc = ""]
-    #[doc = " \\param flags the flags are unused and should be set to 0"]
-    #[doc = " \\param width the width of the surface"]
-    #[doc = " \\param height the height of the surface"]
-    #[doc = " \\param depth the depth of the surface in bits"]
-    #[doc = " \\param format the SDL_PixelFormatEnum for the new surface's pixel format."]
-    #[doc = " \\returns the new SDL_Surface structure that is created or NULL if it fails;"]
-    #[doc = "          call SDL_GetError() for more information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.5."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_CreateRGBSurface"]
-    #[doc = " \\sa SDL_CreateRGBSurfaceFrom"]
-    #[doc = " \\sa SDL_FreeSurface"]
+    #[doc = " Allocate a new RGB surface with a specific pixel format.\n\n This function operates mostly like SDL_CreateRGBSurface(), except instead\n of providing pixel color masks, you provide it with a predefined format\n from SDL_PixelFormatEnum.\n\n \\param flags the flags are unused and should be set to 0\n \\param width the width of the surface\n \\param height the height of the surface\n \\param depth the depth of the surface in bits\n \\param format the SDL_PixelFormatEnum for the new surface's pixel format.\n \\returns the new SDL_Surface structure that is created or NULL if it fails;\n          call SDL_GetError() for more information.\n\n \\since This function is available since SDL 2.0.5.\n\n \\sa SDL_CreateRGBSurface\n \\sa SDL_CreateRGBSurfaceFrom\n \\sa SDL_FreeSurface"]
     pub fn SDL_CreateRGBSurfaceWithFormat(
         flags: Uint32,
         width: libc::c_int,
@@ -9270,32 +6312,7 @@ extern "C" {
     ) -> *mut SDL_Surface;
 }
 extern "C" {
-    #[doc = " Allocate a new RGB surface with existing pixel data."]
-    #[doc = ""]
-    #[doc = " This function operates mostly like SDL_CreateRGBSurface(), except it does"]
-    #[doc = " not allocate memory for the pixel data, instead the caller provides an"]
-    #[doc = " existing buffer of data for the surface to use."]
-    #[doc = ""]
-    #[doc = " No copy is made of the pixel data. Pixel data is not managed automatically;"]
-    #[doc = " you must free the surface before you free the pixel data."]
-    #[doc = ""]
-    #[doc = " \\param pixels a pointer to existing pixel data"]
-    #[doc = " \\param width the width of the surface"]
-    #[doc = " \\param height the height of the surface"]
-    #[doc = " \\param depth the depth of the surface in bits"]
-    #[doc = " \\param pitch the pitch of the surface in bytes"]
-    #[doc = " \\param Rmask the red mask for the pixels"]
-    #[doc = " \\param Gmask the green mask for the pixels"]
-    #[doc = " \\param Bmask the blue mask for the pixels"]
-    #[doc = " \\param Amask the alpha mask for the pixels"]
-    #[doc = " \\returns the new SDL_Surface structure that is created or NULL if it fails;"]
-    #[doc = "          call SDL_GetError() for more information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_CreateRGBSurface"]
-    #[doc = " \\sa SDL_CreateRGBSurfaceWithFormat"]
-    #[doc = " \\sa SDL_FreeSurface"]
+    #[doc = " Allocate a new RGB surface with existing pixel data.\n\n This function operates mostly like SDL_CreateRGBSurface(), except it does\n not allocate memory for the pixel data, instead the caller provides an\n existing buffer of data for the surface to use.\n\n No copy is made of the pixel data. Pixel data is not managed automatically;\n you must free the surface before you free the pixel data.\n\n \\param pixels a pointer to existing pixel data\n \\param width the width of the surface\n \\param height the height of the surface\n \\param depth the depth of the surface in bits\n \\param pitch the pitch of the surface in bytes\n \\param Rmask the red mask for the pixels\n \\param Gmask the green mask for the pixels\n \\param Bmask the blue mask for the pixels\n \\param Amask the alpha mask for the pixels\n \\returns the new SDL_Surface structure that is created or NULL if it fails;\n          call SDL_GetError() for more information.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_CreateRGBSurface\n \\sa SDL_CreateRGBSurfaceWithFormat\n \\sa SDL_FreeSurface"]
     pub fn SDL_CreateRGBSurfaceFrom(
         pixels: *mut libc::c_void,
         width: libc::c_int,
@@ -9309,30 +6326,7 @@ extern "C" {
     ) -> *mut SDL_Surface;
 }
 extern "C" {
-    #[doc = " Allocate a new RGB surface with with a specific pixel format and existing"]
-    #[doc = " pixel data."]
-    #[doc = ""]
-    #[doc = " This function operates mostly like SDL_CreateRGBSurfaceFrom(), except"]
-    #[doc = " instead of providing pixel color masks, you provide it with a predefined"]
-    #[doc = " format from SDL_PixelFormatEnum."]
-    #[doc = ""]
-    #[doc = " No copy is made of the pixel data. Pixel data is not managed automatically;"]
-    #[doc = " you must free the surface before you free the pixel data."]
-    #[doc = ""]
-    #[doc = " \\param pixels a pointer to existing pixel data"]
-    #[doc = " \\param width the width of the surface"]
-    #[doc = " \\param height the height of the surface"]
-    #[doc = " \\param depth the depth of the surface in bits"]
-    #[doc = " \\param pitch the pitch of the surface in bytes"]
-    #[doc = " \\param format the SDL_PixelFormatEnum for the new surface's pixel format."]
-    #[doc = " \\returns the new SDL_Surface structure that is created or NULL if it fails;"]
-    #[doc = "          call SDL_GetError() for more information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.5."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_CreateRGBSurfaceFrom"]
-    #[doc = " \\sa SDL_CreateRGBSurfaceWithFormat"]
-    #[doc = " \\sa SDL_FreeSurface"]
+    #[doc = " Allocate a new RGB surface with with a specific pixel format and existing\n pixel data.\n\n This function operates mostly like SDL_CreateRGBSurfaceFrom(), except\n instead of providing pixel color masks, you provide it with a predefined\n format from SDL_PixelFormatEnum.\n\n No copy is made of the pixel data. Pixel data is not managed automatically;\n you must free the surface before you free the pixel data.\n\n \\param pixels a pointer to existing pixel data\n \\param width the width of the surface\n \\param height the height of the surface\n \\param depth the depth of the surface in bits\n \\param pitch the pitch of the surface in bytes\n \\param format the SDL_PixelFormatEnum for the new surface's pixel format.\n \\returns the new SDL_Surface structure that is created or NULL if it fails;\n          call SDL_GetError() for more information.\n\n \\since This function is available since SDL 2.0.5.\n\n \\sa SDL_CreateRGBSurfaceFrom\n \\sa SDL_CreateRGBSurfaceWithFormat\n \\sa SDL_FreeSurface"]
     pub fn SDL_CreateRGBSurfaceWithFormatFrom(
         pixels: *mut libc::c_void,
         width: libc::c_int,
@@ -9343,110 +6337,30 @@ extern "C" {
     ) -> *mut SDL_Surface;
 }
 extern "C" {
-    #[doc = " Free an RGB surface."]
-    #[doc = ""]
-    #[doc = " It is safe to pass NULL to this function."]
-    #[doc = ""]
-    #[doc = " \\param surface the SDL_Surface to free."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_CreateRGBSurface"]
-    #[doc = " \\sa SDL_CreateRGBSurfaceFrom"]
-    #[doc = " \\sa SDL_LoadBMP"]
-    #[doc = " \\sa SDL_LoadBMP_RW"]
+    #[doc = " Free an RGB surface.\n\n It is safe to pass NULL to this function.\n\n \\param surface the SDL_Surface to free.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_CreateRGBSurface\n \\sa SDL_CreateRGBSurfaceFrom\n \\sa SDL_LoadBMP\n \\sa SDL_LoadBMP_RW"]
     pub fn SDL_FreeSurface(surface: *mut SDL_Surface);
 }
 extern "C" {
-    #[doc = " Set the palette used by a surface."]
-    #[doc = ""]
-    #[doc = " A single palette can be shared with many surfaces."]
-    #[doc = ""]
-    #[doc = " \\param surface the SDL_Surface structure to update"]
-    #[doc = " \\param palette the SDL_Palette structure to use"]
-    #[doc = " \\returns 0 on success or a negative error code on failure; call"]
-    #[doc = "          SDL_GetError() for more information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
+    #[doc = " Set the palette used by a surface.\n\n A single palette can be shared with many surfaces.\n\n \\param surface the SDL_Surface structure to update\n \\param palette the SDL_Palette structure to use\n \\returns 0 on success or a negative error code on failure; call\n          SDL_GetError() for more information.\n\n \\since This function is available since SDL 2.0.0."]
     pub fn SDL_SetSurfacePalette(
         surface: *mut SDL_Surface,
         palette: *mut SDL_Palette,
     ) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Set up a surface for directly accessing the pixels."]
-    #[doc = ""]
-    #[doc = " Between calls to SDL_LockSurface() / SDL_UnlockSurface(), you can write to"]
-    #[doc = " and read from `surface->pixels`, using the pixel format stored in"]
-    #[doc = " `surface->format`. Once you are done accessing the surface, you should use"]
-    #[doc = " SDL_UnlockSurface() to release it."]
-    #[doc = ""]
-    #[doc = " Not all surfaces require locking. If `SDL_MUSTLOCK(surface)` evaluates to"]
-    #[doc = " 0, then you can read and write to the surface at any time, and the pixel"]
-    #[doc = " format of the surface will not change."]
-    #[doc = ""]
-    #[doc = " \\param surface the SDL_Surface structure to be locked"]
-    #[doc = " \\returns 0 on success or a negative error code on failure; call"]
-    #[doc = "          SDL_GetError() for more information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_MUSTLOCK"]
-    #[doc = " \\sa SDL_UnlockSurface"]
+    #[doc = " Set up a surface for directly accessing the pixels.\n\n Between calls to SDL_LockSurface() / SDL_UnlockSurface(), you can write to\n and read from `surface->pixels`, using the pixel format stored in\n `surface->format`. Once you are done accessing the surface, you should use\n SDL_UnlockSurface() to release it.\n\n Not all surfaces require locking. If `SDL_MUSTLOCK(surface)` evaluates to\n 0, then you can read and write to the surface at any time, and the pixel\n format of the surface will not change.\n\n \\param surface the SDL_Surface structure to be locked\n \\returns 0 on success or a negative error code on failure; call\n          SDL_GetError() for more information.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_MUSTLOCK\n \\sa SDL_UnlockSurface"]
     pub fn SDL_LockSurface(surface: *mut SDL_Surface) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Release a surface after directly accessing the pixels."]
-    #[doc = ""]
-    #[doc = " \\param surface the SDL_Surface structure to be unlocked"]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_LockSurface"]
+    #[doc = " Release a surface after directly accessing the pixels.\n\n \\param surface the SDL_Surface structure to be unlocked\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_LockSurface"]
     pub fn SDL_UnlockSurface(surface: *mut SDL_Surface);
 }
 extern "C" {
-    #[doc = " Load a BMP image from a seekable SDL data stream."]
-    #[doc = ""]
-    #[doc = " The new surface should be freed with SDL_FreeSurface(). Not doing so will"]
-    #[doc = " result in a memory leak."]
-    #[doc = ""]
-    #[doc = " src is an open SDL_RWops buffer, typically loaded with SDL_RWFromFile."]
-    #[doc = " Alternitavely, you might also use the macro SDL_LoadBMP to load a bitmap"]
-    #[doc = " from a file, convert it to an SDL_Surface and then close the file."]
-    #[doc = ""]
-    #[doc = " \\param src the data stream for the surface"]
-    #[doc = " \\param freesrc non-zero to close the stream after being read"]
-    #[doc = " \\returns a pointer to a new SDL_Surface structure or NULL if there was an"]
-    #[doc = "          error; call SDL_GetError() for more information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_FreeSurface"]
-    #[doc = " \\sa SDL_RWFromFile"]
-    #[doc = " \\sa SDL_LoadBMP"]
-    #[doc = " \\sa SDL_SaveBMP_RW"]
+    #[doc = " Load a BMP image from a seekable SDL data stream.\n\n The new surface should be freed with SDL_FreeSurface(). Not doing so will\n result in a memory leak.\n\n src is an open SDL_RWops buffer, typically loaded with SDL_RWFromFile.\n Alternitavely, you might also use the macro SDL_LoadBMP to load a bitmap\n from a file, convert it to an SDL_Surface and then close the file.\n\n \\param src the data stream for the surface\n \\param freesrc non-zero to close the stream after being read\n \\returns a pointer to a new SDL_Surface structure or NULL if there was an\n          error; call SDL_GetError() for more information.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_FreeSurface\n \\sa SDL_RWFromFile\n \\sa SDL_LoadBMP\n \\sa SDL_SaveBMP_RW"]
     pub fn SDL_LoadBMP_RW(src: *mut SDL_RWops, freesrc: libc::c_int) -> *mut SDL_Surface;
 }
 extern "C" {
-    #[doc = " Save a surface to a seekable SDL data stream in BMP format."]
-    #[doc = ""]
-    #[doc = " Surfaces with a 24-bit, 32-bit and paletted 8-bit format get saved in the"]
-    #[doc = " BMP directly. Other RGB formats with 8-bit or higher get converted to a"]
-    #[doc = " 24-bit surface or, if they have an alpha mask or a colorkey, to a 32-bit"]
-    #[doc = " surface before they are saved. YUV and paletted 1-bit and 4-bit formats are"]
-    #[doc = " not supported."]
-    #[doc = ""]
-    #[doc = " \\param surface the SDL_Surface structure containing the image to be saved"]
-    #[doc = " \\param dst a data stream to save to"]
-    #[doc = " \\param freedst non-zero to close the stream after being written"]
-    #[doc = " \\returns 0 on success or a negative error code on failure; call"]
-    #[doc = "          SDL_GetError() for more information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_LoadBMP_RW"]
-    #[doc = " \\sa SDL_SaveBMP"]
+    #[doc = " Save a surface to a seekable SDL data stream in BMP format.\n\n Surfaces with a 24-bit, 32-bit and paletted 8-bit format get saved in the\n BMP directly. Other RGB formats with 8-bit or higher get converted to a\n 24-bit surface or, if they have an alpha mask or a colorkey, to a 32-bit\n surface before they are saved. YUV and paletted 1-bit and 4-bit formats are\n not supported.\n\n \\param surface the SDL_Surface structure containing the image to be saved\n \\param dst a data stream to save to\n \\param freedst non-zero to close the stream after being written\n \\returns 0 on success or a negative error code on failure; call\n          SDL_GetError() for more information.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_LoadBMP_RW\n \\sa SDL_SaveBMP"]
     pub fn SDL_SaveBMP_RW(
         surface: *mut SDL_Surface,
         dst: *mut SDL_RWops,
@@ -9454,59 +6368,15 @@ extern "C" {
     ) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Set the RLE acceleration hint for a surface."]
-    #[doc = ""]
-    #[doc = " If RLE is enabled, color key and alpha blending blits are much faster, but"]
-    #[doc = " the surface must be locked before directly accessing the pixels."]
-    #[doc = ""]
-    #[doc = " \\param surface the SDL_Surface structure to optimize"]
-    #[doc = " \\param flag 0 to disable, non-zero to enable RLE acceleration"]
-    #[doc = " \\returns 0 on success or a negative error code on failure; call"]
-    #[doc = "          SDL_GetError() for more information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_BlitSurface"]
-    #[doc = " \\sa SDL_LockSurface"]
-    #[doc = " \\sa SDL_UnlockSurface"]
+    #[doc = " Set the RLE acceleration hint for a surface.\n\n If RLE is enabled, color key and alpha blending blits are much faster, but\n the surface must be locked before directly accessing the pixels.\n\n \\param surface the SDL_Surface structure to optimize\n \\param flag 0 to disable, non-zero to enable RLE acceleration\n \\returns 0 on success or a negative error code on failure; call\n          SDL_GetError() for more information.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_BlitSurface\n \\sa SDL_LockSurface\n \\sa SDL_UnlockSurface"]
     pub fn SDL_SetSurfaceRLE(surface: *mut SDL_Surface, flag: libc::c_int) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Returns whether the surface is RLE enabled"]
-    #[doc = ""]
-    #[doc = " It is safe to pass a NULL `surface` here; it will return SDL_FALSE."]
-    #[doc = ""]
-    #[doc = " \\param surface the SDL_Surface structure to query"]
-    #[doc = " \\returns SDL_TRUE if the surface is RLE enabled, SDL_FALSE otherwise."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.14."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_SetSurfaceRLE"]
+    #[doc = " Returns whether the surface is RLE enabled\n\n It is safe to pass a NULL `surface` here; it will return SDL_FALSE.\n\n \\param surface the SDL_Surface structure to query\n \\returns SDL_TRUE if the surface is RLE enabled, SDL_FALSE otherwise.\n\n \\since This function is available since SDL 2.0.14.\n\n \\sa SDL_SetSurfaceRLE"]
     pub fn SDL_HasSurfaceRLE(surface: *mut SDL_Surface) -> SDL_bool;
 }
 extern "C" {
-    #[doc = " Set the color key (transparent pixel) in a surface."]
-    #[doc = ""]
-    #[doc = " The color key defines a pixel value that will be treated as transparent in"]
-    #[doc = " a blit. For example, one can use this to specify that cyan pixels should be"]
-    #[doc = " considered transparent, and therefore not rendered."]
-    #[doc = ""]
-    #[doc = " It is a pixel of the format used by the surface, as generated by"]
-    #[doc = " SDL_MapRGB()."]
-    #[doc = ""]
-    #[doc = " RLE acceleration can substantially speed up blitting of images with large"]
-    #[doc = " horizontal runs of transparent pixels. See SDL_SetSurfaceRLE() for details."]
-    #[doc = ""]
-    #[doc = " \\param surface the SDL_Surface structure to update"]
-    #[doc = " \\param flag SDL_TRUE to enable color key, SDL_FALSE to disable color key"]
-    #[doc = " \\param key the transparent pixel"]
-    #[doc = " \\returns 0 on success or a negative error code on failure; call"]
-    #[doc = "          SDL_GetError() for more information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_BlitSurface"]
-    #[doc = " \\sa SDL_GetColorKey"]
+    #[doc = " Set the color key (transparent pixel) in a surface.\n\n The color key defines a pixel value that will be treated as transparent in\n a blit. For example, one can use this to specify that cyan pixels should be\n considered transparent, and therefore not rendered.\n\n It is a pixel of the format used by the surface, as generated by\n SDL_MapRGB().\n\n RLE acceleration can substantially speed up blitting of images with large\n horizontal runs of transparent pixels. See SDL_SetSurfaceRLE() for details.\n\n \\param surface the SDL_Surface structure to update\n \\param flag SDL_TRUE to enable color key, SDL_FALSE to disable color key\n \\param key the transparent pixel\n \\returns 0 on success or a negative error code on failure; call\n          SDL_GetError() for more information.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_BlitSurface\n \\sa SDL_GetColorKey"]
     pub fn SDL_SetColorKey(
         surface: *mut SDL_Surface,
         flag: libc::c_int,
@@ -9514,58 +6384,15 @@ extern "C" {
     ) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Returns whether the surface has a color key"]
-    #[doc = ""]
-    #[doc = " It is safe to pass a NULL `surface` here; it will return SDL_FALSE."]
-    #[doc = ""]
-    #[doc = " \\param surface the SDL_Surface structure to query"]
-    #[doc = " \\return SDL_TRUE if the surface has a color key, SDL_FALSE otherwise."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.9."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_SetColorKey"]
-    #[doc = " \\sa SDL_GetColorKey"]
+    #[doc = " Returns whether the surface has a color key\n\n It is safe to pass a NULL `surface` here; it will return SDL_FALSE.\n\n \\param surface the SDL_Surface structure to query\n \\return SDL_TRUE if the surface has a color key, SDL_FALSE otherwise.\n\n \\since This function is available since SDL 2.0.9.\n\n \\sa SDL_SetColorKey\n \\sa SDL_GetColorKey"]
     pub fn SDL_HasColorKey(surface: *mut SDL_Surface) -> SDL_bool;
 }
 extern "C" {
-    #[doc = " Get the color key (transparent pixel) for a surface."]
-    #[doc = ""]
-    #[doc = " The color key is a pixel of the format used by the surface, as generated by"]
-    #[doc = " SDL_MapRGB()."]
-    #[doc = ""]
-    #[doc = " If the surface doesn't have color key enabled this function returns -1."]
-    #[doc = ""]
-    #[doc = " \\param surface the SDL_Surface structure to query"]
-    #[doc = " \\param key a pointer filled in with the transparent pixel"]
-    #[doc = " \\returns 0 on success or a negative error code on failure; call"]
-    #[doc = "          SDL_GetError() for more information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_BlitSurface"]
-    #[doc = " \\sa SDL_SetColorKey"]
+    #[doc = " Get the color key (transparent pixel) for a surface.\n\n The color key is a pixel of the format used by the surface, as generated by\n SDL_MapRGB().\n\n If the surface doesn't have color key enabled this function returns -1.\n\n \\param surface the SDL_Surface structure to query\n \\param key a pointer filled in with the transparent pixel\n \\returns 0 on success or a negative error code on failure; call\n          SDL_GetError() for more information.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_BlitSurface\n \\sa SDL_SetColorKey"]
     pub fn SDL_GetColorKey(surface: *mut SDL_Surface, key: *mut Uint32) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Set an additional color value multiplied into blit operations."]
-    #[doc = ""]
-    #[doc = " When this surface is blitted, during the blit operation each source color"]
-    #[doc = " channel is modulated by the appropriate color value according to the"]
-    #[doc = " following formula:"]
-    #[doc = ""]
-    #[doc = " `srcC = srcC * (color / 255)`"]
-    #[doc = ""]
-    #[doc = " \\param surface the SDL_Surface structure to update"]
-    #[doc = " \\param r the red color value multiplied into blit operations"]
-    #[doc = " \\param g the green color value multiplied into blit operations"]
-    #[doc = " \\param b the blue color value multiplied into blit operations"]
-    #[doc = " \\returns 0 on success or a negative error code on failure; call"]
-    #[doc = "          SDL_GetError() for more information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_GetSurfaceColorMod"]
-    #[doc = " \\sa SDL_SetSurfaceAlphaMod"]
+    #[doc = " Set an additional color value multiplied into blit operations.\n\n When this surface is blitted, during the blit operation each source color\n channel is modulated by the appropriate color value according to the\n following formula:\n\n `srcC = srcC * (color / 255)`\n\n \\param surface the SDL_Surface structure to update\n \\param r the red color value multiplied into blit operations\n \\param g the green color value multiplied into blit operations\n \\param b the blue color value multiplied into blit operations\n \\returns 0 on success or a negative error code on failure; call\n          SDL_GetError() for more information.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_GetSurfaceColorMod\n \\sa SDL_SetSurfaceAlphaMod"]
     pub fn SDL_SetSurfaceColorMod(
         surface: *mut SDL_Surface,
         r: Uint8,
@@ -9574,19 +6401,7 @@ extern "C" {
     ) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Get the additional color value multiplied into blit operations."]
-    #[doc = ""]
-    #[doc = " \\param surface the SDL_Surface structure to query"]
-    #[doc = " \\param r a pointer filled in with the current red color value"]
-    #[doc = " \\param g a pointer filled in with the current green color value"]
-    #[doc = " \\param b a pointer filled in with the current blue color value"]
-    #[doc = " \\returns 0 on success or a negative error code on failure; call"]
-    #[doc = "          SDL_GetError() for more information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_GetSurfaceAlphaMod"]
-    #[doc = " \\sa SDL_SetSurfaceColorMod"]
+    #[doc = " Get the additional color value multiplied into blit operations.\n\n \\param surface the SDL_Surface structure to query\n \\param r a pointer filled in with the current red color value\n \\param g a pointer filled in with the current green color value\n \\param b a pointer filled in with the current blue color value\n \\returns 0 on success or a negative error code on failure; call\n          SDL_GetError() for more information.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_GetSurfaceAlphaMod\n \\sa SDL_SetSurfaceColorMod"]
     pub fn SDL_GetSurfaceColorMod(
         surface: *mut SDL_Surface,
         r: *mut Uint8,
@@ -9595,136 +6410,40 @@ extern "C" {
     ) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Set an additional alpha value used in blit operations."]
-    #[doc = ""]
-    #[doc = " When this surface is blitted, during the blit operation the source alpha"]
-    #[doc = " value is modulated by this alpha value according to the following formula:"]
-    #[doc = ""]
-    #[doc = " `srcA = srcA * (alpha / 255)`"]
-    #[doc = ""]
-    #[doc = " \\param surface the SDL_Surface structure to update"]
-    #[doc = " \\param alpha the alpha value multiplied into blit operations"]
-    #[doc = " \\returns 0 on success or a negative error code on failure; call"]
-    #[doc = "          SDL_GetError() for more information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_GetSurfaceAlphaMod"]
-    #[doc = " \\sa SDL_SetSurfaceColorMod"]
+    #[doc = " Set an additional alpha value used in blit operations.\n\n When this surface is blitted, during the blit operation the source alpha\n value is modulated by this alpha value according to the following formula:\n\n `srcA = srcA * (alpha / 255)`\n\n \\param surface the SDL_Surface structure to update\n \\param alpha the alpha value multiplied into blit operations\n \\returns 0 on success or a negative error code on failure; call\n          SDL_GetError() for more information.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_GetSurfaceAlphaMod\n \\sa SDL_SetSurfaceColorMod"]
     pub fn SDL_SetSurfaceAlphaMod(surface: *mut SDL_Surface, alpha: Uint8) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Get the additional alpha value used in blit operations."]
-    #[doc = ""]
-    #[doc = " \\param surface the SDL_Surface structure to query"]
-    #[doc = " \\param alpha a pointer filled in with the current alpha value"]
-    #[doc = " \\returns 0 on success or a negative error code on failure; call"]
-    #[doc = "          SDL_GetError() for more information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_GetSurfaceColorMod"]
-    #[doc = " \\sa SDL_SetSurfaceAlphaMod"]
+    #[doc = " Get the additional alpha value used in blit operations.\n\n \\param surface the SDL_Surface structure to query\n \\param alpha a pointer filled in with the current alpha value\n \\returns 0 on success or a negative error code on failure; call\n          SDL_GetError() for more information.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_GetSurfaceColorMod\n \\sa SDL_SetSurfaceAlphaMod"]
     pub fn SDL_GetSurfaceAlphaMod(surface: *mut SDL_Surface, alpha: *mut Uint8) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Set the blend mode used for blit operations."]
-    #[doc = ""]
-    #[doc = " To copy a surface to another surface (or texture) without blending with the"]
-    #[doc = " existing data, the blendmode of the SOURCE surface should be set to"]
-    #[doc = " `SDL_BLENDMODE_NONE`."]
-    #[doc = ""]
-    #[doc = " \\param surface the SDL_Surface structure to update"]
-    #[doc = " \\param blendMode the SDL_BlendMode to use for blit blending"]
-    #[doc = " \\returns 0 on success or a negative error code on failure; call"]
-    #[doc = "          SDL_GetError() for more information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_GetSurfaceBlendMode"]
+    #[doc = " Set the blend mode used for blit operations.\n\n To copy a surface to another surface (or texture) without blending with the\n existing data, the blendmode of the SOURCE surface should be set to\n `SDL_BLENDMODE_NONE`.\n\n \\param surface the SDL_Surface structure to update\n \\param blendMode the SDL_BlendMode to use for blit blending\n \\returns 0 on success or a negative error code on failure; call\n          SDL_GetError() for more information.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_GetSurfaceBlendMode"]
     pub fn SDL_SetSurfaceBlendMode(
         surface: *mut SDL_Surface,
         blendMode: SDL_BlendMode,
     ) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Get the blend mode used for blit operations."]
-    #[doc = ""]
-    #[doc = " \\param surface the SDL_Surface structure to query"]
-    #[doc = " \\param blendMode a pointer filled in with the current SDL_BlendMode"]
-    #[doc = " \\returns 0 on success or a negative error code on failure; call"]
-    #[doc = "          SDL_GetError() for more information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_SetSurfaceBlendMode"]
+    #[doc = " Get the blend mode used for blit operations.\n\n \\param surface the SDL_Surface structure to query\n \\param blendMode a pointer filled in with the current SDL_BlendMode\n \\returns 0 on success or a negative error code on failure; call\n          SDL_GetError() for more information.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_SetSurfaceBlendMode"]
     pub fn SDL_GetSurfaceBlendMode(
         surface: *mut SDL_Surface,
         blendMode: *mut SDL_BlendMode,
     ) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Set the clipping rectangle for a surface."]
-    #[doc = ""]
-    #[doc = " When `surface` is the destination of a blit, only the area within the clip"]
-    #[doc = " rectangle is drawn into."]
-    #[doc = ""]
-    #[doc = " Note that blits are automatically clipped to the edges of the source and"]
-    #[doc = " destination surfaces."]
-    #[doc = ""]
-    #[doc = " \\param surface the SDL_Surface structure to be clipped"]
-    #[doc = " \\param rect the SDL_Rect structure representing the clipping rectangle, or"]
-    #[doc = "             NULL to disable clipping"]
-    #[doc = " \\returns SDL_TRUE if the rectangle intersects the surface, otherwise"]
-    #[doc = "          SDL_FALSE and blits will be completely clipped."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_BlitSurface"]
-    #[doc = " \\sa SDL_GetClipRect"]
+    #[doc = " Set the clipping rectangle for a surface.\n\n When `surface` is the destination of a blit, only the area within the clip\n rectangle is drawn into.\n\n Note that blits are automatically clipped to the edges of the source and\n destination surfaces.\n\n \\param surface the SDL_Surface structure to be clipped\n \\param rect the SDL_Rect structure representing the clipping rectangle, or\n             NULL to disable clipping\n \\returns SDL_TRUE if the rectangle intersects the surface, otherwise\n          SDL_FALSE and blits will be completely clipped.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_BlitSurface\n \\sa SDL_GetClipRect"]
     pub fn SDL_SetClipRect(surface: *mut SDL_Surface, rect: *const SDL_Rect) -> SDL_bool;
 }
 extern "C" {
-    #[doc = " Get the clipping rectangle for a surface."]
-    #[doc = ""]
-    #[doc = " When `surface` is the destination of a blit, only the area within the clip"]
-    #[doc = " rectangle is drawn into."]
-    #[doc = ""]
-    #[doc = " \\param surface the SDL_Surface structure representing the surface to be"]
-    #[doc = "                clipped"]
-    #[doc = " \\param rect an SDL_Rect structure filled in with the clipping rectangle for"]
-    #[doc = "             the surface"]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_BlitSurface"]
-    #[doc = " \\sa SDL_SetClipRect"]
+    #[doc = " Get the clipping rectangle for a surface.\n\n When `surface` is the destination of a blit, only the area within the clip\n rectangle is drawn into.\n\n \\param surface the SDL_Surface structure representing the surface to be\n                clipped\n \\param rect an SDL_Rect structure filled in with the clipping rectangle for\n             the surface\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_BlitSurface\n \\sa SDL_SetClipRect"]
     pub fn SDL_GetClipRect(surface: *mut SDL_Surface, rect: *mut SDL_Rect);
 }
 extern "C" {
     pub fn SDL_DuplicateSurface(surface: *mut SDL_Surface) -> *mut SDL_Surface;
 }
 extern "C" {
-    #[doc = " Copy an existing surface to a new surface of the specified format."]
-    #[doc = ""]
-    #[doc = " This function is used to optimize images for faster *repeat* blitting. This"]
-    #[doc = " is accomplished by converting the original and storing the result as a new"]
-    #[doc = " surface. The new, optimized surface can then be used as the source for"]
-    #[doc = " future blits, making them faster."]
-    #[doc = ""]
-    #[doc = " \\param src the existing SDL_Surface structure to convert"]
-    #[doc = " \\param fmt the SDL_PixelFormat structure that the new surface is optimized"]
-    #[doc = "            for"]
-    #[doc = " \\param flags the flags are unused and should be set to 0; this is a"]
-    #[doc = "              leftover from SDL 1.2's API"]
-    #[doc = " \\returns the new SDL_Surface structure that is created or NULL if it fails;"]
-    #[doc = "          call SDL_GetError() for more information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_AllocFormat"]
-    #[doc = " \\sa SDL_ConvertSurfaceFormat"]
-    #[doc = " \\sa SDL_CreateRGBSurface"]
+    #[doc = " Copy an existing surface to a new surface of the specified format.\n\n This function is used to optimize images for faster *repeat* blitting. This\n is accomplished by converting the original and storing the result as a new\n surface. The new, optimized surface can then be used as the source for\n future blits, making them faster.\n\n \\param src the existing SDL_Surface structure to convert\n \\param fmt the SDL_PixelFormat structure that the new surface is optimized\n            for\n \\param flags the flags are unused and should be set to 0; this is a\n              leftover from SDL 1.2's API\n \\returns the new SDL_Surface structure that is created or NULL if it fails;\n          call SDL_GetError() for more information.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_AllocFormat\n \\sa SDL_ConvertSurfaceFormat\n \\sa SDL_CreateRGBSurface"]
     pub fn SDL_ConvertSurface(
         src: *mut SDL_Surface,
         fmt: *const SDL_PixelFormat,
@@ -9732,26 +6451,7 @@ extern "C" {
     ) -> *mut SDL_Surface;
 }
 extern "C" {
-    #[doc = " Copy an existing surface to a new surface of the specified format enum."]
-    #[doc = ""]
-    #[doc = " This function operates just like SDL_ConvertSurface(), but accepts an"]
-    #[doc = " SDL_PixelFormatEnum value instead of an SDL_PixelFormat structure. As such,"]
-    #[doc = " it might be easier to call but it doesn't have access to palette"]
-    #[doc = " information for the destination surface, in case that would be important."]
-    #[doc = ""]
-    #[doc = " \\param src the existing SDL_Surface structure to convert"]
-    #[doc = " \\param pixel_format the SDL_PixelFormatEnum that the new surface is"]
-    #[doc = "                     optimized for"]
-    #[doc = " \\param flags the flags are unused and should be set to 0; this is a"]
-    #[doc = "              leftover from SDL 1.2's API"]
-    #[doc = " \\returns the new SDL_Surface structure that is created or NULL if it fails;"]
-    #[doc = "          call SDL_GetError() for more information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_AllocFormat"]
-    #[doc = " \\sa SDL_ConvertSurface"]
-    #[doc = " \\sa SDL_CreateRGBSurface"]
+    #[doc = " Copy an existing surface to a new surface of the specified format enum.\n\n This function operates just like SDL_ConvertSurface(), but accepts an\n SDL_PixelFormatEnum value instead of an SDL_PixelFormat structure. As such,\n it might be easier to call but it doesn't have access to palette\n information for the destination surface, in case that would be important.\n\n \\param src the existing SDL_Surface structure to convert\n \\param pixel_format the SDL_PixelFormatEnum that the new surface is\n                     optimized for\n \\param flags the flags are unused and should be set to 0; this is a\n              leftover from SDL 1.2's API\n \\returns the new SDL_Surface structure that is created or NULL if it fails;\n          call SDL_GetError() for more information.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_AllocFormat\n \\sa SDL_ConvertSurface\n \\sa SDL_CreateRGBSurface"]
     pub fn SDL_ConvertSurfaceFormat(
         src: *mut SDL_Surface,
         pixel_format: Uint32,
@@ -9759,20 +6459,7 @@ extern "C" {
     ) -> *mut SDL_Surface;
 }
 extern "C" {
-    #[doc = " Copy a block of pixels of one format to another format."]
-    #[doc = ""]
-    #[doc = " \\param width the width of the block to copy, in pixels"]
-    #[doc = " \\param height the height of the block to copy, in pixels"]
-    #[doc = " \\param src_format an SDL_PixelFormatEnum value of the `src` pixels format"]
-    #[doc = " \\param src a pointer to the source pixels"]
-    #[doc = " \\param src_pitch the pitch of the source pixels, in bytes"]
-    #[doc = " \\param dst_format an SDL_PixelFormatEnum value of the `dst` pixels format"]
-    #[doc = " \\param dst a pointer to be filled in with new pixel data"]
-    #[doc = " \\param dst_pitch the pitch of the destination pixels, in bytes"]
-    #[doc = " \\returns 0 on success or a negative error code on failure; call"]
-    #[doc = "          SDL_GetError() for more information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
+    #[doc = " Copy a block of pixels of one format to another format.\n\n \\param width the width of the block to copy, in pixels\n \\param height the height of the block to copy, in pixels\n \\param src_format an SDL_PixelFormatEnum value of the `src` pixels format\n \\param src a pointer to the source pixels\n \\param src_pitch the pitch of the source pixels, in bytes\n \\param dst_format an SDL_PixelFormatEnum value of the `dst` pixels format\n \\param dst a pointer to be filled in with new pixel data\n \\param dst_pitch the pitch of the destination pixels, in bytes\n \\returns 0 on success or a negative error code on failure; call\n          SDL_GetError() for more information.\n\n \\since This function is available since SDL 2.0.0."]
     pub fn SDL_ConvertPixels(
         width: libc::c_int,
         height: libc::c_int,
@@ -9785,24 +6472,7 @@ extern "C" {
     ) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Premultiply the alpha on a block of pixels."]
-    #[doc = ""]
-    #[doc = " This is safe to use with src == dst, but not for other overlapping areas."]
-    #[doc = ""]
-    #[doc = " This function is currently only implemented for SDL_PIXELFORMAT_ARGB8888."]
-    #[doc = ""]
-    #[doc = " \\param width the width of the block to convert, in pixels"]
-    #[doc = " \\param height the height of the block to convert, in pixels"]
-    #[doc = " \\param src_format an SDL_PixelFormatEnum value of the `src` pixels format"]
-    #[doc = " \\param src a pointer to the source pixels"]
-    #[doc = " \\param src_pitch the pitch of the source pixels, in bytes"]
-    #[doc = " \\param dst_format an SDL_PixelFormatEnum value of the `dst` pixels format"]
-    #[doc = " \\param dst a pointer to be filled in with premultiplied pixel data"]
-    #[doc = " \\param dst_pitch the pitch of the destination pixels, in bytes"]
-    #[doc = " \\returns 0 on success or a negative error code on failure; call"]
-    #[doc = "          SDL_GetError() for more information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.18."]
+    #[doc = " Premultiply the alpha on a block of pixels.\n\n This is safe to use with src == dst, but not for other overlapping areas.\n\n This function is currently only implemented for SDL_PIXELFORMAT_ARGB8888.\n\n \\param width the width of the block to convert, in pixels\n \\param height the height of the block to convert, in pixels\n \\param src_format an SDL_PixelFormatEnum value of the `src` pixels format\n \\param src a pointer to the source pixels\n \\param src_pitch the pitch of the source pixels, in bytes\n \\param dst_format an SDL_PixelFormatEnum value of the `dst` pixels format\n \\param dst a pointer to be filled in with premultiplied pixel data\n \\param dst_pitch the pitch of the destination pixels, in bytes\n \\returns 0 on success or a negative error code on failure; call\n          SDL_GetError() for more information.\n\n \\since This function is available since SDL 2.0.18."]
     pub fn SDL_PremultiplyAlpha(
         width: libc::c_int,
         height: libc::c_int,
@@ -9815,52 +6485,12 @@ extern "C" {
     ) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Perform a fast fill of a rectangle with a specific color."]
-    #[doc = ""]
-    #[doc = " `color` should be a pixel of the format used by the surface, and can be"]
-    #[doc = " generated by SDL_MapRGB() or SDL_MapRGBA(). If the color value contains an"]
-    #[doc = " alpha component then the destination is simply filled with that alpha"]
-    #[doc = " information, no blending takes place."]
-    #[doc = ""]
-    #[doc = " If there is a clip rectangle set on the destination (set via"]
-    #[doc = " SDL_SetClipRect()), then this function will fill based on the intersection"]
-    #[doc = " of the clip rectangle and `rect`."]
-    #[doc = ""]
-    #[doc = " \\param dst the SDL_Surface structure that is the drawing target"]
-    #[doc = " \\param rect the SDL_Rect structure representing the rectangle to fill, or"]
-    #[doc = "             NULL to fill the entire surface"]
-    #[doc = " \\param color the color to fill with"]
-    #[doc = " \\returns 0 on success or a negative error code on failure; call"]
-    #[doc = "          SDL_GetError() for more information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_FillRects"]
+    #[doc = " Perform a fast fill of a rectangle with a specific color.\n\n `color` should be a pixel of the format used by the surface, and can be\n generated by SDL_MapRGB() or SDL_MapRGBA(). If the color value contains an\n alpha component then the destination is simply filled with that alpha\n information, no blending takes place.\n\n If there is a clip rectangle set on the destination (set via\n SDL_SetClipRect()), then this function will fill based on the intersection\n of the clip rectangle and `rect`.\n\n \\param dst the SDL_Surface structure that is the drawing target\n \\param rect the SDL_Rect structure representing the rectangle to fill, or\n             NULL to fill the entire surface\n \\param color the color to fill with\n \\returns 0 on success or a negative error code on failure; call\n          SDL_GetError() for more information.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_FillRects"]
     pub fn SDL_FillRect(dst: *mut SDL_Surface, rect: *const SDL_Rect, color: Uint32)
         -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Perform a fast fill of a set of rectangles with a specific color."]
-    #[doc = ""]
-    #[doc = " `color` should be a pixel of the format used by the surface, and can be"]
-    #[doc = " generated by SDL_MapRGB() or SDL_MapRGBA(). If the color value contains an"]
-    #[doc = " alpha component then the destination is simply filled with that alpha"]
-    #[doc = " information, no blending takes place."]
-    #[doc = ""]
-    #[doc = " If there is a clip rectangle set on the destination (set via"]
-    #[doc = " SDL_SetClipRect()), then this function will fill based on the intersection"]
-    #[doc = " of the clip rectangle and `rect`."]
-    #[doc = ""]
-    #[doc = " \\param dst the SDL_Surface structure that is the drawing target"]
-    #[doc = " \\param rects an array of SDL_Rects representing the rectangles to fill."]
-    #[doc = " \\param count the number of rectangles in the array"]
-    #[doc = " \\param color the color to fill with"]
-    #[doc = " \\returns 0 on success or a negative error code on failure; call"]
-    #[doc = "          SDL_GetError() for more information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_FillRect"]
+    #[doc = " Perform a fast fill of a set of rectangles with a specific color.\n\n `color` should be a pixel of the format used by the surface, and can be\n generated by SDL_MapRGB() or SDL_MapRGBA(). If the color value contains an\n alpha component then the destination is simply filled with that alpha\n information, no blending takes place.\n\n If there is a clip rectangle set on the destination (set via\n SDL_SetClipRect()), then this function will fill based on the intersection\n of the clip rectangle and `rect`.\n\n \\param dst the SDL_Surface structure that is the drawing target\n \\param rects an array of SDL_Rects representing the rectangles to fill.\n \\param count the number of rectangles in the array\n \\param color the color to fill with\n \\returns 0 on success or a negative error code on failure; call\n          SDL_GetError() for more information.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_FillRect"]
     pub fn SDL_FillRects(
         dst: *mut SDL_Surface,
         rects: *const SDL_Rect,
@@ -9869,14 +6499,7 @@ extern "C" {
     ) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Perform a fast blit from the source surface to the destination surface."]
-    #[doc = ""]
-    #[doc = " SDL_UpperBlit() has been replaced by SDL_BlitSurface(), which is merely a"]
-    #[doc = " macro for this function with a less confusing name."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_BlitSurface"]
+    #[doc = " Perform a fast blit from the source surface to the destination surface.\n\n SDL_UpperBlit() has been replaced by SDL_BlitSurface(), which is merely a\n macro for this function with a less confusing name.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_BlitSurface"]
     pub fn SDL_UpperBlit(
         src: *mut SDL_Surface,
         srcrect: *const SDL_Rect,
@@ -9885,26 +6508,7 @@ extern "C" {
     ) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Perform low-level surface blitting only."]
-    #[doc = ""]
-    #[doc = " This is a semi-private blit function and it performs low-level surface"]
-    #[doc = " blitting, assuming the input rectangles have already been clipped."]
-    #[doc = ""]
-    #[doc = " Unless you know what you're doing, you should be using SDL_BlitSurface()"]
-    #[doc = " instead."]
-    #[doc = ""]
-    #[doc = " \\param src the SDL_Surface structure to be copied from"]
-    #[doc = " \\param srcrect the SDL_Rect structure representing the rectangle to be"]
-    #[doc = "                copied, or NULL to copy the entire surface"]
-    #[doc = " \\param dst the SDL_Surface structure that is the blit target"]
-    #[doc = " \\param dstrect the SDL_Rect structure representing the rectangle that is"]
-    #[doc = "                copied into"]
-    #[doc = " \\returns 0 on success or a negative error code on failure; call"]
-    #[doc = "          SDL_GetError() for more information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_BlitSurface"]
+    #[doc = " Perform low-level surface blitting only.\n\n This is a semi-private blit function and it performs low-level surface\n blitting, assuming the input rectangles have already been clipped.\n\n Unless you know what you're doing, you should be using SDL_BlitSurface()\n instead.\n\n \\param src the SDL_Surface structure to be copied from\n \\param srcrect the SDL_Rect structure representing the rectangle to be\n                copied, or NULL to copy the entire surface\n \\param dst the SDL_Surface structure that is the blit target\n \\param dstrect the SDL_Rect structure representing the rectangle that is\n                copied into\n \\returns 0 on success or a negative error code on failure; call\n          SDL_GetError() for more information.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_BlitSurface"]
     pub fn SDL_LowerBlit(
         src: *mut SDL_Surface,
         srcrect: *mut SDL_Rect,
@@ -9913,12 +6517,7 @@ extern "C" {
     ) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Perform a fast, low quality, stretch blit between two surfaces of the same"]
-    #[doc = " format."]
-    #[doc = ""]
-    #[doc = " Please use SDL_BlitScaled() instead."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
+    #[doc = " Perform a fast, low quality, stretch blit between two surfaces of the same\n format.\n\n Please use SDL_BlitScaled() instead.\n\n \\since This function is available since SDL 2.0.0."]
     pub fn SDL_SoftStretch(
         src: *mut SDL_Surface,
         srcrect: *const SDL_Rect,
@@ -9927,9 +6526,7 @@ extern "C" {
     ) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Perform bilinear scaling between two surfaces of the same format, 32BPP."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.16."]
+    #[doc = " Perform bilinear scaling between two surfaces of the same format, 32BPP.\n\n \\since This function is available since SDL 2.0.16."]
     pub fn SDL_SoftStretchLinear(
         src: *mut SDL_Surface,
         srcrect: *const SDL_Rect,
@@ -9938,14 +6535,7 @@ extern "C" {
     ) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Perform a scaled surface copy to a destination surface."]
-    #[doc = ""]
-    #[doc = " SDL_UpperBlitScaled() has been replaced by SDL_BlitScaled(), which is"]
-    #[doc = " merely a macro for this function with a less confusing name."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_BlitScaled"]
+    #[doc = " Perform a scaled surface copy to a destination surface.\n\n SDL_UpperBlitScaled() has been replaced by SDL_BlitScaled(), which is\n merely a macro for this function with a less confusing name.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_BlitScaled"]
     pub fn SDL_UpperBlitScaled(
         src: *mut SDL_Surface,
         srcrect: *const SDL_Rect,
@@ -9954,23 +6544,7 @@ extern "C" {
     ) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Perform low-level surface scaled blitting only."]
-    #[doc = ""]
-    #[doc = " This is a semi-private function and it performs low-level surface blitting,"]
-    #[doc = " assuming the input rectangles have already been clipped."]
-    #[doc = ""]
-    #[doc = " \\param src the SDL_Surface structure to be copied from"]
-    #[doc = " \\param srcrect the SDL_Rect structure representing the rectangle to be"]
-    #[doc = "                copied"]
-    #[doc = " \\param dst the SDL_Surface structure that is the blit target"]
-    #[doc = " \\param dstrect the SDL_Rect structure representing the rectangle that is"]
-    #[doc = "                copied into"]
-    #[doc = " \\returns 0 on success or a negative error code on failure; call"]
-    #[doc = "          SDL_GetError() for more information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_BlitScaled"]
+    #[doc = " Perform low-level surface scaled blitting only.\n\n This is a semi-private function and it performs low-level surface blitting,\n assuming the input rectangles have already been clipped.\n\n \\param src the SDL_Surface structure to be copied from\n \\param srcrect the SDL_Rect structure representing the rectangle to be\n                copied\n \\param dst the SDL_Surface structure that is the blit target\n \\param dstrect the SDL_Rect structure representing the rectangle that is\n                copied into\n \\returns 0 on success or a negative error code on failure; call\n          SDL_GetError() for more information.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_BlitScaled"]
     pub fn SDL_LowerBlitScaled(
         src: *mut SDL_Surface,
         srcrect: *mut SDL_Rect,
@@ -9979,36 +6553,21 @@ extern "C" {
     ) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Set the YUV conversion mode"]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.8."]
+    #[doc = " Set the YUV conversion mode\n\n \\since This function is available since SDL 2.0.8."]
     pub fn SDL_SetYUVConversionMode(mode: SDL_YUV_CONVERSION_MODE);
 }
 extern "C" {
-    #[doc = " Get the YUV conversion mode"]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.8."]
+    #[doc = " Get the YUV conversion mode\n\n \\since This function is available since SDL 2.0.8."]
     pub fn SDL_GetYUVConversionMode() -> SDL_YUV_CONVERSION_MODE;
 }
 extern "C" {
-    #[doc = " Get the YUV conversion mode, returning the correct mode for the resolution"]
-    #[doc = " when the current conversion mode is SDL_YUV_CONVERSION_AUTOMATIC"]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.8."]
+    #[doc = " Get the YUV conversion mode, returning the correct mode for the resolution\n when the current conversion mode is SDL_YUV_CONVERSION_AUTOMATIC\n\n \\since This function is available since SDL 2.0.8."]
     pub fn SDL_GetYUVConversionModeForResolution(
         width: libc::c_int,
         height: libc::c_int,
     ) -> SDL_YUV_CONVERSION_MODE;
 }
-#[doc = "  \\brief  The structure that defines a display mode"]
-#[doc = ""]
-#[doc = "  \\sa SDL_GetNumDisplayModes()"]
-#[doc = "  \\sa SDL_GetDisplayMode()"]
-#[doc = "  \\sa SDL_GetDesktopDisplayMode()"]
-#[doc = "  \\sa SDL_GetCurrentDisplayMode()"]
-#[doc = "  \\sa SDL_GetClosestDisplayMode()"]
-#[doc = "  \\sa SDL_SetWindowDisplayMode()"]
-#[doc = "  \\sa SDL_GetWindowDisplayMode()"]
+#[doc = "  \\brief  The structure that defines a display mode\n\n  \\sa SDL_GetNumDisplayModes()\n  \\sa SDL_GetDisplayMode()\n  \\sa SDL_GetDesktopDisplayMode()\n  \\sa SDL_GetCurrentDisplayMode()\n  \\sa SDL_GetClosestDisplayMode()\n  \\sa SDL_SetWindowDisplayMode()\n  \\sa SDL_GetWindowDisplayMode()"]
 #[repr(C)]
 #[derive(Copy, Clone)]
 pub struct SDL_DisplayMode {
@@ -10025,6 +6584,8 @@ pub struct SDL_DisplayMode {
 }
 #[test]
 fn bindgen_test_layout_SDL_DisplayMode() {
+    const UNINIT: ::core::mem::MaybeUninit<SDL_DisplayMode> = ::core::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::core::mem::size_of::<SDL_DisplayMode>(),
         24usize,
@@ -10036,7 +6597,7 @@ fn bindgen_test_layout_SDL_DisplayMode() {
         concat!("Alignment of ", stringify!(SDL_DisplayMode))
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_DisplayMode>())).format as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).format) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -10046,7 +6607,7 @@ fn bindgen_test_layout_SDL_DisplayMode() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_DisplayMode>())).w as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).w) as usize - ptr as usize },
         4usize,
         concat!(
             "Offset of field: ",
@@ -10056,7 +6617,7 @@ fn bindgen_test_layout_SDL_DisplayMode() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_DisplayMode>())).h as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).h) as usize - ptr as usize },
         8usize,
         concat!(
             "Offset of field: ",
@@ -10066,7 +6627,7 @@ fn bindgen_test_layout_SDL_DisplayMode() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_DisplayMode>())).refresh_rate as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).refresh_rate) as usize - ptr as usize },
         12usize,
         concat!(
             "Offset of field: ",
@@ -10076,7 +6637,7 @@ fn bindgen_test_layout_SDL_DisplayMode() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_DisplayMode>())).driverdata as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).driverdata) as usize - ptr as usize },
         16usize,
         concat!(
             "Offset of field: ",
@@ -10095,10 +6656,8 @@ impl SDL_WindowFlags {
     pub const SDL_WINDOW_INPUT_GRABBED: SDL_WindowFlags = SDL_WindowFlags::SDL_WINDOW_MOUSE_GRABBED;
 }
 #[repr(u32)]
-#[doc = "  \\brief The flags on a window"]
-#[doc = ""]
-#[doc = "  \\sa SDL_GetWindowFlags()"]
-#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
+#[doc = "  \\brief The flags on a window\n\n  \\sa SDL_GetWindowFlags()"]
+#[derive(Copy, Clone, Hash, PartialEq, Eq)]
 pub enum SDL_WindowFlags {
     #[doc = "< fullscreen window"]
     SDL_WINDOW_FULLSCREEN = 1,
@@ -10125,9 +6684,7 @@ pub enum SDL_WindowFlags {
     SDL_WINDOW_FULLSCREEN_DESKTOP = 4097,
     #[doc = "< window not created by SDL"]
     SDL_WINDOW_FOREIGN = 2048,
-    #[doc = "< window should be created in high-DPI mode if supported."]
-    #[doc = "On macOS NSHighResolutionCapable must be set true in the"]
-    #[doc = "application's Info.plist for this to have any effect."]
+    #[doc = "< window should be created in high-DPI mode if supported.\nOn macOS NSHighResolutionCapable must be set true in the\napplication's Info.plist for this to have any effect."]
     SDL_WINDOW_ALLOW_HIGHDPI = 8192,
     #[doc = "< window has mouse captured (unrelated to MOUSE_GRABBED)"]
     SDL_WINDOW_MOUSE_CAPTURE = 16384,
@@ -10150,7 +6707,7 @@ pub enum SDL_WindowFlags {
 }
 #[repr(u32)]
 #[doc = "  \\brief Event subtype for window events"]
-#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
+#[derive(Copy, Clone, Hash, PartialEq, Eq)]
 pub enum SDL_WindowEventID {
     #[doc = "< Never used"]
     SDL_WINDOWEVENT_NONE = 0,
@@ -10158,23 +6715,19 @@ pub enum SDL_WindowEventID {
     SDL_WINDOWEVENT_SHOWN = 1,
     #[doc = "< Window has been hidden"]
     SDL_WINDOWEVENT_HIDDEN = 2,
-    #[doc = "< Window has been exposed and should be"]
-    #[doc = "redrawn"]
+    #[doc = "< Window has been exposed and should be\nredrawn"]
     SDL_WINDOWEVENT_EXPOSED = 3,
     #[doc = "< Window has been moved to data1, data2"]
     SDL_WINDOWEVENT_MOVED = 4,
     #[doc = "< Window has been resized to data1xdata2"]
     SDL_WINDOWEVENT_RESIZED = 5,
-    #[doc = "< The window size has changed, either as"]
-    #[doc = "a result of an API call or through the"]
-    #[doc = "system or user changing the window size."]
+    #[doc = "< The window size has changed, either as\na result of an API call or through the\nsystem or user changing the window size."]
     SDL_WINDOWEVENT_SIZE_CHANGED = 6,
     #[doc = "< Window has been minimized"]
     SDL_WINDOWEVENT_MINIMIZED = 7,
     #[doc = "< Window has been maximized"]
     SDL_WINDOWEVENT_MAXIMIZED = 8,
-    #[doc = "< Window has been restored to normal size"]
-    #[doc = "and position"]
+    #[doc = "< Window has been restored to normal size\nand position"]
     SDL_WINDOWEVENT_RESTORED = 9,
     #[doc = "< Window has gained mouse focus"]
     SDL_WINDOWEVENT_ENTER = 10,
@@ -10197,7 +6750,7 @@ pub enum SDL_WindowEventID {
 }
 #[repr(u32)]
 #[doc = "  \\brief Event subtype for display events"]
-#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
+#[derive(Copy, Clone, Hash, PartialEq, Eq)]
 pub enum SDL_DisplayEventID {
     #[doc = "< Never used"]
     SDL_DISPLAYEVENT_NONE = 0,
@@ -10210,7 +6763,7 @@ pub enum SDL_DisplayEventID {
 }
 #[repr(u32)]
 #[doc = "  \\brief Display orientation"]
-#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
+#[derive(Copy, Clone, Hash, PartialEq, Eq)]
 pub enum SDL_DisplayOrientation {
     #[doc = "< The display orientation can't be determined"]
     SDL_ORIENTATION_UNKNOWN = 0,
@@ -10225,7 +6778,7 @@ pub enum SDL_DisplayOrientation {
 }
 #[repr(u32)]
 #[doc = "  \\brief Window flash operation"]
-#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
+#[derive(Copy, Clone, Hash, PartialEq, Eq)]
 pub enum SDL_FlashOperation {
     #[doc = "< Cancel any window flash state"]
     SDL_FLASH_CANCEL = 0,
@@ -10238,7 +6791,7 @@ pub enum SDL_FlashOperation {
 pub type SDL_GLContext = *mut libc::c_void;
 #[repr(u32)]
 #[doc = "  \\brief OpenGL configuration attributes"]
-#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
+#[derive(Copy, Clone, Hash, PartialEq, Eq)]
 pub enum SDL_GLattr {
     SDL_GL_RED_SIZE = 0,
     SDL_GL_GREEN_SIZE = 1,
@@ -10267,9 +6820,10 @@ pub enum SDL_GLattr {
     SDL_GL_CONTEXT_RELEASE_BEHAVIOR = 24,
     SDL_GL_CONTEXT_RESET_NOTIFICATION = 25,
     SDL_GL_CONTEXT_NO_ERROR = 26,
+    SDL_GL_FLOATBUFFERS = 27,
 }
 #[repr(u32)]
-#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
+#[derive(Copy, Clone, Hash, PartialEq, Eq)]
 pub enum SDL_GLprofile {
     SDL_GL_CONTEXT_PROFILE_CORE = 1,
     SDL_GL_CONTEXT_PROFILE_COMPATIBILITY = 2,
@@ -10277,7 +6831,7 @@ pub enum SDL_GLprofile {
     SDL_GL_CONTEXT_PROFILE_ES = 4,
 }
 #[repr(u32)]
-#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
+#[derive(Copy, Clone, Hash, PartialEq, Eq)]
 pub enum SDL_GLcontextFlag {
     SDL_GL_CONTEXT_DEBUG_FLAG = 1,
     SDL_GL_CONTEXT_FORWARD_COMPATIBLE_FLAG = 2,
@@ -10285,189 +6839,58 @@ pub enum SDL_GLcontextFlag {
     SDL_GL_CONTEXT_RESET_ISOLATION_FLAG = 8,
 }
 #[repr(u32)]
-#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
+#[derive(Copy, Clone, Hash, PartialEq, Eq)]
 pub enum SDL_GLcontextReleaseFlag {
     SDL_GL_CONTEXT_RELEASE_BEHAVIOR_NONE = 0,
     SDL_GL_CONTEXT_RELEASE_BEHAVIOR_FLUSH = 1,
 }
 #[repr(u32)]
-#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
+#[derive(Copy, Clone, Hash, PartialEq, Eq)]
 pub enum SDL_GLContextResetNotification {
     SDL_GL_CONTEXT_RESET_NO_NOTIFICATION = 0,
     SDL_GL_CONTEXT_RESET_LOSE_CONTEXT = 1,
 }
 extern "C" {
-    #[doc = " Get the number of video drivers compiled into SDL."]
-    #[doc = ""]
-    #[doc = " \\returns a number >= 1 on success or a negative error code on failure; call"]
-    #[doc = "          SDL_GetError() for more information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_GetVideoDriver"]
+    #[doc = " Get the number of video drivers compiled into SDL.\n\n \\returns a number >= 1 on success or a negative error code on failure; call\n          SDL_GetError() for more information.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_GetVideoDriver"]
     pub fn SDL_GetNumVideoDrivers() -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Get the name of a built in video driver."]
-    #[doc = ""]
-    #[doc = " The video drivers are presented in the order in which they are normally"]
-    #[doc = " checked during initialization."]
-    #[doc = ""]
-    #[doc = " \\param index the index of a video driver"]
-    #[doc = " \\returns the name of the video driver with the given **index**."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_GetNumVideoDrivers"]
+    #[doc = " Get the name of a built in video driver.\n\n The video drivers are presented in the order in which they are normally\n checked during initialization.\n\n \\param index the index of a video driver\n \\returns the name of the video driver with the given **index**.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_GetNumVideoDrivers"]
     pub fn SDL_GetVideoDriver(index: libc::c_int) -> *const libc::c_char;
 }
 extern "C" {
-    #[doc = " Initialize the video subsystem, optionally specifying a video driver."]
-    #[doc = ""]
-    #[doc = " This function initializes the video subsystem, setting up a connection to"]
-    #[doc = " the window manager, etc, and determines the available display modes and"]
-    #[doc = " pixel formats, but does not initialize a window or graphics mode."]
-    #[doc = ""]
-    #[doc = " If you use this function and you haven't used the SDL_INIT_VIDEO flag with"]
-    #[doc = " either SDL_Init() or SDL_InitSubSystem(), you should call SDL_VideoQuit()"]
-    #[doc = " before calling SDL_Quit()."]
-    #[doc = ""]
-    #[doc = " It is safe to call this function multiple times. SDL_VideoInit() will call"]
-    #[doc = " SDL_VideoQuit() itself if the video subsystem has already been initialized."]
-    #[doc = ""]
-    #[doc = " You can use SDL_GetNumVideoDrivers() and SDL_GetVideoDriver() to find a"]
-    #[doc = " specific `driver_name`."]
-    #[doc = ""]
-    #[doc = " \\param driver_name the name of a video driver to initialize, or NULL for"]
-    #[doc = "                    the default driver"]
-    #[doc = " \\returns 0 on success or a negative error code on failure; call"]
-    #[doc = "          SDL_GetError() for more information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_GetNumVideoDrivers"]
-    #[doc = " \\sa SDL_GetVideoDriver"]
-    #[doc = " \\sa SDL_InitSubSystem"]
-    #[doc = " \\sa SDL_VideoQuit"]
+    #[doc = " Initialize the video subsystem, optionally specifying a video driver.\n\n This function initializes the video subsystem, setting up a connection to\n the window manager, etc, and determines the available display modes and\n pixel formats, but does not initialize a window or graphics mode.\n\n If you use this function and you haven't used the SDL_INIT_VIDEO flag with\n either SDL_Init() or SDL_InitSubSystem(), you should call SDL_VideoQuit()\n before calling SDL_Quit().\n\n It is safe to call this function multiple times. SDL_VideoInit() will call\n SDL_VideoQuit() itself if the video subsystem has already been initialized.\n\n You can use SDL_GetNumVideoDrivers() and SDL_GetVideoDriver() to find a\n specific `driver_name`.\n\n \\param driver_name the name of a video driver to initialize, or NULL for\n                    the default driver\n \\returns 0 on success or a negative error code on failure; call\n          SDL_GetError() for more information.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_GetNumVideoDrivers\n \\sa SDL_GetVideoDriver\n \\sa SDL_InitSubSystem\n \\sa SDL_VideoQuit"]
     pub fn SDL_VideoInit(driver_name: *const libc::c_char) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Shut down the video subsystem, if initialized with SDL_VideoInit()."]
-    #[doc = ""]
-    #[doc = " This function closes all windows, and restores the original video mode."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_VideoInit"]
+    #[doc = " Shut down the video subsystem, if initialized with SDL_VideoInit().\n\n This function closes all windows, and restores the original video mode.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_VideoInit"]
     pub fn SDL_VideoQuit();
 }
 extern "C" {
-    #[doc = " Get the name of the currently initialized video driver."]
-    #[doc = ""]
-    #[doc = " \\returns the name of the current video driver or NULL if no driver has been"]
-    #[doc = "          initialized."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_GetNumVideoDrivers"]
-    #[doc = " \\sa SDL_GetVideoDriver"]
+    #[doc = " Get the name of the currently initialized video driver.\n\n \\returns the name of the current video driver or NULL if no driver has been\n          initialized.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_GetNumVideoDrivers\n \\sa SDL_GetVideoDriver"]
     pub fn SDL_GetCurrentVideoDriver() -> *const libc::c_char;
 }
 extern "C" {
-    #[doc = " Get the number of available video displays."]
-    #[doc = ""]
-    #[doc = " \\returns a number >= 1 or a negative error code on failure; call"]
-    #[doc = "          SDL_GetError() for more information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_GetDisplayBounds"]
+    #[doc = " Get the number of available video displays.\n\n \\returns a number >= 1 or a negative error code on failure; call\n          SDL_GetError() for more information.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_GetDisplayBounds"]
     pub fn SDL_GetNumVideoDisplays() -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Get the name of a display in UTF-8 encoding."]
-    #[doc = ""]
-    #[doc = " \\param displayIndex the index of display from which the name should be"]
-    #[doc = "                     queried"]
-    #[doc = " \\returns the name of a display or NULL for an invalid display index or"]
-    #[doc = "          failure; call SDL_GetError() for more information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_GetNumVideoDisplays"]
+    #[doc = " Get the name of a display in UTF-8 encoding.\n\n \\param displayIndex the index of display from which the name should be\n                     queried\n \\returns the name of a display or NULL for an invalid display index or\n          failure; call SDL_GetError() for more information.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_GetNumVideoDisplays"]
     pub fn SDL_GetDisplayName(displayIndex: libc::c_int) -> *const libc::c_char;
 }
 extern "C" {
-    #[doc = " Get the desktop area represented by a display."]
-    #[doc = ""]
-    #[doc = " The primary display (`displayIndex` zero) is always located at 0,0."]
-    #[doc = ""]
-    #[doc = " \\param displayIndex the index of the display to query"]
-    #[doc = " \\param rect the SDL_Rect structure filled in with the display bounds"]
-    #[doc = " \\returns 0 on success or a negative error code on failure; call"]
-    #[doc = "          SDL_GetError() for more information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_GetNumVideoDisplays"]
+    #[doc = " Get the desktop area represented by a display.\n\n The primary display (`displayIndex` zero) is always located at 0,0.\n\n \\param displayIndex the index of the display to query\n \\param rect the SDL_Rect structure filled in with the display bounds\n \\returns 0 on success or a negative error code on failure; call\n          SDL_GetError() for more information.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_GetNumVideoDisplays"]
     pub fn SDL_GetDisplayBounds(displayIndex: libc::c_int, rect: *mut SDL_Rect) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Get the usable desktop area represented by a display."]
-    #[doc = ""]
-    #[doc = " The primary display (`displayIndex` zero) is always located at 0,0."]
-    #[doc = ""]
-    #[doc = " This is the same area as SDL_GetDisplayBounds() reports, but with portions"]
-    #[doc = " reserved by the system removed. For example, on Apple's macOS, this"]
-    #[doc = " subtracts the area occupied by the menu bar and dock."]
-    #[doc = ""]
-    #[doc = " Setting a window to be fullscreen generally bypasses these unusable areas,"]
-    #[doc = " so these are good guidelines for the maximum space available to a"]
-    #[doc = " non-fullscreen window."]
-    #[doc = ""]
-    #[doc = " The parameter `rect` is ignored if it is NULL."]
-    #[doc = ""]
-    #[doc = " This function also returns -1 if the parameter `displayIndex` is out of"]
-    #[doc = " range."]
-    #[doc = ""]
-    #[doc = " \\param displayIndex the index of the display to query the usable bounds"]
-    #[doc = "                     from"]
-    #[doc = " \\param rect the SDL_Rect structure filled in with the display bounds"]
-    #[doc = " \\returns 0 on success or a negative error code on failure; call"]
-    #[doc = "          SDL_GetError() for more information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.5."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_GetDisplayBounds"]
-    #[doc = " \\sa SDL_GetNumVideoDisplays"]
+    #[doc = " Get the usable desktop area represented by a display.\n\n The primary display (`displayIndex` zero) is always located at 0,0.\n\n This is the same area as SDL_GetDisplayBounds() reports, but with portions\n reserved by the system removed. For example, on Apple's macOS, this\n subtracts the area occupied by the menu bar and dock.\n\n Setting a window to be fullscreen generally bypasses these unusable areas,\n so these are good guidelines for the maximum space available to a\n non-fullscreen window.\n\n The parameter `rect` is ignored if it is NULL.\n\n This function also returns -1 if the parameter `displayIndex` is out of\n range.\n\n \\param displayIndex the index of the display to query the usable bounds\n                     from\n \\param rect the SDL_Rect structure filled in with the display bounds\n \\returns 0 on success or a negative error code on failure; call\n          SDL_GetError() for more information.\n\n \\since This function is available since SDL 2.0.5.\n\n \\sa SDL_GetDisplayBounds\n \\sa SDL_GetNumVideoDisplays"]
     pub fn SDL_GetDisplayUsableBounds(
         displayIndex: libc::c_int,
         rect: *mut SDL_Rect,
     ) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Get the dots/pixels-per-inch for a display."]
-    #[doc = ""]
-    #[doc = " Diagonal, horizontal and vertical DPI can all be optionally returned if the"]
-    #[doc = " appropriate parameter is non-NULL."]
-    #[doc = ""]
-    #[doc = " A failure of this function usually means that either no DPI information is"]
-    #[doc = " available or the `displayIndex` is out of range."]
-    #[doc = ""]
-    #[doc = " \\param displayIndex the index of the display from which DPI information"]
-    #[doc = "                     should be queried"]
-    #[doc = " \\param ddpi a pointer filled in with the diagonal DPI of the display; may"]
-    #[doc = "             be NULL"]
-    #[doc = " \\param hdpi a pointer filled in with the horizontal DPI of the display; may"]
-    #[doc = "             be NULL"]
-    #[doc = " \\param vdpi a pointer filled in with the vertical DPI of the display; may"]
-    #[doc = "             be NULL"]
-    #[doc = " \\returns 0 on success or a negative error code on failure; call"]
-    #[doc = "          SDL_GetError() for more information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.4."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_GetNumVideoDisplays"]
+    #[doc = " Get the dots/pixels-per-inch for a display.\n\n Diagonal, horizontal and vertical DPI can all be optionally returned if the\n appropriate parameter is non-NULL.\n\n A failure of this function usually means that either no DPI information is\n available or the `displayIndex` is out of range.\n\n **WARNING**: This reports the DPI that the hardware reports, and it is not\n always reliable! It is almost always better to use SDL_GetWindowSize() to\n find the window size, which might be in logical points instead of pixels,\n and then SDL_GL_GetDrawableSize(), SDL_Vulkan_GetDrawableSize(),\n SDL_Metal_GetDrawableSize(), or SDL_GetRendererOutputSize(), and compare\n the two values to get an actual scaling value between the two. We will be\n rethinking how high-dpi details should be managed in SDL3 to make things\n more consistent, reliable, and clear.\n\n \\param displayIndex the index of the display from which DPI information\n                     should be queried\n \\param ddpi a pointer filled in with the diagonal DPI of the display; may\n             be NULL\n \\param hdpi a pointer filled in with the horizontal DPI of the display; may\n             be NULL\n \\param vdpi a pointer filled in with the vertical DPI of the display; may\n             be NULL\n \\returns 0 on success or a negative error code on failure; call\n          SDL_GetError() for more information.\n\n \\since This function is available since SDL 2.0.4.\n\n \\sa SDL_GetNumVideoDisplays"]
     pub fn SDL_GetDisplayDPI(
         displayIndex: libc::c_int,
         ddpi: *mut f32,
@@ -10476,54 +6899,15 @@ extern "C" {
     ) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Get the orientation of a display."]
-    #[doc = ""]
-    #[doc = " \\param displayIndex the index of the display to query"]
-    #[doc = " \\returns The SDL_DisplayOrientation enum value of the display, or"]
-    #[doc = "          `SDL_ORIENTATION_UNKNOWN` if it isn't available."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.9."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_GetNumVideoDisplays"]
+    #[doc = " Get the orientation of a display.\n\n \\param displayIndex the index of the display to query\n \\returns The SDL_DisplayOrientation enum value of the display, or\n          `SDL_ORIENTATION_UNKNOWN` if it isn't available.\n\n \\since This function is available since SDL 2.0.9.\n\n \\sa SDL_GetNumVideoDisplays"]
     pub fn SDL_GetDisplayOrientation(displayIndex: libc::c_int) -> SDL_DisplayOrientation;
 }
 extern "C" {
-    #[doc = " Get the number of available display modes."]
-    #[doc = ""]
-    #[doc = " The `displayIndex` needs to be in the range from 0 to"]
-    #[doc = " SDL_GetNumVideoDisplays() - 1."]
-    #[doc = ""]
-    #[doc = " \\param displayIndex the index of the display to query"]
-    #[doc = " \\returns a number >= 1 on success or a negative error code on failure; call"]
-    #[doc = "          SDL_GetError() for more information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_GetDisplayMode"]
-    #[doc = " \\sa SDL_GetNumVideoDisplays"]
+    #[doc = " Get the number of available display modes.\n\n The `displayIndex` needs to be in the range from 0 to\n SDL_GetNumVideoDisplays() - 1.\n\n \\param displayIndex the index of the display to query\n \\returns a number >= 1 on success or a negative error code on failure; call\n          SDL_GetError() for more information.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_GetDisplayMode\n \\sa SDL_GetNumVideoDisplays"]
     pub fn SDL_GetNumDisplayModes(displayIndex: libc::c_int) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Get information about a specific display mode."]
-    #[doc = ""]
-    #[doc = " The display modes are sorted in this priority:"]
-    #[doc = ""]
-    #[doc = " - width -> largest to smallest"]
-    #[doc = " - height -> largest to smallest"]
-    #[doc = " - bits per pixel -> more colors to fewer colors"]
-    #[doc = " - packed pixel layout -> largest to smallest"]
-    #[doc = " - refresh rate -> highest to lowest"]
-    #[doc = ""]
-    #[doc = " \\param displayIndex the index of the display to query"]
-    #[doc = " \\param modeIndex the index of the display mode to query"]
-    #[doc = " \\param mode an SDL_DisplayMode structure filled in with the mode at"]
-    #[doc = "             `modeIndex`"]
-    #[doc = " \\returns 0 on success or a negative error code on failure; call"]
-    #[doc = "          SDL_GetError() for more information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_GetNumDisplayModes"]
+    #[doc = " Get information about a specific display mode.\n\n The display modes are sorted in this priority:\n\n - width -> largest to smallest\n - height -> largest to smallest\n - bits per pixel -> more colors to fewer colors\n - packed pixel layout -> largest to smallest\n - refresh rate -> highest to lowest\n\n \\param displayIndex the index of the display to query\n \\param modeIndex the index of the display mode to query\n \\param mode an SDL_DisplayMode structure filled in with the mode at\n             `modeIndex`\n \\returns 0 on success or a negative error code on failure; call\n          SDL_GetError() for more information.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_GetNumDisplayModes"]
     pub fn SDL_GetDisplayMode(
         displayIndex: libc::c_int,
         modeIndex: libc::c_int,
@@ -10531,76 +6915,21 @@ extern "C" {
     ) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Get information about the desktop's display mode."]
-    #[doc = ""]
-    #[doc = " There's a difference between this function and SDL_GetCurrentDisplayMode()"]
-    #[doc = " when SDL runs fullscreen and has changed the resolution. In that case this"]
-    #[doc = " function will return the previous native display mode, and not the current"]
-    #[doc = " display mode."]
-    #[doc = ""]
-    #[doc = " \\param displayIndex the index of the display to query"]
-    #[doc = " \\param mode an SDL_DisplayMode structure filled in with the current display"]
-    #[doc = "             mode"]
-    #[doc = " \\returns 0 on success or a negative error code on failure; call"]
-    #[doc = "          SDL_GetError() for more information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_GetCurrentDisplayMode"]
-    #[doc = " \\sa SDL_GetDisplayMode"]
-    #[doc = " \\sa SDL_SetWindowDisplayMode"]
+    #[doc = " Get information about the desktop's display mode.\n\n There's a difference between this function and SDL_GetCurrentDisplayMode()\n when SDL runs fullscreen and has changed the resolution. In that case this\n function will return the previous native display mode, and not the current\n display mode.\n\n \\param displayIndex the index of the display to query\n \\param mode an SDL_DisplayMode structure filled in with the current display\n             mode\n \\returns 0 on success or a negative error code on failure; call\n          SDL_GetError() for more information.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_GetCurrentDisplayMode\n \\sa SDL_GetDisplayMode\n \\sa SDL_SetWindowDisplayMode"]
     pub fn SDL_GetDesktopDisplayMode(
         displayIndex: libc::c_int,
         mode: *mut SDL_DisplayMode,
     ) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Get information about the current display mode."]
-    #[doc = ""]
-    #[doc = " There's a difference between this function and SDL_GetDesktopDisplayMode()"]
-    #[doc = " when SDL runs fullscreen and has changed the resolution. In that case this"]
-    #[doc = " function will return the current display mode, and not the previous native"]
-    #[doc = " display mode."]
-    #[doc = ""]
-    #[doc = " \\param displayIndex the index of the display to query"]
-    #[doc = " \\param mode an SDL_DisplayMode structure filled in with the current display"]
-    #[doc = "             mode"]
-    #[doc = " \\returns 0 on success or a negative error code on failure; call"]
-    #[doc = "          SDL_GetError() for more information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_GetDesktopDisplayMode"]
-    #[doc = " \\sa SDL_GetDisplayMode"]
-    #[doc = " \\sa SDL_GetNumVideoDisplays"]
-    #[doc = " \\sa SDL_SetWindowDisplayMode"]
+    #[doc = " Get information about the current display mode.\n\n There's a difference between this function and SDL_GetDesktopDisplayMode()\n when SDL runs fullscreen and has changed the resolution. In that case this\n function will return the current display mode, and not the previous native\n display mode.\n\n \\param displayIndex the index of the display to query\n \\param mode an SDL_DisplayMode structure filled in with the current display\n             mode\n \\returns 0 on success or a negative error code on failure; call\n          SDL_GetError() for more information.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_GetDesktopDisplayMode\n \\sa SDL_GetDisplayMode\n \\sa SDL_GetNumVideoDisplays\n \\sa SDL_SetWindowDisplayMode"]
     pub fn SDL_GetCurrentDisplayMode(
         displayIndex: libc::c_int,
         mode: *mut SDL_DisplayMode,
     ) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Get the closest match to the requested display mode."]
-    #[doc = ""]
-    #[doc = " The available display modes are scanned and `closest` is filled in with the"]
-    #[doc = " closest mode matching the requested mode and returned. The mode format and"]
-    #[doc = " refresh rate default to the desktop mode if they are set to 0. The modes"]
-    #[doc = " are scanned with size being first priority, format being second priority,"]
-    #[doc = " and finally checking the refresh rate. If all the available modes are too"]
-    #[doc = " small, then NULL is returned."]
-    #[doc = ""]
-    #[doc = " \\param displayIndex the index of the display to query"]
-    #[doc = " \\param mode an SDL_DisplayMode structure containing the desired display"]
-    #[doc = "             mode"]
-    #[doc = " \\param closest an SDL_DisplayMode structure filled in with the closest"]
-    #[doc = "                match of the available display modes"]
-    #[doc = " \\returns the passed in value `closest` or NULL if no matching video mode"]
-    #[doc = "          was available; call SDL_GetError() for more information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_GetDisplayMode"]
-    #[doc = " \\sa SDL_GetNumDisplayModes"]
+    #[doc = " Get the closest match to the requested display mode.\n\n The available display modes are scanned and `closest` is filled in with the\n closest mode matching the requested mode and returned. The mode format and\n refresh rate default to the desktop mode if they are set to 0. The modes\n are scanned with size being first priority, format being second priority,\n and finally checking the refresh rate. If all the available modes are too\n small, then NULL is returned.\n\n \\param displayIndex the index of the display to query\n \\param mode an SDL_DisplayMode structure containing the desired display\n             mode\n \\param closest an SDL_DisplayMode structure filled in with the closest\n                match of the available display modes\n \\returns the passed in value `closest` or NULL if no matching video mode\n          was available; call SDL_GetError() for more information.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_GetDisplayMode\n \\sa SDL_GetNumDisplayModes"]
     pub fn SDL_GetClosestDisplayMode(
         displayIndex: libc::c_int,
         mode: *const SDL_DisplayMode,
@@ -10608,152 +6937,41 @@ extern "C" {
     ) -> *mut SDL_DisplayMode;
 }
 extern "C" {
-    #[doc = " Get the index of the display associated with a window."]
-    #[doc = ""]
-    #[doc = " \\param window the window to query"]
-    #[doc = " \\returns the index of the display containing the center of the window on"]
-    #[doc = "          success or a negative error code on failure; call SDL_GetError()"]
-    #[doc = "          for more information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_GetDisplayBounds"]
-    #[doc = " \\sa SDL_GetNumVideoDisplays"]
+    #[doc = " Get the index of the display containing a point\n\n \\param point the point to query\n \\returns the index of the display containing the point or a negative error\n          code on failure; call SDL_GetError() for more information.\n\n \\since This function is available since SDL 2.24.0.\n\n \\sa SDL_GetDisplayBounds\n \\sa SDL_GetNumVideoDisplays"]
+    pub fn SDL_GetPointDisplayIndex(point: *const SDL_Point) -> libc::c_int;
+}
+extern "C" {
+    #[doc = " Get the index of the display primarily containing a rect\n\n \\param rect the rect to query\n \\returns the index of the display entirely containing the rect or closest\n          to the center of the rect on success or a negative error code on\n          failure; call SDL_GetError() for more information.\n\n \\since This function is available since SDL 2.24.0.\n\n \\sa SDL_GetDisplayBounds\n \\sa SDL_GetNumVideoDisplays"]
+    pub fn SDL_GetRectDisplayIndex(rect: *const SDL_Rect) -> libc::c_int;
+}
+extern "C" {
+    #[doc = " Get the index of the display associated with a window.\n\n \\param window the window to query\n \\returns the index of the display containing the center of the window on\n          success or a negative error code on failure; call SDL_GetError()\n          for more information.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_GetDisplayBounds\n \\sa SDL_GetNumVideoDisplays"]
     pub fn SDL_GetWindowDisplayIndex(window: *mut SDL_Window) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Set the display mode to use when a window is visible at fullscreen."]
-    #[doc = ""]
-    #[doc = " This only affects the display mode used when the window is fullscreen. To"]
-    #[doc = " change the window size when the window is not fullscreen, use"]
-    #[doc = " SDL_SetWindowSize()."]
-    #[doc = ""]
-    #[doc = " \\param window the window to affect"]
-    #[doc = " \\param mode the SDL_DisplayMode structure representing the mode to use, or"]
-    #[doc = "             NULL to use the window's dimensions and the desktop's format"]
-    #[doc = "             and refresh rate"]
-    #[doc = " \\returns 0 on success or a negative error code on failure; call"]
-    #[doc = "          SDL_GetError() for more information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_GetWindowDisplayMode"]
-    #[doc = " \\sa SDL_SetWindowFullscreen"]
+    #[doc = " Set the display mode to use when a window is visible at fullscreen.\n\n This only affects the display mode used when the window is fullscreen. To\n change the window size when the window is not fullscreen, use\n SDL_SetWindowSize().\n\n \\param window the window to affect\n \\param mode the SDL_DisplayMode structure representing the mode to use, or\n             NULL to use the window's dimensions and the desktop's format\n             and refresh rate\n \\returns 0 on success or a negative error code on failure; call\n          SDL_GetError() for more information.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_GetWindowDisplayMode\n \\sa SDL_SetWindowFullscreen"]
     pub fn SDL_SetWindowDisplayMode(
         window: *mut SDL_Window,
         mode: *const SDL_DisplayMode,
     ) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Query the display mode to use when a window is visible at fullscreen."]
-    #[doc = ""]
-    #[doc = " \\param window the window to query"]
-    #[doc = " \\param mode an SDL_DisplayMode structure filled in with the fullscreen"]
-    #[doc = "             display mode"]
-    #[doc = " \\returns 0 on success or a negative error code on failure; call"]
-    #[doc = "          SDL_GetError() for more information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_SetWindowDisplayMode"]
-    #[doc = " \\sa SDL_SetWindowFullscreen"]
+    #[doc = " Query the display mode to use when a window is visible at fullscreen.\n\n \\param window the window to query\n \\param mode an SDL_DisplayMode structure filled in with the fullscreen\n             display mode\n \\returns 0 on success or a negative error code on failure; call\n          SDL_GetError() for more information.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_SetWindowDisplayMode\n \\sa SDL_SetWindowFullscreen"]
     pub fn SDL_GetWindowDisplayMode(
         window: *mut SDL_Window,
         mode: *mut SDL_DisplayMode,
     ) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Get the raw ICC profile data for the screen the window is currently on."]
-    #[doc = ""]
-    #[doc = " Data returned should be freed with SDL_free."]
-    #[doc = ""]
-    #[doc = " \\param window the window to query"]
-    #[doc = " \\param size the size of the ICC profile"]
-    #[doc = " \\returns the raw ICC profile data on success or NULL on failure; call"]
-    #[doc = "          SDL_GetError() for more information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.18."]
-    pub fn SDL_GetWindowICCProfile(window: *mut SDL_Window, size: *mut size_t)
-        -> *mut libc::c_void;
-}
-extern "C" {
-    #[doc = " Get the pixel format associated with the window."]
-    #[doc = ""]
-    #[doc = " \\param window the window to query"]
-    #[doc = " \\returns the pixel format of the window on success or"]
-    #[doc = "          SDL_PIXELFORMAT_UNKNOWN on failure; call SDL_GetError() for more"]
-    #[doc = "          information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
+    #[doc = " Get the raw ICC profile data for the screen the window is currently on.\n\n Data returned should be freed with SDL_free.\n\n \\param window the window to query\n \\param size the size of the ICC profile\n \\returns the raw ICC profile data on success or NULL on failure; call\n          SDL_GetError() for more information.\n\n \\since This function is available since SDL 2.0.18."]
+    pub fn SDL_GetWindowICCProfile(window: *mut SDL_Window, size: *mut usize) -> *mut libc::c_void;
+}
+extern "C" {
+    #[doc = " Get the pixel format associated with the window.\n\n \\param window the window to query\n \\returns the pixel format of the window on success or\n          SDL_PIXELFORMAT_UNKNOWN on failure; call SDL_GetError() for more\n          information.\n\n \\since This function is available since SDL 2.0.0."]
     pub fn SDL_GetWindowPixelFormat(window: *mut SDL_Window) -> Uint32;
 }
 extern "C" {
-    #[doc = " Create a window with the specified position, dimensions, and flags."]
-    #[doc = ""]
-    #[doc = " `flags` may be any of the following OR'd together:"]
-    #[doc = ""]
-    #[doc = " - `SDL_WINDOW_FULLSCREEN`: fullscreen window"]
-    #[doc = " - `SDL_WINDOW_FULLSCREEN_DESKTOP`: fullscreen window at desktop resolution"]
-    #[doc = " - `SDL_WINDOW_OPENGL`: window usable with an OpenGL context"]
-    #[doc = " - `SDL_WINDOW_VULKAN`: window usable with a Vulkan instance"]
-    #[doc = " - `SDL_WINDOW_METAL`: window usable with a Metal instance"]
-    #[doc = " - `SDL_WINDOW_HIDDEN`: window is not visible"]
-    #[doc = " - `SDL_WINDOW_BORDERLESS`: no window decoration"]
-    #[doc = " - `SDL_WINDOW_RESIZABLE`: window can be resized"]
-    #[doc = " - `SDL_WINDOW_MINIMIZED`: window is minimized"]
-    #[doc = " - `SDL_WINDOW_MAXIMIZED`: window is maximized"]
-    #[doc = " - `SDL_WINDOW_INPUT_GRABBED`: window has grabbed input focus"]
-    #[doc = " - `SDL_WINDOW_ALLOW_HIGHDPI`: window should be created in high-DPI mode if"]
-    #[doc = "   supported (>= SDL 2.0.1)"]
-    #[doc = ""]
-    #[doc = " `SDL_WINDOW_SHOWN` is ignored by SDL_CreateWindow(). The SDL_Window is"]
-    #[doc = " implicitly shown if SDL_WINDOW_HIDDEN is not set. `SDL_WINDOW_SHOWN` may be"]
-    #[doc = " queried later using SDL_GetWindowFlags()."]
-    #[doc = ""]
-    #[doc = " On Apple's macOS, you **must** set the NSHighResolutionCapable Info.plist"]
-    #[doc = " property to YES, otherwise you will not receive a High-DPI OpenGL canvas."]
-    #[doc = ""]
-    #[doc = " If the window is created with the `SDL_WINDOW_ALLOW_HIGHDPI` flag, its size"]
-    #[doc = " in pixels may differ from its size in screen coordinates on platforms with"]
-    #[doc = " high-DPI support (e.g. iOS and macOS). Use SDL_GetWindowSize() to query the"]
-    #[doc = " client area's size in screen coordinates, and SDL_GL_GetDrawableSize() or"]
-    #[doc = " SDL_GetRendererOutputSize() to query the drawable size in pixels."]
-    #[doc = ""]
-    #[doc = " If the window is set fullscreen, the width and height parameters `w` and"]
-    #[doc = " `h` will not be used. However, invalid size parameters (e.g. too large) may"]
-    #[doc = " still fail. Window size is actually limited to 16384 x 16384 for all"]
-    #[doc = " platforms at window creation."]
-    #[doc = ""]
-    #[doc = " If the window is created with any of the SDL_WINDOW_OPENGL or"]
-    #[doc = " SDL_WINDOW_VULKAN flags, then the corresponding LoadLibrary function"]
-    #[doc = " (SDL_GL_LoadLibrary or SDL_Vulkan_LoadLibrary) is called and the"]
-    #[doc = " corresponding UnloadLibrary function is called by SDL_DestroyWindow()."]
-    #[doc = ""]
-    #[doc = " If SDL_WINDOW_VULKAN is specified and there isn't a working Vulkan driver,"]
-    #[doc = " SDL_CreateWindow() will fail because SDL_Vulkan_LoadLibrary() will fail."]
-    #[doc = ""]
-    #[doc = " If SDL_WINDOW_METAL is specified on an OS that does not support Metal,"]
-    #[doc = " SDL_CreateWindow() will fail."]
-    #[doc = ""]
-    #[doc = " On non-Apple devices, SDL requires you to either not link to the Vulkan"]
-    #[doc = " loader or link to a dynamic library version. This limitation may be removed"]
-    #[doc = " in a future version of SDL."]
-    #[doc = ""]
-    #[doc = " \\param title the title of the window, in UTF-8 encoding"]
-    #[doc = " \\param x the x position of the window, `SDL_WINDOWPOS_CENTERED`, or"]
-    #[doc = "          `SDL_WINDOWPOS_UNDEFINED`"]
-    #[doc = " \\param y the y position of the window, `SDL_WINDOWPOS_CENTERED`, or"]
-    #[doc = "          `SDL_WINDOWPOS_UNDEFINED`"]
-    #[doc = " \\param w the width of the window, in screen coordinates"]
-    #[doc = " \\param h the height of the window, in screen coordinates"]
-    #[doc = " \\param flags 0, or one or more SDL_WindowFlags OR'd together"]
-    #[doc = " \\returns the window that was created or NULL on failure; call"]
-    #[doc = "          SDL_GetError() for more information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_CreateWindowFrom"]
-    #[doc = " \\sa SDL_DestroyWindow"]
+    #[doc = " Create a window with the specified position, dimensions, and flags.\n\n `flags` may be any of the following OR'd together:\n\n - `SDL_WINDOW_FULLSCREEN`: fullscreen window\n - `SDL_WINDOW_FULLSCREEN_DESKTOP`: fullscreen window at desktop resolution\n - `SDL_WINDOW_OPENGL`: window usable with an OpenGL context\n - `SDL_WINDOW_VULKAN`: window usable with a Vulkan instance\n - `SDL_WINDOW_METAL`: window usable with a Metal instance\n - `SDL_WINDOW_HIDDEN`: window is not visible\n - `SDL_WINDOW_BORDERLESS`: no window decoration\n - `SDL_WINDOW_RESIZABLE`: window can be resized\n - `SDL_WINDOW_MINIMIZED`: window is minimized\n - `SDL_WINDOW_MAXIMIZED`: window is maximized\n - `SDL_WINDOW_INPUT_GRABBED`: window has grabbed input focus\n - `SDL_WINDOW_ALLOW_HIGHDPI`: window should be created in high-DPI mode if\n   supported (>= SDL 2.0.1)\n\n `SDL_WINDOW_SHOWN` is ignored by SDL_CreateWindow(). The SDL_Window is\n implicitly shown if SDL_WINDOW_HIDDEN is not set. `SDL_WINDOW_SHOWN` may be\n queried later using SDL_GetWindowFlags().\n\n On Apple's macOS, you **must** set the NSHighResolutionCapable Info.plist\n property to YES, otherwise you will not receive a High-DPI OpenGL canvas.\n\n If the window is created with the `SDL_WINDOW_ALLOW_HIGHDPI` flag, its size\n in pixels may differ from its size in screen coordinates on platforms with\n high-DPI support (e.g. iOS and macOS). Use SDL_GetWindowSize() to query the\n client area's size in screen coordinates, and SDL_GL_GetDrawableSize() or\n SDL_GetRendererOutputSize() to query the drawable size in pixels. Note that\n when this flag is set, the drawable size can vary after the window is\n created and should be queried after major window events such as when the\n window is resized or moved between displays.\n\n If the window is set fullscreen, the width and height parameters `w` and\n `h` will not be used. However, invalid size parameters (e.g. too large) may\n still fail. Window size is actually limited to 16384 x 16384 for all\n platforms at window creation.\n\n If the window is created with any of the SDL_WINDOW_OPENGL or\n SDL_WINDOW_VULKAN flags, then the corresponding LoadLibrary function\n (SDL_GL_LoadLibrary or SDL_Vulkan_LoadLibrary) is called and the\n corresponding UnloadLibrary function is called by SDL_DestroyWindow().\n\n If SDL_WINDOW_VULKAN is specified and there isn't a working Vulkan driver,\n SDL_CreateWindow() will fail because SDL_Vulkan_LoadLibrary() will fail.\n\n If SDL_WINDOW_METAL is specified on an OS that does not support Metal,\n SDL_CreateWindow() will fail.\n\n On non-Apple devices, SDL requires you to either not link to the Vulkan\n loader or link to a dynamic library version. This limitation may be removed\n in a future version of SDL.\n\n \\param title the title of the window, in UTF-8 encoding\n \\param x the x position of the window, `SDL_WINDOWPOS_CENTERED`, or\n          `SDL_WINDOWPOS_UNDEFINED`\n \\param y the y position of the window, `SDL_WINDOWPOS_CENTERED`, or\n          `SDL_WINDOWPOS_UNDEFINED`\n \\param w the width of the window, in screen coordinates\n \\param h the height of the window, in screen coordinates\n \\param flags 0, or one or more SDL_WindowFlags OR'd together\n \\returns the window that was created or NULL on failure; call\n          SDL_GetError() for more information.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_CreateWindowFrom\n \\sa SDL_DestroyWindow"]
     pub fn SDL_CreateWindow(
         title: *const libc::c_char,
         x: libc::c_int,
@@ -10764,117 +6982,35 @@ extern "C" {
     ) -> *mut SDL_Window;
 }
 extern "C" {
-    #[doc = " Create an SDL window from an existing native window."]
-    #[doc = ""]
-    #[doc = " In some cases (e.g. OpenGL) and on some platforms (e.g. Microsoft Windows)"]
-    #[doc = " the hint `SDL_HINT_VIDEO_WINDOW_SHARE_PIXEL_FORMAT` needs to be configured"]
-    #[doc = " before using SDL_CreateWindowFrom()."]
-    #[doc = ""]
-    #[doc = " \\param data a pointer to driver-dependent window creation data, typically"]
-    #[doc = "             your native window cast to a void*"]
-    #[doc = " \\returns the window that was created or NULL on failure; call"]
-    #[doc = "          SDL_GetError() for more information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_CreateWindow"]
-    #[doc = " \\sa SDL_DestroyWindow"]
+    #[doc = " Create an SDL window from an existing native window.\n\n In some cases (e.g. OpenGL) and on some platforms (e.g. Microsoft Windows)\n the hint `SDL_HINT_VIDEO_WINDOW_SHARE_PIXEL_FORMAT` needs to be configured\n before using SDL_CreateWindowFrom().\n\n \\param data a pointer to driver-dependent window creation data, typically\n             your native window cast to a void*\n \\returns the window that was created or NULL on failure; call\n          SDL_GetError() for more information.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_CreateWindow\n \\sa SDL_DestroyWindow"]
     pub fn SDL_CreateWindowFrom(data: *const libc::c_void) -> *mut SDL_Window;
 }
 extern "C" {
-    #[doc = " Get the numeric ID of a window."]
-    #[doc = ""]
-    #[doc = " The numeric ID is what SDL_WindowEvent references, and is necessary to map"]
-    #[doc = " these events to specific SDL_Window objects."]
-    #[doc = ""]
-    #[doc = " \\param window the window to query"]
-    #[doc = " \\returns the ID of the window on success or 0 on failure; call"]
-    #[doc = "          SDL_GetError() for more information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_GetWindowFromID"]
+    #[doc = " Get the numeric ID of a window.\n\n The numeric ID is what SDL_WindowEvent references, and is necessary to map\n these events to specific SDL_Window objects.\n\n \\param window the window to query\n \\returns the ID of the window on success or 0 on failure; call\n          SDL_GetError() for more information.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_GetWindowFromID"]
     pub fn SDL_GetWindowID(window: *mut SDL_Window) -> Uint32;
 }
 extern "C" {
-    #[doc = " Get a window from a stored ID."]
-    #[doc = ""]
-    #[doc = " The numeric ID is what SDL_WindowEvent references, and is necessary to map"]
-    #[doc = " these events to specific SDL_Window objects."]
-    #[doc = ""]
-    #[doc = " \\param id the ID of the window"]
-    #[doc = " \\returns the window associated with `id` or NULL if it doesn't exist; call"]
-    #[doc = "          SDL_GetError() for more information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_GetWindowID"]
+    #[doc = " Get a window from a stored ID.\n\n The numeric ID is what SDL_WindowEvent references, and is necessary to map\n these events to specific SDL_Window objects.\n\n \\param id the ID of the window\n \\returns the window associated with `id` or NULL if it doesn't exist; call\n          SDL_GetError() for more information.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_GetWindowID"]
     pub fn SDL_GetWindowFromID(id: Uint32) -> *mut SDL_Window;
 }
 extern "C" {
-    #[doc = " Get the window flags."]
-    #[doc = ""]
-    #[doc = " \\param window the window to query"]
-    #[doc = " \\returns a mask of the SDL_WindowFlags associated with `window`"]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_CreateWindow"]
-    #[doc = " \\sa SDL_HideWindow"]
-    #[doc = " \\sa SDL_MaximizeWindow"]
-    #[doc = " \\sa SDL_MinimizeWindow"]
-    #[doc = " \\sa SDL_SetWindowFullscreen"]
-    #[doc = " \\sa SDL_SetWindowGrab"]
-    #[doc = " \\sa SDL_ShowWindow"]
+    #[doc = " Get the window flags.\n\n \\param window the window to query\n \\returns a mask of the SDL_WindowFlags associated with `window`\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_CreateWindow\n \\sa SDL_HideWindow\n \\sa SDL_MaximizeWindow\n \\sa SDL_MinimizeWindow\n \\sa SDL_SetWindowFullscreen\n \\sa SDL_SetWindowGrab\n \\sa SDL_ShowWindow"]
     pub fn SDL_GetWindowFlags(window: *mut SDL_Window) -> Uint32;
 }
 extern "C" {
-    #[doc = " Set the title of a window."]
-    #[doc = ""]
-    #[doc = " This string is expected to be in UTF-8 encoding."]
-    #[doc = ""]
-    #[doc = " \\param window the window to change"]
-    #[doc = " \\param title the desired window title in UTF-8 format"]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_GetWindowTitle"]
+    #[doc = " Set the title of a window.\n\n This string is expected to be in UTF-8 encoding.\n\n \\param window the window to change\n \\param title the desired window title in UTF-8 format\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_GetWindowTitle"]
     pub fn SDL_SetWindowTitle(window: *mut SDL_Window, title: *const libc::c_char);
 }
 extern "C" {
-    #[doc = " Get the title of a window."]
-    #[doc = ""]
-    #[doc = " \\param window the window to query"]
-    #[doc = " \\returns the title of the window in UTF-8 format or \"\" if there is no"]
-    #[doc = "          title."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_SetWindowTitle"]
+    #[doc = " Get the title of a window.\n\n \\param window the window to query\n \\returns the title of the window in UTF-8 format or \"\" if there is no\n          title.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_SetWindowTitle"]
     pub fn SDL_GetWindowTitle(window: *mut SDL_Window) -> *const libc::c_char;
 }
 extern "C" {
-    #[doc = " Set the icon for a window."]
-    #[doc = ""]
-    #[doc = " \\param window the window to change"]
-    #[doc = " \\param icon an SDL_Surface structure containing the icon for the window"]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
+    #[doc = " Set the icon for a window.\n\n \\param window the window to change\n \\param icon an SDL_Surface structure containing the icon for the window\n\n \\since This function is available since SDL 2.0.0."]
     pub fn SDL_SetWindowIcon(window: *mut SDL_Window, icon: *mut SDL_Surface);
 }
 extern "C" {
-    #[doc = " Associate an arbitrary named pointer with a window."]
-    #[doc = ""]
-    #[doc = " `name` is case-sensitive."]
-    #[doc = ""]
-    #[doc = " \\param window the window to associate with the pointer"]
-    #[doc = " \\param name the name of the pointer"]
-    #[doc = " \\param userdata the associated pointer"]
-    #[doc = " \\returns the previous value associated with `name`."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_GetWindowData"]
+    #[doc = " Associate an arbitrary named pointer with a window.\n\n `name` is case-sensitive.\n\n \\param window the window to associate with the pointer\n \\param name the name of the pointer\n \\param userdata the associated pointer\n \\returns the previous value associated with `name`.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_GetWindowData"]
     pub fn SDL_SetWindowData(
         window: *mut SDL_Window,
         name: *const libc::c_char,
@@ -10882,132 +7018,30 @@ extern "C" {
     ) -> *mut libc::c_void;
 }
 extern "C" {
-    #[doc = " Retrieve the data pointer associated with a window."]
-    #[doc = ""]
-    #[doc = " \\param window the window to query"]
-    #[doc = " \\param name the name of the pointer"]
-    #[doc = " \\returns the value associated with `name`."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_SetWindowData"]
+    #[doc = " Retrieve the data pointer associated with a window.\n\n \\param window the window to query\n \\param name the name of the pointer\n \\returns the value associated with `name`.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_SetWindowData"]
     pub fn SDL_GetWindowData(
         window: *mut SDL_Window,
         name: *const libc::c_char,
     ) -> *mut libc::c_void;
 }
 extern "C" {
-    #[doc = " Set the position of a window."]
-    #[doc = ""]
-    #[doc = " The window coordinate origin is the upper left of the display."]
-    #[doc = ""]
-    #[doc = " \\param window the window to reposition"]
-    #[doc = " \\param x the x coordinate of the window in screen coordinates, or"]
-    #[doc = "          `SDL_WINDOWPOS_CENTERED` or `SDL_WINDOWPOS_UNDEFINED`"]
-    #[doc = " \\param y the y coordinate of the window in screen coordinates, or"]
-    #[doc = "          `SDL_WINDOWPOS_CENTERED` or `SDL_WINDOWPOS_UNDEFINED`"]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_GetWindowPosition"]
+    #[doc = " Set the position of a window.\n\n The window coordinate origin is the upper left of the display.\n\n \\param window the window to reposition\n \\param x the x coordinate of the window in screen coordinates, or\n          `SDL_WINDOWPOS_CENTERED` or `SDL_WINDOWPOS_UNDEFINED`\n \\param y the y coordinate of the window in screen coordinates, or\n          `SDL_WINDOWPOS_CENTERED` or `SDL_WINDOWPOS_UNDEFINED`\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_GetWindowPosition"]
     pub fn SDL_SetWindowPosition(window: *mut SDL_Window, x: libc::c_int, y: libc::c_int);
 }
 extern "C" {
-    #[doc = " Get the position of a window."]
-    #[doc = ""]
-    #[doc = " If you do not need the value for one of the positions a NULL may be passed"]
-    #[doc = " in the `x` or `y` parameter."]
-    #[doc = ""]
-    #[doc = " \\param window the window to query"]
-    #[doc = " \\param x a pointer filled in with the x position of the window, in screen"]
-    #[doc = "          coordinates, may be NULL"]
-    #[doc = " \\param y a pointer filled in with the y position of the window, in screen"]
-    #[doc = "          coordinates, may be NULL"]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_SetWindowPosition"]
+    #[doc = " Get the position of a window.\n\n If you do not need the value for one of the positions a NULL may be passed\n in the `x` or `y` parameter.\n\n \\param window the window to query\n \\param x a pointer filled in with the x position of the window, in screen\n          coordinates, may be NULL\n \\param y a pointer filled in with the y position of the window, in screen\n          coordinates, may be NULL\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_SetWindowPosition"]
     pub fn SDL_GetWindowPosition(window: *mut SDL_Window, x: *mut libc::c_int, y: *mut libc::c_int);
 }
 extern "C" {
-    #[doc = " Set the size of a window's client area."]
-    #[doc = ""]
-    #[doc = " The window size in screen coordinates may differ from the size in pixels,"]
-    #[doc = " if the window was created with `SDL_WINDOW_ALLOW_HIGHDPI` on a platform"]
-    #[doc = " with high-dpi support (e.g. iOS or macOS). Use SDL_GL_GetDrawableSize() or"]
-    #[doc = " SDL_GetRendererOutputSize() to get the real client area size in pixels."]
-    #[doc = ""]
-    #[doc = " Fullscreen windows automatically match the size of the display mode, and"]
-    #[doc = " you should use SDL_SetWindowDisplayMode() to change their size."]
-    #[doc = ""]
-    #[doc = " \\param window the window to change"]
-    #[doc = " \\param w the width of the window in pixels, in screen coordinates, must be"]
-    #[doc = "          > 0"]
-    #[doc = " \\param h the height of the window in pixels, in screen coordinates, must be"]
-    #[doc = "          > 0"]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_GetWindowSize"]
-    #[doc = " \\sa SDL_SetWindowDisplayMode"]
+    #[doc = " Set the size of a window's client area.\n\n The window size in screen coordinates may differ from the size in pixels,\n if the window was created with `SDL_WINDOW_ALLOW_HIGHDPI` on a platform\n with high-dpi support (e.g. iOS or macOS). Use SDL_GL_GetDrawableSize() or\n SDL_GetRendererOutputSize() to get the real client area size in pixels.\n\n Fullscreen windows automatically match the size of the display mode, and\n you should use SDL_SetWindowDisplayMode() to change their size.\n\n \\param window the window to change\n \\param w the width of the window in pixels, in screen coordinates, must be\n          > 0\n \\param h the height of the window in pixels, in screen coordinates, must be\n          > 0\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_GetWindowSize\n \\sa SDL_SetWindowDisplayMode"]
     pub fn SDL_SetWindowSize(window: *mut SDL_Window, w: libc::c_int, h: libc::c_int);
 }
 extern "C" {
-    #[doc = " Get the size of a window's client area."]
-    #[doc = ""]
-    #[doc = " NULL can safely be passed as the `w` or `h` parameter if the width or"]
-    #[doc = " height value is not desired."]
-    #[doc = ""]
-    #[doc = " The window size in screen coordinates may differ from the size in pixels,"]
-    #[doc = " if the window was created with `SDL_WINDOW_ALLOW_HIGHDPI` on a platform"]
-    #[doc = " with high-dpi support (e.g. iOS or macOS). Use SDL_GL_GetDrawableSize(),"]
-    #[doc = " SDL_Vulkan_GetDrawableSize(), or SDL_GetRendererOutputSize() to get the"]
-    #[doc = " real client area size in pixels."]
-    #[doc = ""]
-    #[doc = " \\param window the window to query the width and height from"]
-    #[doc = " \\param w a pointer filled in with the width of the window, in screen"]
-    #[doc = "          coordinates, may be NULL"]
-    #[doc = " \\param h a pointer filled in with the height of the window, in screen"]
-    #[doc = "          coordinates, may be NULL"]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_GL_GetDrawableSize"]
-    #[doc = " \\sa SDL_Vulkan_GetDrawableSize"]
-    #[doc = " \\sa SDL_SetWindowSize"]
+    #[doc = " Get the size of a window's client area.\n\n NULL can safely be passed as the `w` or `h` parameter if the width or\n height value is not desired.\n\n The window size in screen coordinates may differ from the size in pixels,\n if the window was created with `SDL_WINDOW_ALLOW_HIGHDPI` on a platform\n with high-dpi support (e.g. iOS or macOS). Use SDL_GL_GetDrawableSize(),\n SDL_Vulkan_GetDrawableSize(), or SDL_GetRendererOutputSize() to get the\n real client area size in pixels.\n\n \\param window the window to query the width and height from\n \\param w a pointer filled in with the width of the window, in screen\n          coordinates, may be NULL\n \\param h a pointer filled in with the height of the window, in screen\n          coordinates, may be NULL\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_GL_GetDrawableSize\n \\sa SDL_Vulkan_GetDrawableSize\n \\sa SDL_SetWindowSize"]
     pub fn SDL_GetWindowSize(window: *mut SDL_Window, w: *mut libc::c_int, h: *mut libc::c_int);
 }
 extern "C" {
-    #[doc = " Get the size of a window's borders (decorations) around the client area."]
-    #[doc = ""]
-    #[doc = " Note: If this function fails (returns -1), the size values will be"]
-    #[doc = " initialized to 0, 0, 0, 0 (if a non-NULL pointer is provided), as if the"]
-    #[doc = " window in question was borderless."]
-    #[doc = ""]
-    #[doc = " Note: This function may fail on systems where the window has not yet been"]
-    #[doc = " decorated by the display server (for example, immediately after calling"]
-    #[doc = " SDL_CreateWindow). It is recommended that you wait at least until the"]
-    #[doc = " window has been presented and composited, so that the window system has a"]
-    #[doc = " chance to decorate the window and provide the border dimensions to SDL."]
-    #[doc = ""]
-    #[doc = " This function also returns -1 if getting the information is not supported."]
-    #[doc = ""]
-    #[doc = " \\param window the window to query the size values of the border"]
-    #[doc = "               (decorations) from"]
-    #[doc = " \\param top pointer to variable for storing the size of the top border; NULL"]
-    #[doc = "            is permitted"]
-    #[doc = " \\param left pointer to variable for storing the size of the left border;"]
-    #[doc = "             NULL is permitted"]
-    #[doc = " \\param bottom pointer to variable for storing the size of the bottom"]
-    #[doc = "               border; NULL is permitted"]
-    #[doc = " \\param right pointer to variable for storing the size of the right border;"]
-    #[doc = "              NULL is permitted"]
-    #[doc = " \\returns 0 on success or a negative error code on failure; call"]
-    #[doc = "          SDL_GetError() for more information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.5."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_GetWindowSize"]
+    #[doc = " Get the size of a window's borders (decorations) around the client area.\n\n Note: If this function fails (returns -1), the size values will be\n initialized to 0, 0, 0, 0 (if a non-NULL pointer is provided), as if the\n window in question was borderless.\n\n Note: This function may fail on systems where the window has not yet been\n decorated by the display server (for example, immediately after calling\n SDL_CreateWindow). It is recommended that you wait at least until the\n window has been presented and composited, so that the window system has a\n chance to decorate the window and provide the border dimensions to SDL.\n\n This function also returns -1 if getting the information is not supported.\n\n \\param window the window to query the size values of the border\n               (decorations) from\n \\param top pointer to variable for storing the size of the top border; NULL\n            is permitted\n \\param left pointer to variable for storing the size of the left border;\n             NULL is permitted\n \\param bottom pointer to variable for storing the size of the bottom\n               border; NULL is permitted\n \\param right pointer to variable for storing the size of the right border;\n              NULL is permitted\n \\returns 0 on success or a negative error code on failure; call\n          SDL_GetError() for more information.\n\n \\since This function is available since SDL 2.0.5.\n\n \\sa SDL_GetWindowSize"]
     pub fn SDL_GetWindowBordersSize(
         window: *mut SDL_Window,
         top: *mut libc::c_int,
@@ -11017,16 +7051,15 @@ extern "C" {
     ) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Set the minimum size of a window's client area."]
-    #[doc = ""]
-    #[doc = " \\param window the window to change"]
-    #[doc = " \\param min_w the minimum width of the window in pixels"]
-    #[doc = " \\param min_h the minimum height of the window in pixels"]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_GetWindowMinimumSize"]
-    #[doc = " \\sa SDL_SetWindowMaximumSize"]
+    #[doc = " Get the size of a window in pixels.\n\n This may differ from SDL_GetWindowSize() if we're rendering to a high-DPI\n drawable, i.e. the window was created with `SDL_WINDOW_ALLOW_HIGHDPI` on a\n platform with high-DPI support (Apple calls this \"Retina\"), and not\n disabled by the `SDL_HINT_VIDEO_HIGHDPI_DISABLED` hint.\n\n \\param window the window from which the drawable size should be queried\n \\param w a pointer to variable for storing the width in pixels, may be NULL\n \\param h a pointer to variable for storing the height in pixels, may be\n          NULL\n\n \\since This function is available since SDL 2.26.0.\n\n \\sa SDL_CreateWindow\n \\sa SDL_GetWindowSize"]
+    pub fn SDL_GetWindowSizeInPixels(
+        window: *mut SDL_Window,
+        w: *mut libc::c_int,
+        h: *mut libc::c_int,
+    );
+}
+extern "C" {
+    #[doc = " Set the minimum size of a window's client area.\n\n \\param window the window to change\n \\param min_w the minimum width of the window in pixels\n \\param min_h the minimum height of the window in pixels\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_GetWindowMinimumSize\n \\sa SDL_SetWindowMaximumSize"]
     pub fn SDL_SetWindowMinimumSize(
         window: *mut SDL_Window,
         min_w: libc::c_int,
@@ -11034,18 +7067,7 @@ extern "C" {
     );
 }
 extern "C" {
-    #[doc = " Get the minimum size of a window's client area."]
-    #[doc = ""]
-    #[doc = " \\param window the window to query"]
-    #[doc = " \\param w a pointer filled in with the minimum width of the window, may be"]
-    #[doc = "          NULL"]
-    #[doc = " \\param h a pointer filled in with the minimum height of the window, may be"]
-    #[doc = "          NULL"]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_GetWindowMaximumSize"]
-    #[doc = " \\sa SDL_SetWindowMinimumSize"]
+    #[doc = " Get the minimum size of a window's client area.\n\n \\param window the window to query\n \\param w a pointer filled in with the minimum width of the window, may be\n          NULL\n \\param h a pointer filled in with the minimum height of the window, may be\n          NULL\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_GetWindowMaximumSize\n \\sa SDL_SetWindowMinimumSize"]
     pub fn SDL_GetWindowMinimumSize(
         window: *mut SDL_Window,
         w: *mut libc::c_int,
@@ -11053,16 +7075,7 @@ extern "C" {
     );
 }
 extern "C" {
-    #[doc = " Set the maximum size of a window's client area."]
-    #[doc = ""]
-    #[doc = " \\param window the window to change"]
-    #[doc = " \\param max_w the maximum width of the window in pixels"]
-    #[doc = " \\param max_h the maximum height of the window in pixels"]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_GetWindowMaximumSize"]
-    #[doc = " \\sa SDL_SetWindowMinimumSize"]
+    #[doc = " Set the maximum size of a window's client area.\n\n \\param window the window to change\n \\param max_w the maximum width of the window in pixels\n \\param max_h the maximum height of the window in pixels\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_GetWindowMaximumSize\n \\sa SDL_SetWindowMinimumSize"]
     pub fn SDL_SetWindowMaximumSize(
         window: *mut SDL_Window,
         max_w: libc::c_int,
@@ -11070,18 +7083,7 @@ extern "C" {
     );
 }
 extern "C" {
-    #[doc = " Get the maximum size of a window's client area."]
-    #[doc = ""]
-    #[doc = " \\param window the window to query"]
-    #[doc = " \\param w a pointer filled in with the maximum width of the window, may be"]
-    #[doc = "          NULL"]
-    #[doc = " \\param h a pointer filled in with the maximum height of the window, may be"]
-    #[doc = "          NULL"]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_GetWindowMinimumSize"]
-    #[doc = " \\sa SDL_SetWindowMaximumSize"]
+    #[doc = " Get the maximum size of a window's client area.\n\n \\param window the window to query\n \\param w a pointer filled in with the maximum width of the window, may be\n          NULL\n \\param h a pointer filled in with the maximum height of the window, may be\n          NULL\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_GetWindowMinimumSize\n \\sa SDL_SetWindowMaximumSize"]
     pub fn SDL_GetWindowMaximumSize(
         window: *mut SDL_Window,
         w: *mut libc::c_int,
@@ -11089,195 +7091,55 @@ extern "C" {
     );
 }
 extern "C" {
-    #[doc = " Set the border state of a window."]
-    #[doc = ""]
-    #[doc = " This will add or remove the window's `SDL_WINDOW_BORDERLESS` flag and add"]
-    #[doc = " or remove the border from the actual window. This is a no-op if the"]
-    #[doc = " window's border already matches the requested state."]
-    #[doc = ""]
-    #[doc = " You can't change the border state of a fullscreen window."]
-    #[doc = ""]
-    #[doc = " \\param window the window of which to change the border state"]
-    #[doc = " \\param bordered SDL_FALSE to remove border, SDL_TRUE to add border"]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_GetWindowFlags"]
+    #[doc = " Set the border state of a window.\n\n This will add or remove the window's `SDL_WINDOW_BORDERLESS` flag and add\n or remove the border from the actual window. This is a no-op if the\n window's border already matches the requested state.\n\n You can't change the border state of a fullscreen window.\n\n \\param window the window of which to change the border state\n \\param bordered SDL_FALSE to remove border, SDL_TRUE to add border\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_GetWindowFlags"]
     pub fn SDL_SetWindowBordered(window: *mut SDL_Window, bordered: SDL_bool);
 }
 extern "C" {
-    #[doc = " Set the user-resizable state of a window."]
-    #[doc = ""]
-    #[doc = " This will add or remove the window's `SDL_WINDOW_RESIZABLE` flag and"]
-    #[doc = " allow/disallow user resizing of the window. This is a no-op if the window's"]
-    #[doc = " resizable state already matches the requested state."]
-    #[doc = ""]
-    #[doc = " You can't change the resizable state of a fullscreen window."]
-    #[doc = ""]
-    #[doc = " \\param window the window of which to change the resizable state"]
-    #[doc = " \\param resizable SDL_TRUE to allow resizing, SDL_FALSE to disallow"]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.5."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_GetWindowFlags"]
+    #[doc = " Set the user-resizable state of a window.\n\n This will add or remove the window's `SDL_WINDOW_RESIZABLE` flag and\n allow/disallow user resizing of the window. This is a no-op if the window's\n resizable state already matches the requested state.\n\n You can't change the resizable state of a fullscreen window.\n\n \\param window the window of which to change the resizable state\n \\param resizable SDL_TRUE to allow resizing, SDL_FALSE to disallow\n\n \\since This function is available since SDL 2.0.5.\n\n \\sa SDL_GetWindowFlags"]
     pub fn SDL_SetWindowResizable(window: *mut SDL_Window, resizable: SDL_bool);
 }
 extern "C" {
-    #[doc = " Set the window to always be above the others."]
-    #[doc = ""]
-    #[doc = " This will add or remove the window's `SDL_WINDOW_ALWAYS_ON_TOP` flag. This"]
-    #[doc = " will bring the window to the front and keep the window above the rest."]
-    #[doc = ""]
-    #[doc = " \\param window The window of which to change the always on top state"]
-    #[doc = " \\param on_top SDL_TRUE to set the window always on top, SDL_FALSE to"]
-    #[doc = "               disable"]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.16."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_GetWindowFlags"]
+    #[doc = " Set the window to always be above the others.\n\n This will add or remove the window's `SDL_WINDOW_ALWAYS_ON_TOP` flag. This\n will bring the window to the front and keep the window above the rest.\n\n \\param window The window of which to change the always on top state\n \\param on_top SDL_TRUE to set the window always on top, SDL_FALSE to\n               disable\n\n \\since This function is available since SDL 2.0.16.\n\n \\sa SDL_GetWindowFlags"]
     pub fn SDL_SetWindowAlwaysOnTop(window: *mut SDL_Window, on_top: SDL_bool);
 }
 extern "C" {
-    #[doc = " Show a window."]
-    #[doc = ""]
-    #[doc = " \\param window the window to show"]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_HideWindow"]
-    #[doc = " \\sa SDL_RaiseWindow"]
+    #[doc = " Show a window.\n\n \\param window the window to show\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_HideWindow\n \\sa SDL_RaiseWindow"]
     pub fn SDL_ShowWindow(window: *mut SDL_Window);
 }
 extern "C" {
-    #[doc = " Hide a window."]
-    #[doc = ""]
-    #[doc = " \\param window the window to hide"]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_ShowWindow"]
+    #[doc = " Hide a window.\n\n \\param window the window to hide\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_ShowWindow"]
     pub fn SDL_HideWindow(window: *mut SDL_Window);
 }
 extern "C" {
-    #[doc = " Raise a window above other windows and set the input focus."]
-    #[doc = ""]
-    #[doc = " \\param window the window to raise"]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
+    #[doc = " Raise a window above other windows and set the input focus.\n\n \\param window the window to raise\n\n \\since This function is available since SDL 2.0.0."]
     pub fn SDL_RaiseWindow(window: *mut SDL_Window);
 }
 extern "C" {
-    #[doc = " Make a window as large as possible."]
-    #[doc = ""]
-    #[doc = " \\param window the window to maximize"]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_MinimizeWindow"]
-    #[doc = " \\sa SDL_RestoreWindow"]
+    #[doc = " Make a window as large as possible.\n\n \\param window the window to maximize\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_MinimizeWindow\n \\sa SDL_RestoreWindow"]
     pub fn SDL_MaximizeWindow(window: *mut SDL_Window);
 }
 extern "C" {
-    #[doc = " Minimize a window to an iconic representation."]
-    #[doc = ""]
-    #[doc = " \\param window the window to minimize"]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_MaximizeWindow"]
-    #[doc = " \\sa SDL_RestoreWindow"]
+    #[doc = " Minimize a window to an iconic representation.\n\n \\param window the window to minimize\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_MaximizeWindow\n \\sa SDL_RestoreWindow"]
     pub fn SDL_MinimizeWindow(window: *mut SDL_Window);
 }
 extern "C" {
-    #[doc = " Restore the size and position of a minimized or maximized window."]
-    #[doc = ""]
-    #[doc = " \\param window the window to restore"]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_MaximizeWindow"]
-    #[doc = " \\sa SDL_MinimizeWindow"]
+    #[doc = " Restore the size and position of a minimized or maximized window.\n\n \\param window the window to restore\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_MaximizeWindow\n \\sa SDL_MinimizeWindow"]
     pub fn SDL_RestoreWindow(window: *mut SDL_Window);
 }
 extern "C" {
-    #[doc = " Set a window's fullscreen state."]
-    #[doc = ""]
-    #[doc = " `flags` may be `SDL_WINDOW_FULLSCREEN`, for \"real\" fullscreen with a"]
-    #[doc = " videomode change; `SDL_WINDOW_FULLSCREEN_DESKTOP` for \"fake\" fullscreen"]
-    #[doc = " that takes the size of the desktop; and 0 for windowed mode."]
-    #[doc = ""]
-    #[doc = " \\param window the window to change"]
-    #[doc = " \\param flags `SDL_WINDOW_FULLSCREEN`, `SDL_WINDOW_FULLSCREEN_DESKTOP` or 0"]
-    #[doc = " \\returns 0 on success or a negative error code on failure; call"]
-    #[doc = "          SDL_GetError() for more information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_GetWindowDisplayMode"]
-    #[doc = " \\sa SDL_SetWindowDisplayMode"]
+    #[doc = " Set a window's fullscreen state.\n\n `flags` may be `SDL_WINDOW_FULLSCREEN`, for \"real\" fullscreen with a\n videomode change; `SDL_WINDOW_FULLSCREEN_DESKTOP` for \"fake\" fullscreen\n that takes the size of the desktop; and 0 for windowed mode.\n\n \\param window the window to change\n \\param flags `SDL_WINDOW_FULLSCREEN`, `SDL_WINDOW_FULLSCREEN_DESKTOP` or 0\n \\returns 0 on success or a negative error code on failure; call\n          SDL_GetError() for more information.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_GetWindowDisplayMode\n \\sa SDL_SetWindowDisplayMode"]
     pub fn SDL_SetWindowFullscreen(window: *mut SDL_Window, flags: Uint32) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Get the SDL surface associated with the window."]
-    #[doc = ""]
-    #[doc = " A new surface will be created with the optimal format for the window, if"]
-    #[doc = " necessary. This surface will be freed when the window is destroyed. Do not"]
-    #[doc = " free this surface."]
-    #[doc = ""]
-    #[doc = " This surface will be invalidated if the window is resized. After resizing a"]
-    #[doc = " window this function must be called again to return a valid surface."]
-    #[doc = ""]
-    #[doc = " You may not combine this with 3D or the rendering API on this window."]
-    #[doc = ""]
-    #[doc = " This function is affected by `SDL_HINT_FRAMEBUFFER_ACCELERATION`."]
-    #[doc = ""]
-    #[doc = " \\param window the window to query"]
-    #[doc = " \\returns the surface associated with the window, or NULL on failure; call"]
-    #[doc = "          SDL_GetError() for more information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_UpdateWindowSurface"]
-    #[doc = " \\sa SDL_UpdateWindowSurfaceRects"]
+    #[doc = " Get the SDL surface associated with the window.\n\n A new surface will be created with the optimal format for the window, if\n necessary. This surface will be freed when the window is destroyed. Do not\n free this surface.\n\n This surface will be invalidated if the window is resized. After resizing a\n window this function must be called again to return a valid surface.\n\n You may not combine this with 3D or the rendering API on this window.\n\n This function is affected by `SDL_HINT_FRAMEBUFFER_ACCELERATION`.\n\n \\param window the window to query\n \\returns the surface associated with the window, or NULL on failure; call\n          SDL_GetError() for more information.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_UpdateWindowSurface\n \\sa SDL_UpdateWindowSurfaceRects"]
     pub fn SDL_GetWindowSurface(window: *mut SDL_Window) -> *mut SDL_Surface;
 }
 extern "C" {
-    #[doc = " Copy the window surface to the screen."]
-    #[doc = ""]
-    #[doc = " This is the function you use to reflect any changes to the surface on the"]
-    #[doc = " screen."]
-    #[doc = ""]
-    #[doc = " This function is equivalent to the SDL 1.2 API SDL_Flip()."]
-    #[doc = ""]
-    #[doc = " \\param window the window to update"]
-    #[doc = " \\returns 0 on success or a negative error code on failure; call"]
-    #[doc = "          SDL_GetError() for more information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_GetWindowSurface"]
-    #[doc = " \\sa SDL_UpdateWindowSurfaceRects"]
+    #[doc = " Copy the window surface to the screen.\n\n This is the function you use to reflect any changes to the surface on the\n screen.\n\n This function is equivalent to the SDL 1.2 API SDL_Flip().\n\n \\param window the window to update\n \\returns 0 on success or a negative error code on failure; call\n          SDL_GetError() for more information.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_GetWindowSurface\n \\sa SDL_UpdateWindowSurfaceRects"]
     pub fn SDL_UpdateWindowSurface(window: *mut SDL_Window) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Copy areas of the window surface to the screen."]
-    #[doc = ""]
-    #[doc = " This is the function you use to reflect changes to portions of the surface"]
-    #[doc = " on the screen."]
-    #[doc = ""]
-    #[doc = " This function is equivalent to the SDL 1.2 API SDL_UpdateRects()."]
-    #[doc = ""]
-    #[doc = " \\param window the window to update"]
-    #[doc = " \\param rects an array of SDL_Rect structures representing areas of the"]
-    #[doc = "              surface to copy"]
-    #[doc = " \\param numrects the number of rectangles"]
-    #[doc = " \\returns 0 on success or a negative error code on failure; call"]
-    #[doc = "          SDL_GetError() for more information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_GetWindowSurface"]
-    #[doc = " \\sa SDL_UpdateWindowSurface"]
+    #[doc = " Copy areas of the window surface to the screen.\n\n This is the function you use to reflect changes to portions of the surface\n on the screen.\n\n This function is equivalent to the SDL 1.2 API SDL_UpdateRects().\n\n \\param window the window to update\n \\param rects an array of SDL_Rect structures representing areas of the\n              surface to copy\n \\param numrects the number of rectangles\n \\returns 0 on success or a negative error code on failure; call\n          SDL_GetError() for more information.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_GetWindowSurface\n \\sa SDL_UpdateWindowSurface"]
     pub fn SDL_UpdateWindowSurfaceRects(
         window: *mut SDL_Window,
         rects: *const SDL_Rect,
@@ -11285,285 +7147,70 @@ extern "C" {
     ) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Set a window's input grab mode."]
-    #[doc = ""]
-    #[doc = " When input is grabbed, the mouse is confined to the window. This function"]
-    #[doc = " will also grab the keyboard if `SDL_HINT_GRAB_KEYBOARD` is set. To grab the"]
-    #[doc = " keyboard without also grabbing the mouse, use SDL_SetWindowKeyboardGrab()."]
-    #[doc = ""]
-    #[doc = " If the caller enables a grab while another window is currently grabbed, the"]
-    #[doc = " other window loses its grab in favor of the caller's window."]
-    #[doc = ""]
-    #[doc = " \\param window the window for which the input grab mode should be set"]
-    #[doc = " \\param grabbed SDL_TRUE to grab input or SDL_FALSE to release input"]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_GetGrabbedWindow"]
-    #[doc = " \\sa SDL_GetWindowGrab"]
+    #[doc = " Set a window's input grab mode.\n\n When input is grabbed, the mouse is confined to the window. This function\n will also grab the keyboard if `SDL_HINT_GRAB_KEYBOARD` is set. To grab the\n keyboard without also grabbing the mouse, use SDL_SetWindowKeyboardGrab().\n\n If the caller enables a grab while another window is currently grabbed, the\n other window loses its grab in favor of the caller's window.\n\n \\param window the window for which the input grab mode should be set\n \\param grabbed SDL_TRUE to grab input or SDL_FALSE to release input\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_GetGrabbedWindow\n \\sa SDL_GetWindowGrab"]
     pub fn SDL_SetWindowGrab(window: *mut SDL_Window, grabbed: SDL_bool);
 }
 extern "C" {
-    #[doc = " Set a window's keyboard grab mode."]
-    #[doc = ""]
-    #[doc = " Keyboard grab enables capture of system keyboard shortcuts like Alt+Tab or"]
-    #[doc = " the Meta/Super key. Note that not all system keyboard shortcuts can be"]
-    #[doc = " captured by applications (one example is Ctrl+Alt+Del on Windows)."]
-    #[doc = ""]
-    #[doc = " This is primarily intended for specialized applications such as VNC clients"]
-    #[doc = " or VM frontends. Normal games should not use keyboard grab."]
-    #[doc = ""]
-    #[doc = " When keyboard grab is enabled, SDL will continue to handle Alt+Tab when the"]
-    #[doc = " window is full-screen to ensure the user is not trapped in your"]
-    #[doc = " application. If you have a custom keyboard shortcut to exit fullscreen"]
-    #[doc = " mode, you may suppress this behavior with"]
-    #[doc = " `SDL_HINT_ALLOW_ALT_TAB_WHILE_GRABBED`."]
-    #[doc = ""]
-    #[doc = " If the caller enables a grab while another window is currently grabbed, the"]
-    #[doc = " other window loses its grab in favor of the caller's window."]
-    #[doc = ""]
-    #[doc = " \\param window The window for which the keyboard grab mode should be set."]
-    #[doc = " \\param grabbed This is SDL_TRUE to grab keyboard, and SDL_FALSE to release."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.16."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_GetWindowKeyboardGrab"]
-    #[doc = " \\sa SDL_SetWindowMouseGrab"]
-    #[doc = " \\sa SDL_SetWindowGrab"]
+    #[doc = " Set a window's keyboard grab mode.\n\n Keyboard grab enables capture of system keyboard shortcuts like Alt+Tab or\n the Meta/Super key. Note that not all system keyboard shortcuts can be\n captured by applications (one example is Ctrl+Alt+Del on Windows).\n\n This is primarily intended for specialized applications such as VNC clients\n or VM frontends. Normal games should not use keyboard grab.\n\n When keyboard grab is enabled, SDL will continue to handle Alt+Tab when the\n window is full-screen to ensure the user is not trapped in your\n application. If you have a custom keyboard shortcut to exit fullscreen\n mode, you may suppress this behavior with\n `SDL_HINT_ALLOW_ALT_TAB_WHILE_GRABBED`.\n\n If the caller enables a grab while another window is currently grabbed, the\n other window loses its grab in favor of the caller's window.\n\n \\param window The window for which the keyboard grab mode should be set.\n \\param grabbed This is SDL_TRUE to grab keyboard, and SDL_FALSE to release.\n\n \\since This function is available since SDL 2.0.16.\n\n \\sa SDL_GetWindowKeyboardGrab\n \\sa SDL_SetWindowMouseGrab\n \\sa SDL_SetWindowGrab"]
     pub fn SDL_SetWindowKeyboardGrab(window: *mut SDL_Window, grabbed: SDL_bool);
 }
 extern "C" {
-    #[doc = " Set a window's mouse grab mode."]
-    #[doc = ""]
-    #[doc = " Mouse grab confines the mouse cursor to the window."]
-    #[doc = ""]
-    #[doc = " \\param window The window for which the mouse grab mode should be set."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.16."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_GetWindowMouseGrab"]
-    #[doc = " \\sa SDL_SetWindowKeyboardGrab"]
-    #[doc = " \\sa SDL_SetWindowGrab"]
+    #[doc = " Set a window's mouse grab mode.\n\n Mouse grab confines the mouse cursor to the window.\n\n \\param window The window for which the mouse grab mode should be set.\n \\param grabbed This is SDL_TRUE to grab mouse, and SDL_FALSE to release.\n\n \\since This function is available since SDL 2.0.16.\n\n \\sa SDL_GetWindowMouseGrab\n \\sa SDL_SetWindowKeyboardGrab\n \\sa SDL_SetWindowGrab"]
     pub fn SDL_SetWindowMouseGrab(window: *mut SDL_Window, grabbed: SDL_bool);
 }
 extern "C" {
-    #[doc = " Get a window's input grab mode."]
-    #[doc = ""]
-    #[doc = " \\param window the window to query"]
-    #[doc = " \\returns SDL_TRUE if input is grabbed, SDL_FALSE otherwise."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_SetWindowGrab"]
+    #[doc = " Get a window's input grab mode.\n\n \\param window the window to query\n \\returns SDL_TRUE if input is grabbed, SDL_FALSE otherwise.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_SetWindowGrab"]
     pub fn SDL_GetWindowGrab(window: *mut SDL_Window) -> SDL_bool;
 }
 extern "C" {
-    #[doc = " Get a window's keyboard grab mode."]
-    #[doc = ""]
-    #[doc = " \\param window the window to query"]
-    #[doc = " \\returns SDL_TRUE if keyboard is grabbed, and SDL_FALSE otherwise."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.16."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_SetWindowKeyboardGrab"]
-    #[doc = " \\sa SDL_GetWindowGrab"]
+    #[doc = " Get a window's keyboard grab mode.\n\n \\param window the window to query\n \\returns SDL_TRUE if keyboard is grabbed, and SDL_FALSE otherwise.\n\n \\since This function is available since SDL 2.0.16.\n\n \\sa SDL_SetWindowKeyboardGrab\n \\sa SDL_GetWindowGrab"]
     pub fn SDL_GetWindowKeyboardGrab(window: *mut SDL_Window) -> SDL_bool;
 }
 extern "C" {
-    #[doc = " Get a window's mouse grab mode."]
-    #[doc = ""]
-    #[doc = " \\param window the window to query"]
-    #[doc = " \\returns SDL_TRUE if mouse is grabbed, and SDL_FALSE otherwise."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.16."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_SetWindowKeyboardGrab"]
-    #[doc = " \\sa SDL_GetWindowGrab"]
+    #[doc = " Get a window's mouse grab mode.\n\n \\param window the window to query\n \\returns SDL_TRUE if mouse is grabbed, and SDL_FALSE otherwise.\n\n \\since This function is available since SDL 2.0.16.\n\n \\sa SDL_SetWindowKeyboardGrab\n \\sa SDL_GetWindowGrab"]
     pub fn SDL_GetWindowMouseGrab(window: *mut SDL_Window) -> SDL_bool;
 }
 extern "C" {
-    #[doc = " Get the window that currently has an input grab enabled."]
-    #[doc = ""]
-    #[doc = " \\returns the window if input is grabbed or NULL otherwise."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.4."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_GetWindowGrab"]
-    #[doc = " \\sa SDL_SetWindowGrab"]
+    #[doc = " Get the window that currently has an input grab enabled.\n\n \\returns the window if input is grabbed or NULL otherwise.\n\n \\since This function is available since SDL 2.0.4.\n\n \\sa SDL_GetWindowGrab\n \\sa SDL_SetWindowGrab"]
     pub fn SDL_GetGrabbedWindow() -> *mut SDL_Window;
 }
 extern "C" {
-    #[doc = " Confines the cursor to the specified area of a window."]
-    #[doc = ""]
-    #[doc = " Note that this does NOT grab the cursor, it only defines the area a cursor"]
-    #[doc = " is restricted to when the window has mouse focus."]
-    #[doc = ""]
-    #[doc = " \\param window The window that will be associated with the barrier."]
-    #[doc = " \\param rect A rectangle area in window-relative coordinates. If NULL the"]
-    #[doc = "             barrier for the specified window will be destroyed."]
-    #[doc = " \\returns 0 on success or a negative error code on failure; call"]
-    #[doc = "          SDL_GetError() for more information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.18."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_GetWindowMouseRect"]
-    #[doc = " \\sa SDL_SetWindowMouseGrab"]
+    #[doc = " Confines the cursor to the specified area of a window.\n\n Note that this does NOT grab the cursor, it only defines the area a cursor\n is restricted to when the window has mouse focus.\n\n \\param window The window that will be associated with the barrier.\n \\param rect A rectangle area in window-relative coordinates. If NULL the\n             barrier for the specified window will be destroyed.\n \\returns 0 on success or a negative error code on failure; call\n          SDL_GetError() for more information.\n\n \\since This function is available since SDL 2.0.18.\n\n \\sa SDL_GetWindowMouseRect\n \\sa SDL_SetWindowMouseGrab"]
     pub fn SDL_SetWindowMouseRect(window: *mut SDL_Window, rect: *const SDL_Rect) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Get the mouse confinement rectangle of a window."]
-    #[doc = ""]
-    #[doc = " \\param window The window to query"]
-    #[doc = " \\returns A pointer to the mouse confinement rectangle of a window, or NULL"]
-    #[doc = "          if there isn't one."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.18."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_SetWindowMouseRect"]
+    #[doc = " Get the mouse confinement rectangle of a window.\n\n \\param window The window to query\n \\returns A pointer to the mouse confinement rectangle of a window, or NULL\n          if there isn't one.\n\n \\since This function is available since SDL 2.0.18.\n\n \\sa SDL_SetWindowMouseRect"]
     pub fn SDL_GetWindowMouseRect(window: *mut SDL_Window) -> *const SDL_Rect;
 }
 extern "C" {
-    #[doc = " Set the brightness (gamma multiplier) for a given window's display."]
-    #[doc = ""]
-    #[doc = " Despite the name and signature, this method sets the brightness of the"]
-    #[doc = " entire display, not an individual window. A window is considered to be"]
-    #[doc = " owned by the display that contains the window's center pixel. (The index of"]
-    #[doc = " this display can be retrieved using SDL_GetWindowDisplayIndex().) The"]
-    #[doc = " brightness set will not follow the window if it is moved to another"]
-    #[doc = " display."]
-    #[doc = ""]
-    #[doc = " Many platforms will refuse to set the display brightness in modern times."]
-    #[doc = " You are better off using a shader to adjust gamma during rendering, or"]
-    #[doc = " something similar."]
-    #[doc = ""]
-    #[doc = " \\param window the window used to select the display whose brightness will"]
-    #[doc = "               be changed"]
-    #[doc = " \\param brightness the brightness (gamma multiplier) value to set where 0.0"]
-    #[doc = "                   is completely dark and 1.0 is normal brightness"]
-    #[doc = " \\returns 0 on success or a negative error code on failure; call"]
-    #[doc = "          SDL_GetError() for more information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_GetWindowBrightness"]
-    #[doc = " \\sa SDL_SetWindowGammaRamp"]
+    #[doc = " Set the brightness (gamma multiplier) for a given window's display.\n\n Despite the name and signature, this method sets the brightness of the\n entire display, not an individual window. A window is considered to be\n owned by the display that contains the window's center pixel. (The index of\n this display can be retrieved using SDL_GetWindowDisplayIndex().) The\n brightness set will not follow the window if it is moved to another\n display.\n\n Many platforms will refuse to set the display brightness in modern times.\n You are better off using a shader to adjust gamma during rendering, or\n something similar.\n\n \\param window the window used to select the display whose brightness will\n               be changed\n \\param brightness the brightness (gamma multiplier) value to set where 0.0\n                   is completely dark and 1.0 is normal brightness\n \\returns 0 on success or a negative error code on failure; call\n          SDL_GetError() for more information.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_GetWindowBrightness\n \\sa SDL_SetWindowGammaRamp"]
     pub fn SDL_SetWindowBrightness(window: *mut SDL_Window, brightness: f32) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Get the brightness (gamma multiplier) for a given window's display."]
-    #[doc = ""]
-    #[doc = " Despite the name and signature, this method retrieves the brightness of the"]
-    #[doc = " entire display, not an individual window. A window is considered to be"]
-    #[doc = " owned by the display that contains the window's center pixel. (The index of"]
-    #[doc = " this display can be retrieved using SDL_GetWindowDisplayIndex().)"]
-    #[doc = ""]
-    #[doc = " \\param window the window used to select the display whose brightness will"]
-    #[doc = "               be queried"]
-    #[doc = " \\returns the brightness for the display where 0.0 is completely dark and"]
-    #[doc = "          1.0 is normal brightness."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_SetWindowBrightness"]
+    #[doc = " Get the brightness (gamma multiplier) for a given window's display.\n\n Despite the name and signature, this method retrieves the brightness of the\n entire display, not an individual window. A window is considered to be\n owned by the display that contains the window's center pixel. (The index of\n this display can be retrieved using SDL_GetWindowDisplayIndex().)\n\n \\param window the window used to select the display whose brightness will\n               be queried\n \\returns the brightness for the display where 0.0 is completely dark and\n          1.0 is normal brightness.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_SetWindowBrightness"]
     pub fn SDL_GetWindowBrightness(window: *mut SDL_Window) -> f32;
 }
 extern "C" {
-    #[doc = " Set the opacity for a window."]
-    #[doc = ""]
-    #[doc = " The parameter `opacity` will be clamped internally between 0.0f"]
-    #[doc = " (transparent) and 1.0f (opaque)."]
-    #[doc = ""]
-    #[doc = " This function also returns -1 if setting the opacity isn't supported."]
-    #[doc = ""]
-    #[doc = " \\param window the window which will be made transparent or opaque"]
-    #[doc = " \\param opacity the opacity value (0.0f - transparent, 1.0f - opaque)"]
-    #[doc = " \\returns 0 on success or a negative error code on failure; call"]
-    #[doc = "          SDL_GetError() for more information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.5."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_GetWindowOpacity"]
+    #[doc = " Set the opacity for a window.\n\n The parameter `opacity` will be clamped internally between 0.0f\n (transparent) and 1.0f (opaque).\n\n This function also returns -1 if setting the opacity isn't supported.\n\n \\param window the window which will be made transparent or opaque\n \\param opacity the opacity value (0.0f - transparent, 1.0f - opaque)\n \\returns 0 on success or a negative error code on failure; call\n          SDL_GetError() for more information.\n\n \\since This function is available since SDL 2.0.5.\n\n \\sa SDL_GetWindowOpacity"]
     pub fn SDL_SetWindowOpacity(window: *mut SDL_Window, opacity: f32) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Get the opacity of a window."]
-    #[doc = ""]
-    #[doc = " If transparency isn't supported on this platform, opacity will be reported"]
-    #[doc = " as 1.0f without error."]
-    #[doc = ""]
-    #[doc = " The parameter `opacity` is ignored if it is NULL."]
-    #[doc = ""]
-    #[doc = " This function also returns -1 if an invalid window was provided."]
-    #[doc = ""]
-    #[doc = " \\param window the window to get the current opacity value from"]
-    #[doc = " \\param out_opacity the float filled in (0.0f - transparent, 1.0f - opaque)"]
-    #[doc = " \\returns 0 on success or a negative error code on failure; call"]
-    #[doc = "          SDL_GetError() for more information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.5."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_SetWindowOpacity"]
+    #[doc = " Get the opacity of a window.\n\n If transparency isn't supported on this platform, opacity will be reported\n as 1.0f without error.\n\n The parameter `opacity` is ignored if it is NULL.\n\n This function also returns -1 if an invalid window was provided.\n\n \\param window the window to get the current opacity value from\n \\param out_opacity the float filled in (0.0f - transparent, 1.0f - opaque)\n \\returns 0 on success or a negative error code on failure; call\n          SDL_GetError() for more information.\n\n \\since This function is available since SDL 2.0.5.\n\n \\sa SDL_SetWindowOpacity"]
     pub fn SDL_GetWindowOpacity(window: *mut SDL_Window, out_opacity: *mut f32) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Set the window as a modal for another window."]
-    #[doc = ""]
-    #[doc = " \\param modal_window the window that should be set modal"]
-    #[doc = " \\param parent_window the parent window for the modal window"]
-    #[doc = " \\returns 0 on success or a negative error code on failure; call"]
-    #[doc = "          SDL_GetError() for more information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.5."]
+    #[doc = " Set the window as a modal for another window.\n\n \\param modal_window the window that should be set modal\n \\param parent_window the parent window for the modal window\n \\returns 0 on success or a negative error code on failure; call\n          SDL_GetError() for more information.\n\n \\since This function is available since SDL 2.0.5."]
     pub fn SDL_SetWindowModalFor(
         modal_window: *mut SDL_Window,
         parent_window: *mut SDL_Window,
     ) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Explicitly set input focus to the window."]
-    #[doc = ""]
-    #[doc = " You almost certainly want SDL_RaiseWindow() instead of this function. Use"]
-    #[doc = " this with caution, as you might give focus to a window that is completely"]
-    #[doc = " obscured by other windows."]
-    #[doc = ""]
-    #[doc = " \\param window the window that should get the input focus"]
-    #[doc = " \\returns 0 on success or a negative error code on failure; call"]
-    #[doc = "          SDL_GetError() for more information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.5."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_RaiseWindow"]
+    #[doc = " Explicitly set input focus to the window.\n\n You almost certainly want SDL_RaiseWindow() instead of this function. Use\n this with caution, as you might give focus to a window that is completely\n obscured by other windows.\n\n \\param window the window that should get the input focus\n \\returns 0 on success or a negative error code on failure; call\n          SDL_GetError() for more information.\n\n \\since This function is available since SDL 2.0.5.\n\n \\sa SDL_RaiseWindow"]
     pub fn SDL_SetWindowInputFocus(window: *mut SDL_Window) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Set the gamma ramp for the display that owns a given window."]
-    #[doc = ""]
-    #[doc = " Set the gamma translation table for the red, green, and blue channels of"]
-    #[doc = " the video hardware. Each table is an array of 256 16-bit quantities,"]
-    #[doc = " representing a mapping between the input and output for that channel. The"]
-    #[doc = " input is the index into the array, and the output is the 16-bit gamma value"]
-    #[doc = " at that index, scaled to the output color precision."]
-    #[doc = ""]
-    #[doc = " Despite the name and signature, this method sets the gamma ramp of the"]
-    #[doc = " entire display, not an individual window. A window is considered to be"]
-    #[doc = " owned by the display that contains the window's center pixel. (The index of"]
-    #[doc = " this display can be retrieved using SDL_GetWindowDisplayIndex().) The gamma"]
-    #[doc = " ramp set will not follow the window if it is moved to another display."]
-    #[doc = ""]
-    #[doc = " \\param window the window used to select the display whose gamma ramp will"]
-    #[doc = "               be changed"]
-    #[doc = " \\param red a 256 element array of 16-bit quantities representing the"]
-    #[doc = "            translation table for the red channel, or NULL"]
-    #[doc = " \\param green a 256 element array of 16-bit quantities representing the"]
-    #[doc = "              translation table for the green channel, or NULL"]
-    #[doc = " \\param blue a 256 element array of 16-bit quantities representing the"]
-    #[doc = "             translation table for the blue channel, or NULL"]
-    #[doc = " \\returns 0 on success or a negative error code on failure; call"]
-    #[doc = "          SDL_GetError() for more information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_GetWindowGammaRamp"]
+    #[doc = " Set the gamma ramp for the display that owns a given window.\n\n Set the gamma translation table for the red, green, and blue channels of\n the video hardware. Each table is an array of 256 16-bit quantities,\n representing a mapping between the input and output for that channel. The\n input is the index into the array, and the output is the 16-bit gamma value\n at that index, scaled to the output color precision.\n\n Despite the name and signature, this method sets the gamma ramp of the\n entire display, not an individual window. A window is considered to be\n owned by the display that contains the window's center pixel. (The index of\n this display can be retrieved using SDL_GetWindowDisplayIndex().) The gamma\n ramp set will not follow the window if it is moved to another display.\n\n \\param window the window used to select the display whose gamma ramp will\n               be changed\n \\param red a 256 element array of 16-bit quantities representing the\n            translation table for the red channel, or NULL\n \\param green a 256 element array of 16-bit quantities representing the\n              translation table for the green channel, or NULL\n \\param blue a 256 element array of 16-bit quantities representing the\n             translation table for the blue channel, or NULL\n \\returns 0 on success or a negative error code on failure; call\n          SDL_GetError() for more information.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_GetWindowGammaRamp"]
     pub fn SDL_SetWindowGammaRamp(
         window: *mut SDL_Window,
         red: *const Uint16,
@@ -11572,27 +7219,7 @@ extern "C" {
     ) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Get the gamma ramp for a given window's display."]
-    #[doc = ""]
-    #[doc = " Despite the name and signature, this method retrieves the gamma ramp of the"]
-    #[doc = " entire display, not an individual window. A window is considered to be"]
-    #[doc = " owned by the display that contains the window's center pixel. (The index of"]
-    #[doc = " this display can be retrieved using SDL_GetWindowDisplayIndex().)"]
-    #[doc = ""]
-    #[doc = " \\param window the window used to select the display whose gamma ramp will"]
-    #[doc = "               be queried"]
-    #[doc = " \\param red a 256 element array of 16-bit quantities filled in with the"]
-    #[doc = "            translation table for the red channel, or NULL"]
-    #[doc = " \\param green a 256 element array of 16-bit quantities filled in with the"]
-    #[doc = "              translation table for the green channel, or NULL"]
-    #[doc = " \\param blue a 256 element array of 16-bit quantities filled in with the"]
-    #[doc = "             translation table for the blue channel, or NULL"]
-    #[doc = " \\returns 0 on success or a negative error code on failure; call"]
-    #[doc = "          SDL_GetError() for more information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_SetWindowGammaRamp"]
+    #[doc = " Get the gamma ramp for a given window's display.\n\n Despite the name and signature, this method retrieves the gamma ramp of the\n entire display, not an individual window. A window is considered to be\n owned by the display that contains the window's center pixel. (The index of\n this display can be retrieved using SDL_GetWindowDisplayIndex().)\n\n \\param window the window used to select the display whose gamma ramp will\n               be queried\n \\param red a 256 element array of 16-bit quantities filled in with the\n            translation table for the red channel, or NULL\n \\param green a 256 element array of 16-bit quantities filled in with the\n              translation table for the green channel, or NULL\n \\param blue a 256 element array of 16-bit quantities filled in with the\n             translation table for the blue channel, or NULL\n \\returns 0 on success or a negative error code on failure; call\n          SDL_GetError() for more information.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_SetWindowGammaRamp"]
     pub fn SDL_GetWindowGammaRamp(
         window: *mut SDL_Window,
         red: *mut Uint16,
@@ -11601,10 +7228,8 @@ extern "C" {
     ) -> libc::c_int;
 }
 #[repr(u32)]
-#[doc = " Possible return values from the SDL_HitTest callback."]
-#[doc = ""]
-#[doc = " \\sa SDL_HitTest"]
-#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
+#[doc = " Possible return values from the SDL_HitTest callback.\n\n \\sa SDL_HitTest"]
+#[derive(Copy, Clone, Hash, PartialEq, Eq)]
 pub enum SDL_HitTestResult {
     #[doc = "< Region is normal. No special properties."]
     SDL_HITTEST_NORMAL = 0,
@@ -11619,14 +7244,7 @@ pub enum SDL_HitTestResult {
     SDL_HITTEST_RESIZE_BOTTOMLEFT = 8,
     SDL_HITTEST_RESIZE_LEFT = 9,
 }
-#[doc = " Callback used for hit-testing."]
-#[doc = ""]
-#[doc = " \\param win the SDL_Window where hit-testing was set on"]
-#[doc = " \\param area an SDL_Point which should be hit-tested"]
-#[doc = " \\param data what was passed as `callback_data` to SDL_SetWindowHitTest()"]
-#[doc = " \\return an SDL_HitTestResult value."]
-#[doc = ""]
-#[doc = " \\sa SDL_SetWindowHitTest"]
+#[doc = " Callback used for hit-testing.\n\n \\param win the SDL_Window where hit-testing was set on\n \\param area an SDL_Point which should be hit-tested\n \\param data what was passed as `callback_data` to SDL_SetWindowHitTest()\n \\return an SDL_HitTestResult value.\n\n \\sa SDL_SetWindowHitTest"]
 pub type SDL_HitTest = ::core::option::Option<
     unsafe extern "C" fn(
         win: *mut SDL_Window,
@@ -11635,44 +7253,7 @@ pub type SDL_HitTest = ::core::option::Option<
     ) -> SDL_HitTestResult,
 >;
 extern "C" {
-    #[doc = " Provide a callback that decides if a window region has special properties."]
-    #[doc = ""]
-    #[doc = " Normally windows are dragged and resized by decorations provided by the"]
-    #[doc = " system window manager (a title bar, borders, etc), but for some apps, it"]
-    #[doc = " makes sense to drag them from somewhere else inside the window itself; for"]
-    #[doc = " example, one might have a borderless window that wants to be draggable from"]
-    #[doc = " any part, or simulate its own title bar, etc."]
-    #[doc = ""]
-    #[doc = " This function lets the app provide a callback that designates pieces of a"]
-    #[doc = " given window as special. This callback is run during event processing if we"]
-    #[doc = " need to tell the OS to treat a region of the window specially; the use of"]
-    #[doc = " this callback is known as \"hit testing.\""]
-    #[doc = ""]
-    #[doc = " Mouse input may not be delivered to your application if it is within a"]
-    #[doc = " special area; the OS will often apply that input to moving the window or"]
-    #[doc = " resizing the window and not deliver it to the application."]
-    #[doc = ""]
-    #[doc = " Specifying NULL for a callback disables hit-testing. Hit-testing is"]
-    #[doc = " disabled by default."]
-    #[doc = ""]
-    #[doc = " Platforms that don't support this functionality will return -1"]
-    #[doc = " unconditionally, even if you're attempting to disable hit-testing."]
-    #[doc = ""]
-    #[doc = " Your callback may fire at any time, and its firing does not indicate any"]
-    #[doc = " specific behavior (for example, on Windows, this certainly might fire when"]
-    #[doc = " the OS is deciding whether to drag your window, but it fires for lots of"]
-    #[doc = " other reasons, too, some unrelated to anything you probably care about _and"]
-    #[doc = " when the mouse isn't actually at the location it is testing_). Since this"]
-    #[doc = " can fire at any time, you should try to keep your callback efficient,"]
-    #[doc = " devoid of allocations, etc."]
-    #[doc = ""]
-    #[doc = " \\param window the window to set hit-testing on"]
-    #[doc = " \\param callback the function to call when doing a hit-test"]
-    #[doc = " \\param callback_data an app-defined void pointer passed to **callback**"]
-    #[doc = " \\returns 0 on success or -1 on error (including unsupported); call"]
-    #[doc = "          SDL_GetError() for more information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.4."]
+    #[doc = " Provide a callback that decides if a window region has special properties.\n\n Normally windows are dragged and resized by decorations provided by the\n system window manager (a title bar, borders, etc), but for some apps, it\n makes sense to drag them from somewhere else inside the window itself; for\n example, one might have a borderless window that wants to be draggable from\n any part, or simulate its own title bar, etc.\n\n This function lets the app provide a callback that designates pieces of a\n given window as special. This callback is run during event processing if we\n need to tell the OS to treat a region of the window specially; the use of\n this callback is known as \"hit testing.\"\n\n Mouse input may not be delivered to your application if it is within a\n special area; the OS will often apply that input to moving the window or\n resizing the window and not deliver it to the application.\n\n Specifying NULL for a callback disables hit-testing. Hit-testing is\n disabled by default.\n\n Platforms that don't support this functionality will return -1\n unconditionally, even if you're attempting to disable hit-testing.\n\n Your callback may fire at any time, and its firing does not indicate any\n specific behavior (for example, on Windows, this certainly might fire when\n the OS is deciding whether to drag your window, but it fires for lots of\n other reasons, too, some unrelated to anything you probably care about _and\n when the mouse isn't actually at the location it is testing_). Since this\n can fire at any time, you should try to keep your callback efficient,\n devoid of allocations, etc.\n\n \\param window the window to set hit-testing on\n \\param callback the function to call when doing a hit-test\n \\param callback_data an app-defined void pointer passed to **callback**\n \\returns 0 on success or -1 on error (including unsupported); call\n          SDL_GetError() for more information.\n\n \\since This function is available since SDL 2.0.4."]
     pub fn SDL_SetWindowHitTest(
         window: *mut SDL_Window,
         callback: SDL_HitTest,
@@ -11680,286 +7261,71 @@ extern "C" {
     ) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Request a window to demand attention from the user."]
-    #[doc = ""]
-    #[doc = " \\param window the window to be flashed"]
-    #[doc = " \\param operation the flash operation"]
-    #[doc = " \\returns 0 on success or a negative error code on failure; call"]
-    #[doc = "          SDL_GetError() for more information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.16."]
+    #[doc = " Request a window to demand attention from the user.\n\n \\param window the window to be flashed\n \\param operation the flash operation\n \\returns 0 on success or a negative error code on failure; call\n          SDL_GetError() for more information.\n\n \\since This function is available since SDL 2.0.16."]
     pub fn SDL_FlashWindow(window: *mut SDL_Window, operation: SDL_FlashOperation) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Destroy a window."]
-    #[doc = ""]
-    #[doc = " If `window` is NULL, this function will return immediately after setting"]
-    #[doc = " the SDL error message to \"Invalid window\". See SDL_GetError()."]
-    #[doc = ""]
-    #[doc = " \\param window the window to destroy"]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_CreateWindow"]
-    #[doc = " \\sa SDL_CreateWindowFrom"]
+    #[doc = " Destroy a window.\n\n If `window` is NULL, this function will return immediately after setting\n the SDL error message to \"Invalid window\". See SDL_GetError().\n\n \\param window the window to destroy\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_CreateWindow\n \\sa SDL_CreateWindowFrom"]
     pub fn SDL_DestroyWindow(window: *mut SDL_Window);
 }
 extern "C" {
-    #[doc = " Check whether the screensaver is currently enabled."]
-    #[doc = ""]
-    #[doc = " The screensaver is disabled by default since SDL 2.0.2. Before SDL 2.0.2"]
-    #[doc = " the screensaver was enabled by default."]
-    #[doc = ""]
-    #[doc = " The default can also be changed using `SDL_HINT_VIDEO_ALLOW_SCREENSAVER`."]
-    #[doc = ""]
-    #[doc = " \\returns SDL_TRUE if the screensaver is enabled, SDL_FALSE if it is"]
-    #[doc = "          disabled."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_DisableScreenSaver"]
-    #[doc = " \\sa SDL_EnableScreenSaver"]
+    #[doc = " Check whether the screensaver is currently enabled.\n\n The screensaver is disabled by default since SDL 2.0.2. Before SDL 2.0.2\n the screensaver was enabled by default.\n\n The default can also be changed using `SDL_HINT_VIDEO_ALLOW_SCREENSAVER`.\n\n \\returns SDL_TRUE if the screensaver is enabled, SDL_FALSE if it is\n          disabled.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_DisableScreenSaver\n \\sa SDL_EnableScreenSaver"]
     pub fn SDL_IsScreenSaverEnabled() -> SDL_bool;
 }
 extern "C" {
-    #[doc = " Allow the screen to be blanked by a screen saver."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_DisableScreenSaver"]
-    #[doc = " \\sa SDL_IsScreenSaverEnabled"]
+    #[doc = " Allow the screen to be blanked by a screen saver.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_DisableScreenSaver\n \\sa SDL_IsScreenSaverEnabled"]
     pub fn SDL_EnableScreenSaver();
 }
 extern "C" {
-    #[doc = " Prevent the screen from being blanked by a screen saver."]
-    #[doc = ""]
-    #[doc = " If you disable the screensaver, it is automatically re-enabled when SDL"]
-    #[doc = " quits."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_EnableScreenSaver"]
-    #[doc = " \\sa SDL_IsScreenSaverEnabled"]
+    #[doc = " Prevent the screen from being blanked by a screen saver.\n\n If you disable the screensaver, it is automatically re-enabled when SDL\n quits.\n\n The screensaver is disabled by default since SDL 2.0.2. Before SDL 2.0.2\n the screensaver was enabled by default.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_EnableScreenSaver\n \\sa SDL_IsScreenSaverEnabled"]
     pub fn SDL_DisableScreenSaver();
 }
 extern "C" {
-    #[doc = " Dynamically load an OpenGL library."]
-    #[doc = ""]
-    #[doc = " This should be done after initializing the video driver, but before"]
-    #[doc = " creating any OpenGL windows. If no OpenGL library is loaded, the default"]
-    #[doc = " library will be loaded upon creation of the first OpenGL window."]
-    #[doc = ""]
-    #[doc = " If you do this, you need to retrieve all of the GL functions used in your"]
-    #[doc = " program from the dynamic library using SDL_GL_GetProcAddress()."]
-    #[doc = ""]
-    #[doc = " \\param path the platform dependent OpenGL library name, or NULL to open the"]
-    #[doc = "             default OpenGL library"]
-    #[doc = " \\returns 0 on success or a negative error code on failure; call"]
-    #[doc = "          SDL_GetError() for more information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_GL_GetProcAddress"]
-    #[doc = " \\sa SDL_GL_UnloadLibrary"]
+    #[doc = " Dynamically load an OpenGL library.\n\n This should be done after initializing the video driver, but before\n creating any OpenGL windows. If no OpenGL library is loaded, the default\n library will be loaded upon creation of the first OpenGL window.\n\n If you do this, you need to retrieve all of the GL functions used in your\n program from the dynamic library using SDL_GL_GetProcAddress().\n\n \\param path the platform dependent OpenGL library name, or NULL to open the\n             default OpenGL library\n \\returns 0 on success or a negative error code on failure; call\n          SDL_GetError() for more information.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_GL_GetProcAddress\n \\sa SDL_GL_UnloadLibrary"]
     pub fn SDL_GL_LoadLibrary(path: *const libc::c_char) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Get an OpenGL function by name."]
-    #[doc = ""]
-    #[doc = " If the GL library is loaded at runtime with SDL_GL_LoadLibrary(), then all"]
-    #[doc = " GL functions must be retrieved this way. Usually this is used to retrieve"]
-    #[doc = " function pointers to OpenGL extensions."]
-    #[doc = ""]
-    #[doc = " There are some quirks to looking up OpenGL functions that require some"]
-    #[doc = " extra care from the application. If you code carefully, you can handle"]
-    #[doc = " these quirks without any platform-specific code, though:"]
-    #[doc = ""]
-    #[doc = " - On Windows, function pointers are specific to the current GL context;"]
-    #[doc = "   this means you need to have created a GL context and made it current"]
-    #[doc = "   before calling SDL_GL_GetProcAddress(). If you recreate your context or"]
-    #[doc = "   create a second context, you should assume that any existing function"]
-    #[doc = "   pointers aren't valid to use with it. This is (currently) a"]
-    #[doc = "   Windows-specific limitation, and in practice lots of drivers don't suffer"]
-    #[doc = "   this limitation, but it is still the way the wgl API is documented to"]
-    #[doc = "   work and you should expect crashes if you don't respect it. Store a copy"]
-    #[doc = "   of the function pointers that comes and goes with context lifespan."]
-    #[doc = " - On X11, function pointers returned by this function are valid for any"]
-    #[doc = "   context, and can even be looked up before a context is created at all."]
-    #[doc = "   This means that, for at least some common OpenGL implementations, if you"]
-    #[doc = "   look up a function that doesn't exist, you'll get a non-NULL result that"]
-    #[doc = "   is _NOT_ safe to call. You must always make sure the function is actually"]
-    #[doc = "   available for a given GL context before calling it, by checking for the"]
-    #[doc = "   existence of the appropriate extension with SDL_GL_ExtensionSupported(),"]
-    #[doc = "   or verifying that the version of OpenGL you're using offers the function"]
-    #[doc = "   as core functionality."]
-    #[doc = " - Some OpenGL drivers, on all platforms, *will* return NULL if a function"]
-    #[doc = "   isn't supported, but you can't count on this behavior. Check for"]
-    #[doc = "   extensions you use, and if you get a NULL anyway, act as if that"]
-    #[doc = "   extension wasn't available. This is probably a bug in the driver, but you"]
-    #[doc = "   can code defensively for this scenario anyhow."]
-    #[doc = " - Just because you're on Linux/Unix, don't assume you'll be using X11."]
-    #[doc = "   Next-gen display servers are waiting to replace it, and may or may not"]
-    #[doc = "   make the same promises about function pointers."]
-    #[doc = " - OpenGL function pointers must be declared `APIENTRY` as in the example"]
-    #[doc = "   code. This will ensure the proper calling convention is followed on"]
-    #[doc = "   platforms where this matters (Win32) thereby avoiding stack corruption."]
-    #[doc = ""]
-    #[doc = " \\param proc the name of an OpenGL function"]
-    #[doc = " \\returns a pointer to the named OpenGL function. The returned pointer"]
-    #[doc = "          should be cast to the appropriate function signature."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_GL_ExtensionSupported"]
-    #[doc = " \\sa SDL_GL_LoadLibrary"]
-    #[doc = " \\sa SDL_GL_UnloadLibrary"]
+    #[doc = " Get an OpenGL function by name.\n\n If the GL library is loaded at runtime with SDL_GL_LoadLibrary(), then all\n GL functions must be retrieved this way. Usually this is used to retrieve\n function pointers to OpenGL extensions.\n\n There are some quirks to looking up OpenGL functions that require some\n extra care from the application. If you code carefully, you can handle\n these quirks without any platform-specific code, though:\n\n - On Windows, function pointers are specific to the current GL context;\n   this means you need to have created a GL context and made it current\n   before calling SDL_GL_GetProcAddress(). If you recreate your context or\n   create a second context, you should assume that any existing function\n   pointers aren't valid to use with it. This is (currently) a\n   Windows-specific limitation, and in practice lots of drivers don't suffer\n   this limitation, but it is still the way the wgl API is documented to\n   work and you should expect crashes if you don't respect it. Store a copy\n   of the function pointers that comes and goes with context lifespan.\n - On X11, function pointers returned by this function are valid for any\n   context, and can even be looked up before a context is created at all.\n   This means that, for at least some common OpenGL implementations, if you\n   look up a function that doesn't exist, you'll get a non-NULL result that\n   is _NOT_ safe to call. You must always make sure the function is actually\n   available for a given GL context before calling it, by checking for the\n   existence of the appropriate extension with SDL_GL_ExtensionSupported(),\n   or verifying that the version of OpenGL you're using offers the function\n   as core functionality.\n - Some OpenGL drivers, on all platforms, *will* return NULL if a function\n   isn't supported, but you can't count on this behavior. Check for\n   extensions you use, and if you get a NULL anyway, act as if that\n   extension wasn't available. This is probably a bug in the driver, but you\n   can code defensively for this scenario anyhow.\n - Just because you're on Linux/Unix, don't assume you'll be using X11.\n   Next-gen display servers are waiting to replace it, and may or may not\n   make the same promises about function pointers.\n - OpenGL function pointers must be declared `APIENTRY` as in the example\n   code. This will ensure the proper calling convention is followed on\n   platforms where this matters (Win32) thereby avoiding stack corruption.\n\n \\param proc the name of an OpenGL function\n \\returns a pointer to the named OpenGL function. The returned pointer\n          should be cast to the appropriate function signature.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_GL_ExtensionSupported\n \\sa SDL_GL_LoadLibrary\n \\sa SDL_GL_UnloadLibrary"]
     pub fn SDL_GL_GetProcAddress(proc_: *const libc::c_char) -> *mut libc::c_void;
 }
 extern "C" {
-    #[doc = " Unload the OpenGL library previously loaded by SDL_GL_LoadLibrary()."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_GL_LoadLibrary"]
+    #[doc = " Unload the OpenGL library previously loaded by SDL_GL_LoadLibrary().\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_GL_LoadLibrary"]
     pub fn SDL_GL_UnloadLibrary();
 }
 extern "C" {
-    #[doc = " Check if an OpenGL extension is supported for the current context."]
-    #[doc = ""]
-    #[doc = " This function operates on the current GL context; you must have created a"]
-    #[doc = " context and it must be current before calling this function. Do not assume"]
-    #[doc = " that all contexts you create will have the same set of extensions"]
-    #[doc = " available, or that recreating an existing context will offer the same"]
-    #[doc = " extensions again."]
-    #[doc = ""]
-    #[doc = " While it's probably not a massive overhead, this function is not an O(1)"]
-    #[doc = " operation. Check the extensions you care about after creating the GL"]
-    #[doc = " context and save that information somewhere instead of calling the function"]
-    #[doc = " every time you need to know."]
-    #[doc = ""]
-    #[doc = " \\param extension the name of the extension to check"]
-    #[doc = " \\returns SDL_TRUE if the extension is supported, SDL_FALSE otherwise."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
+    #[doc = " Check if an OpenGL extension is supported for the current context.\n\n This function operates on the current GL context; you must have created a\n context and it must be current before calling this function. Do not assume\n that all contexts you create will have the same set of extensions\n available, or that recreating an existing context will offer the same\n extensions again.\n\n While it's probably not a massive overhead, this function is not an O(1)\n operation. Check the extensions you care about after creating the GL\n context and save that information somewhere instead of calling the function\n every time you need to know.\n\n \\param extension the name of the extension to check\n \\returns SDL_TRUE if the extension is supported, SDL_FALSE otherwise.\n\n \\since This function is available since SDL 2.0.0."]
     pub fn SDL_GL_ExtensionSupported(extension: *const libc::c_char) -> SDL_bool;
 }
 extern "C" {
-    #[doc = " Reset all previously set OpenGL context attributes to their default values."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.2."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_GL_GetAttribute"]
-    #[doc = " \\sa SDL_GL_SetAttribute"]
+    #[doc = " Reset all previously set OpenGL context attributes to their default values.\n\n \\since This function is available since SDL 2.0.2.\n\n \\sa SDL_GL_GetAttribute\n \\sa SDL_GL_SetAttribute"]
     pub fn SDL_GL_ResetAttributes();
 }
 extern "C" {
-    #[doc = " Set an OpenGL window attribute before window creation."]
-    #[doc = ""]
-    #[doc = " This function sets the OpenGL attribute `attr` to `value`. The requested"]
-    #[doc = " attributes should be set before creating an OpenGL window. You should use"]
-    #[doc = " SDL_GL_GetAttribute() to check the values after creating the OpenGL"]
-    #[doc = " context, since the values obtained can differ from the requested ones."]
-    #[doc = ""]
-    #[doc = " \\param attr an SDL_GLattr enum value specifying the OpenGL attribute to set"]
-    #[doc = " \\param value the desired value for the attribute"]
-    #[doc = " \\returns 0 on success or a negative error code on failure; call"]
-    #[doc = "          SDL_GetError() for more information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_GL_GetAttribute"]
-    #[doc = " \\sa SDL_GL_ResetAttributes"]
+    #[doc = " Set an OpenGL window attribute before window creation.\n\n This function sets the OpenGL attribute `attr` to `value`. The requested\n attributes should be set before creating an OpenGL window. You should use\n SDL_GL_GetAttribute() to check the values after creating the OpenGL\n context, since the values obtained can differ from the requested ones.\n\n \\param attr an SDL_GLattr enum value specifying the OpenGL attribute to set\n \\param value the desired value for the attribute\n \\returns 0 on success or a negative error code on failure; call\n          SDL_GetError() for more information.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_GL_GetAttribute\n \\sa SDL_GL_ResetAttributes"]
     pub fn SDL_GL_SetAttribute(attr: SDL_GLattr, value: libc::c_int) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Get the actual value for an attribute from the current context."]
-    #[doc = ""]
-    #[doc = " \\param attr an SDL_GLattr enum value specifying the OpenGL attribute to get"]
-    #[doc = " \\param value a pointer filled in with the current value of `attr`"]
-    #[doc = " \\returns 0 on success or a negative error code on failure; call"]
-    #[doc = "          SDL_GetError() for more information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_GL_ResetAttributes"]
-    #[doc = " \\sa SDL_GL_SetAttribute"]
+    #[doc = " Get the actual value for an attribute from the current context.\n\n \\param attr an SDL_GLattr enum value specifying the OpenGL attribute to get\n \\param value a pointer filled in with the current value of `attr`\n \\returns 0 on success or a negative error code on failure; call\n          SDL_GetError() for more information.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_GL_ResetAttributes\n \\sa SDL_GL_SetAttribute"]
     pub fn SDL_GL_GetAttribute(attr: SDL_GLattr, value: *mut libc::c_int) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Create an OpenGL context for an OpenGL window, and make it current."]
-    #[doc = ""]
-    #[doc = " Windows users new to OpenGL should note that, for historical reasons, GL"]
-    #[doc = " functions added after OpenGL version 1.1 are not available by default."]
-    #[doc = " Those functions must be loaded at run-time, either with an OpenGL"]
-    #[doc = " extension-handling library or with SDL_GL_GetProcAddress() and its related"]
-    #[doc = " functions."]
-    #[doc = ""]
-    #[doc = " SDL_GLContext is an alias for `void *`. It's opaque to the application."]
-    #[doc = ""]
-    #[doc = " \\param window the window to associate with the context"]
-    #[doc = " \\returns the OpenGL context associated with `window` or NULL on error; call"]
-    #[doc = "          SDL_GetError() for more details."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_GL_DeleteContext"]
-    #[doc = " \\sa SDL_GL_MakeCurrent"]
+    #[doc = " Create an OpenGL context for an OpenGL window, and make it current.\n\n Windows users new to OpenGL should note that, for historical reasons, GL\n functions added after OpenGL version 1.1 are not available by default.\n Those functions must be loaded at run-time, either with an OpenGL\n extension-handling library or with SDL_GL_GetProcAddress() and its related\n functions.\n\n SDL_GLContext is an alias for `void *`. It's opaque to the application.\n\n \\param window the window to associate with the context\n \\returns the OpenGL context associated with `window` or NULL on error; call\n          SDL_GetError() for more details.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_GL_DeleteContext\n \\sa SDL_GL_MakeCurrent"]
     pub fn SDL_GL_CreateContext(window: *mut SDL_Window) -> SDL_GLContext;
 }
 extern "C" {
-    #[doc = " Set up an OpenGL context for rendering into an OpenGL window."]
-    #[doc = ""]
-    #[doc = " The context must have been created with a compatible window."]
-    #[doc = ""]
-    #[doc = " \\param window the window to associate with the context"]
-    #[doc = " \\param context the OpenGL context to associate with the window"]
-    #[doc = " \\returns 0 on success or a negative error code on failure; call"]
-    #[doc = "          SDL_GetError() for more information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_GL_CreateContext"]
+    #[doc = " Set up an OpenGL context for rendering into an OpenGL window.\n\n The context must have been created with a compatible window.\n\n \\param window the window to associate with the context\n \\param context the OpenGL context to associate with the window\n \\returns 0 on success or a negative error code on failure; call\n          SDL_GetError() for more information.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_GL_CreateContext"]
     pub fn SDL_GL_MakeCurrent(window: *mut SDL_Window, context: SDL_GLContext) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Get the currently active OpenGL window."]
-    #[doc = ""]
-    #[doc = " \\returns the currently active OpenGL window on success or NULL on failure;"]
-    #[doc = "          call SDL_GetError() for more information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
+    #[doc = " Get the currently active OpenGL window.\n\n \\returns the currently active OpenGL window on success or NULL on failure;\n          call SDL_GetError() for more information.\n\n \\since This function is available since SDL 2.0.0."]
     pub fn SDL_GL_GetCurrentWindow() -> *mut SDL_Window;
 }
 extern "C" {
-    #[doc = " Get the currently active OpenGL context."]
-    #[doc = ""]
-    #[doc = " \\returns the currently active OpenGL context or NULL on failure; call"]
-    #[doc = "          SDL_GetError() for more information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_GL_MakeCurrent"]
+    #[doc = " Get the currently active OpenGL context.\n\n \\returns the currently active OpenGL context or NULL on failure; call\n          SDL_GetError() for more information.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_GL_MakeCurrent"]
     pub fn SDL_GL_GetCurrentContext() -> SDL_GLContext;
 }
 extern "C" {
-    #[doc = " Get the size of a window's underlying drawable in pixels."]
-    #[doc = ""]
-    #[doc = " This returns info useful for calling glViewport()."]
-    #[doc = ""]
-    #[doc = " This may differ from SDL_GetWindowSize() if we're rendering to a high-DPI"]
-    #[doc = " drawable, i.e. the window was created with `SDL_WINDOW_ALLOW_HIGHDPI` on a"]
-    #[doc = " platform with high-DPI support (Apple calls this \"Retina\"), and not"]
-    #[doc = " disabled by the `SDL_HINT_VIDEO_HIGHDPI_DISABLED` hint."]
-    #[doc = ""]
-    #[doc = " \\param window the window from which the drawable size should be queried"]
-    #[doc = " \\param w a pointer to variable for storing the width in pixels, may be NULL"]
-    #[doc = " \\param h a pointer to variable for storing the height in pixels, may be"]
-    #[doc = "          NULL"]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.1."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_CreateWindow"]
-    #[doc = " \\sa SDL_GetWindowSize"]
+    #[doc = " Get the size of a window's underlying drawable in pixels.\n\n This returns info useful for calling glViewport().\n\n This may differ from SDL_GetWindowSize() if we're rendering to a high-DPI\n drawable, i.e. the window was created with `SDL_WINDOW_ALLOW_HIGHDPI` on a\n platform with high-DPI support (Apple calls this \"Retina\"), and not\n disabled by the `SDL_HINT_VIDEO_HIGHDPI_DISABLED` hint.\n\n \\param window the window from which the drawable size should be queried\n \\param w a pointer to variable for storing the width in pixels, may be NULL\n \\param h a pointer to variable for storing the height in pixels, may be\n          NULL\n\n \\since This function is available since SDL 2.0.1.\n\n \\sa SDL_CreateWindow\n \\sa SDL_GetWindowSize"]
     pub fn SDL_GL_GetDrawableSize(
         window: *mut SDL_Window,
         w: *mut libc::c_int,
@@ -11967,89 +7333,24 @@ extern "C" {
     );
 }
 extern "C" {
-    #[doc = " Set the swap interval for the current OpenGL context."]
-    #[doc = ""]
-    #[doc = " Some systems allow specifying -1 for the interval, to enable adaptive"]
-    #[doc = " vsync. Adaptive vsync works the same as vsync, but if you've already missed"]
-    #[doc = " the vertical retrace for a given frame, it swaps buffers immediately, which"]
-    #[doc = " might be less jarring for the user during occasional framerate drops. If an"]
-    #[doc = " application requests adaptive vsync and the system does not support it,"]
-    #[doc = " this function will fail and return -1. In such a case, you should probably"]
-    #[doc = " retry the call with 1 for the interval."]
-    #[doc = ""]
-    #[doc = " Adaptive vsync is implemented for some glX drivers with"]
-    #[doc = " GLX_EXT_swap_control_tear:"]
-    #[doc = ""]
-    #[doc = " https://www.opengl.org/registry/specs/EXT/glx_swap_control_tear.txt"]
-    #[doc = ""]
-    #[doc = " and for some Windows drivers with WGL_EXT_swap_control_tear:"]
-    #[doc = ""]
-    #[doc = " https://www.opengl.org/registry/specs/EXT/wgl_swap_control_tear.txt"]
-    #[doc = ""]
-    #[doc = " Read more on the Khronos wiki:"]
-    #[doc = " https://www.khronos.org/opengl/wiki/Swap_Interval#Adaptive_Vsync"]
-    #[doc = ""]
-    #[doc = " \\param interval 0 for immediate updates, 1 for updates synchronized with"]
-    #[doc = "                 the vertical retrace, -1 for adaptive vsync"]
-    #[doc = " \\returns 0 on success or -1 if setting the swap interval is not supported;"]
-    #[doc = "          call SDL_GetError() for more information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_GL_GetSwapInterval"]
+    #[doc = " Set the swap interval for the current OpenGL context.\n\n Some systems allow specifying -1 for the interval, to enable adaptive\n vsync. Adaptive vsync works the same as vsync, but if you've already missed\n the vertical retrace for a given frame, it swaps buffers immediately, which\n might be less jarring for the user during occasional framerate drops. If an\n application requests adaptive vsync and the system does not support it,\n this function will fail and return -1. In such a case, you should probably\n retry the call with 1 for the interval.\n\n Adaptive vsync is implemented for some glX drivers with\n GLX_EXT_swap_control_tear, and for some Windows drivers with\n WGL_EXT_swap_control_tear.\n\n Read more on the Khronos wiki:\n https://www.khronos.org/opengl/wiki/Swap_Interval#Adaptive_Vsync\n\n \\param interval 0 for immediate updates, 1 for updates synchronized with\n                 the vertical retrace, -1 for adaptive vsync\n \\returns 0 on success or -1 if setting the swap interval is not supported;\n          call SDL_GetError() for more information.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_GL_GetSwapInterval"]
     pub fn SDL_GL_SetSwapInterval(interval: libc::c_int) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Get the swap interval for the current OpenGL context."]
-    #[doc = ""]
-    #[doc = " If the system can't determine the swap interval, or there isn't a valid"]
-    #[doc = " current context, this function will return 0 as a safe default."]
-    #[doc = ""]
-    #[doc = " \\returns 0 if there is no vertical retrace synchronization, 1 if the buffer"]
-    #[doc = "          swap is synchronized with the vertical retrace, and -1 if late"]
-    #[doc = "          swaps happen immediately instead of waiting for the next retrace;"]
-    #[doc = "          call SDL_GetError() for more information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_GL_SetSwapInterval"]
+    #[doc = " Get the swap interval for the current OpenGL context.\n\n If the system can't determine the swap interval, or there isn't a valid\n current context, this function will return 0 as a safe default.\n\n \\returns 0 if there is no vertical retrace synchronization, 1 if the buffer\n          swap is synchronized with the vertical retrace, and -1 if late\n          swaps happen immediately instead of waiting for the next retrace;\n          call SDL_GetError() for more information.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_GL_SetSwapInterval"]
     pub fn SDL_GL_GetSwapInterval() -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Update a window with OpenGL rendering."]
-    #[doc = ""]
-    #[doc = " This is used with double-buffered OpenGL contexts, which are the default."]
-    #[doc = ""]
-    #[doc = " On macOS, make sure you bind 0 to the draw framebuffer before swapping the"]
-    #[doc = " window, otherwise nothing will happen. If you aren't using"]
-    #[doc = " glBindFramebuffer(), this is the default and you won't have to do anything"]
-    #[doc = " extra."]
-    #[doc = ""]
-    #[doc = " \\param window the window to change"]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
+    #[doc = " Update a window with OpenGL rendering.\n\n This is used with double-buffered OpenGL contexts, which are the default.\n\n On macOS, make sure you bind 0 to the draw framebuffer before swapping the\n window, otherwise nothing will happen. If you aren't using\n glBindFramebuffer(), this is the default and you won't have to do anything\n extra.\n\n \\param window the window to change\n\n \\since This function is available since SDL 2.0.0."]
     pub fn SDL_GL_SwapWindow(window: *mut SDL_Window);
 }
 extern "C" {
-    #[doc = " Delete an OpenGL context."]
-    #[doc = ""]
-    #[doc = " \\param context the OpenGL context to be deleted"]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_GL_CreateContext"]
+    #[doc = " Delete an OpenGL context.\n\n \\param context the OpenGL context to be deleted\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_GL_CreateContext"]
     pub fn SDL_GL_DeleteContext(context: SDL_GLContext);
 }
 #[repr(u32)]
-#[doc = "  \\brief The SDL keyboard scancode representation."]
-#[doc = ""]
-#[doc = "  Values of this type are used to represent keyboard keys, among other places"]
-#[doc = "  in the \\link SDL_Keysym::scancode key.keysym.scancode \\endlink field of the"]
-#[doc = "  SDL_Event structure."]
-#[doc = ""]
-#[doc = "  The values in this enumeration are based on the USB usage page standard:"]
-#[doc = "  https://www.usb.org/sites/default/files/documents/hut1_12v2.pdf"]
-#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
+#[doc = "  \\brief The SDL keyboard scancode representation.\n\n  Values of this type are used to represent keyboard keys, among other places\n  in the \\link SDL_Keysym::scancode key.keysym.scancode \\endlink field of the\n  SDL_Event structure.\n\n  The values in this enumeration are based on the USB usage page standard:\n  https://www.usb.org/sites/default/files/documents/hut1_12v2.pdf"]
+#[derive(Copy, Clone, Hash, PartialEq, Eq)]
 pub enum SDL_Scancode {
     SDL_SCANCODE_UNKNOWN = 0,
     SDL_SCANCODE_A = 4,
@@ -12097,50 +7398,13 @@ pub enum SDL_Scancode {
     SDL_SCANCODE_EQUALS = 46,
     SDL_SCANCODE_LEFTBRACKET = 47,
     SDL_SCANCODE_RIGHTBRACKET = 48,
-    #[doc = "< Located at the lower left of the return"]
-    #[doc = "   key on ISO keyboards and at the right end"]
-    #[doc = "   of the QWERTY row on ANSI keyboards."]
-    #[doc = "   Produces REVERSE SOLIDUS (backslash) and"]
-    #[doc = "   VERTICAL LINE in a US layout, REVERSE"]
-    #[doc = "   SOLIDUS and VERTICAL LINE in a UK Mac"]
-    #[doc = "   layout, NUMBER SIGN and TILDE in a UK"]
-    #[doc = "   Windows layout, DOLLAR SIGN and POUND SIGN"]
-    #[doc = "   in a Swiss German layout, NUMBER SIGN and"]
-    #[doc = "   APOSTROPHE in a German layout, GRAVE"]
-    #[doc = "   ACCENT and POUND SIGN in a French Mac"]
-    #[doc = "   layout, and ASTERISK and MICRO SIGN in a"]
-    #[doc = "   French Windows layout."]
+    #[doc = "< Located at the lower left of the return\n   key on ISO keyboards and at the right end\n   of the QWERTY row on ANSI keyboards.\n   Produces REVERSE SOLIDUS (backslash) and\n   VERTICAL LINE in a US layout, REVERSE\n   SOLIDUS and VERTICAL LINE in a UK Mac\n   layout, NUMBER SIGN and TILDE in a UK\n   Windows layout, DOLLAR SIGN and POUND SIGN\n   in a Swiss German layout, NUMBER SIGN and\n   APOSTROPHE in a German layout, GRAVE\n   ACCENT and POUND SIGN in a French Mac\n   layout, and ASTERISK and MICRO SIGN in a\n   French Windows layout."]
     SDL_SCANCODE_BACKSLASH = 49,
-    #[doc = "< ISO USB keyboards actually use this code"]
-    #[doc = "   instead of 49 for the same key, but all"]
-    #[doc = "   OSes I've seen treat the two codes"]
-    #[doc = "   identically. So, as an implementor, unless"]
-    #[doc = "   your keyboard generates both of those"]
-    #[doc = "   codes and your OS treats them differently,"]
-    #[doc = "   you should generate SDL_SCANCODE_BACKSLASH"]
-    #[doc = "   instead of this code. As a user, you"]
-    #[doc = "   should not rely on this code because SDL"]
-    #[doc = "   will never generate it with most (all?)"]
-    #[doc = "   keyboards."]
+    #[doc = "< ISO USB keyboards actually use this code\n   instead of 49 for the same key, but all\n   OSes I've seen treat the two codes\n   identically. So, as an implementor, unless\n   your keyboard generates both of those\n   codes and your OS treats them differently,\n   you should generate SDL_SCANCODE_BACKSLASH\n   instead of this code. As a user, you\n   should not rely on this code because SDL\n   will never generate it with most (all?)\n   keyboards."]
     SDL_SCANCODE_NONUSHASH = 50,
     SDL_SCANCODE_SEMICOLON = 51,
     SDL_SCANCODE_APOSTROPHE = 52,
-    #[doc = "< Located in the top left corner (on both ANSI"]
-    #[doc = "   and ISO keyboards). Produces GRAVE ACCENT and"]
-    #[doc = "   TILDE in a US Windows layout and in US and UK"]
-    #[doc = "   Mac layouts on ANSI keyboards, GRAVE ACCENT"]
-    #[doc = "   and NOT SIGN in a UK Windows layout, SECTION"]
-    #[doc = "   SIGN and PLUS-MINUS SIGN in US and UK Mac"]
-    #[doc = "   layouts on ISO keyboards, SECTION SIGN and"]
-    #[doc = "   DEGREE SIGN in a Swiss German layout (Mac:"]
-    #[doc = "   only on ISO keyboards), CIRCUMFLEX ACCENT and"]
-    #[doc = "   DEGREE SIGN in a German layout (Mac: only on"]
-    #[doc = "   ISO keyboards), SUPERSCRIPT TWO and TILDE in a"]
-    #[doc = "   French Windows layout, COMMERCIAL AT and"]
-    #[doc = "   NUMBER SIGN in a French Mac layout on ISO"]
-    #[doc = "   keyboards, and LESS-THAN SIGN and GREATER-THAN"]
-    #[doc = "   SIGN in a Swiss German, German, or French Mac"]
-    #[doc = "   layout on ANSI keyboards."]
+    #[doc = "< Located in the top left corner (on both ANSI\n   and ISO keyboards). Produces GRAVE ACCENT and\n   TILDE in a US Windows layout and in US and UK\n   Mac layouts on ANSI keyboards, GRAVE ACCENT\n   and NOT SIGN in a UK Windows layout, SECTION\n   SIGN and PLUS-MINUS SIGN in US and UK Mac\n   layouts on ISO keyboards, SECTION SIGN and\n   DEGREE SIGN in a Swiss German layout (Mac:\n   only on ISO keyboards), CIRCUMFLEX ACCENT and\n   DEGREE SIGN in a German layout (Mac: only on\n   ISO keyboards), SUPERSCRIPT TWO and TILDE in a\n   French Windows layout, COMMERCIAL AT and\n   NUMBER SIGN in a French Mac layout on ISO\n   keyboards, and LESS-THAN SIGN and GREATER-THAN\n   SIGN in a Swiss German, German, or French Mac\n   layout on ANSI keyboards."]
     SDL_SCANCODE_GRAVE = 53,
     SDL_SCANCODE_COMMA = 54,
     SDL_SCANCODE_PERIOD = 55,
@@ -12161,8 +7425,7 @@ pub enum SDL_Scancode {
     SDL_SCANCODE_PRINTSCREEN = 70,
     SDL_SCANCODE_SCROLLLOCK = 71,
     SDL_SCANCODE_PAUSE = 72,
-    #[doc = "< insert on PC, help on some Mac keyboards (but"]
-    #[doc = "does send code 73, not 117)"]
+    #[doc = "< insert on PC, help on some Mac keyboards (but\ndoes send code 73, not 117)"]
     SDL_SCANCODE_INSERT = 73,
     SDL_SCANCODE_HOME = 74,
     SDL_SCANCODE_PAGEUP = 75,
@@ -12191,22 +7454,11 @@ pub enum SDL_Scancode {
     SDL_SCANCODE_KP_9 = 97,
     SDL_SCANCODE_KP_0 = 98,
     SDL_SCANCODE_KP_PERIOD = 99,
-    #[doc = "< This is the additional key that ISO"]
-    #[doc = "   keyboards have over ANSI ones,"]
-    #[doc = "   located between left shift and Y."]
-    #[doc = "   Produces GRAVE ACCENT and TILDE in a"]
-    #[doc = "   US or UK Mac layout, REVERSE SOLIDUS"]
-    #[doc = "   (backslash) and VERTICAL LINE in a"]
-    #[doc = "   US or UK Windows layout, and"]
-    #[doc = "   LESS-THAN SIGN and GREATER-THAN SIGN"]
-    #[doc = "   in a Swiss German, German, or French"]
-    #[doc = "   layout."]
+    #[doc = "< This is the additional key that ISO\n   keyboards have over ANSI ones,\n   located between left shift and Y.\n   Produces GRAVE ACCENT and TILDE in a\n   US or UK Mac layout, REVERSE SOLIDUS\n   (backslash) and VERTICAL LINE in a\n   US or UK Windows layout, and\n   LESS-THAN SIGN and GREATER-THAN SIGN\n   in a Swiss German, German, or French\n   layout."]
     SDL_SCANCODE_NONUSBACKSLASH = 100,
     #[doc = "< windows contextual menu, compose"]
     SDL_SCANCODE_APPLICATION = 101,
-    #[doc = "< The USB document says this is a status flag,"]
-    #[doc = "   not a physical key - but some Mac keyboards"]
-    #[doc = "   do have a power key."]
+    #[doc = "< The USB document says this is a status flag,\n   not a physical key - but some Mac keyboards\n   do have a power key."]
     SDL_SCANCODE_POWER = 102,
     SDL_SCANCODE_KP_EQUALS = 103,
     SDL_SCANCODE_F13 = 104,
@@ -12222,24 +7474,31 @@ pub enum SDL_Scancode {
     SDL_SCANCODE_F23 = 114,
     SDL_SCANCODE_F24 = 115,
     SDL_SCANCODE_EXECUTE = 116,
+    #[doc = "< AL Integrated Help Center"]
     SDL_SCANCODE_HELP = 117,
+    #[doc = "< Menu (show menu)"]
     SDL_SCANCODE_MENU = 118,
     SDL_SCANCODE_SELECT = 119,
+    #[doc = "< AC Stop"]
     SDL_SCANCODE_STOP = 120,
-    #[doc = "< redo"]
+    #[doc = "< AC Redo/Repeat"]
     SDL_SCANCODE_AGAIN = 121,
+    #[doc = "< AC Undo"]
     SDL_SCANCODE_UNDO = 122,
+    #[doc = "< AC Cut"]
     SDL_SCANCODE_CUT = 123,
+    #[doc = "< AC Copy"]
     SDL_SCANCODE_COPY = 124,
+    #[doc = "< AC Paste"]
     SDL_SCANCODE_PASTE = 125,
+    #[doc = "< AC Find"]
     SDL_SCANCODE_FIND = 126,
     SDL_SCANCODE_MUTE = 127,
     SDL_SCANCODE_VOLUMEUP = 128,
     SDL_SCANCODE_VOLUMEDOWN = 129,
     SDL_SCANCODE_KP_COMMA = 133,
     SDL_SCANCODE_KP_EQUALSAS400 = 134,
-    #[doc = "< used on Asian keyboards, see"]
-    #[doc = "footnotes in USB doc"]
+    #[doc = "< used on Asian keyboards, see\nfootnotes in USB doc"]
     SDL_SCANCODE_INTERNATIONAL1 = 135,
     SDL_SCANCODE_INTERNATIONAL2 = 136,
     #[doc = "< Yen"]
@@ -12271,6 +7530,7 @@ pub enum SDL_Scancode {
     #[doc = "< Erase-Eaze"]
     SDL_SCANCODE_ALTERASE = 153,
     SDL_SCANCODE_SYSREQ = 154,
+    #[doc = "< AC Cancel"]
     SDL_SCANCODE_CANCEL = 155,
     SDL_SCANCODE_CLEAR = 156,
     SDL_SCANCODE_PRIOR = 157,
@@ -12339,9 +7599,7 @@ pub enum SDL_Scancode {
     SDL_SCANCODE_RALT = 230,
     #[doc = "< windows, command (apple), meta"]
     SDL_SCANCODE_RGUI = 231,
-    #[doc = "< I'm not sure if this is really not covered"]
-    #[doc = "   by any of the above, but since there's a"]
-    #[doc = "   special KMOD_MODE for it I'm adding it here"]
+    #[doc = "< I'm not sure if this is really not covered\n   by any of the above, but since there's a\n   special KMOD_MODE for it I'm adding it here"]
     SDL_SCANCODE_MODE = 257,
     SDL_SCANCODE_AUDIONEXT = 258,
     SDL_SCANCODE_AUDIOPREV = 259,
@@ -12349,47 +7607,55 @@ pub enum SDL_Scancode {
     SDL_SCANCODE_AUDIOPLAY = 261,
     SDL_SCANCODE_AUDIOMUTE = 262,
     SDL_SCANCODE_MEDIASELECT = 263,
+    #[doc = "< AL Internet Browser"]
     SDL_SCANCODE_WWW = 264,
     SDL_SCANCODE_MAIL = 265,
+    #[doc = "< AL Calculator"]
     SDL_SCANCODE_CALCULATOR = 266,
     SDL_SCANCODE_COMPUTER = 267,
+    #[doc = "< AC Search"]
     SDL_SCANCODE_AC_SEARCH = 268,
+    #[doc = "< AC Home"]
     SDL_SCANCODE_AC_HOME = 269,
+    #[doc = "< AC Back"]
     SDL_SCANCODE_AC_BACK = 270,
+    #[doc = "< AC Forward"]
     SDL_SCANCODE_AC_FORWARD = 271,
+    #[doc = "< AC Stop"]
     SDL_SCANCODE_AC_STOP = 272,
+    #[doc = "< AC Refresh"]
     SDL_SCANCODE_AC_REFRESH = 273,
+    #[doc = "< AC Bookmarks"]
     SDL_SCANCODE_AC_BOOKMARKS = 274,
     SDL_SCANCODE_BRIGHTNESSDOWN = 275,
     SDL_SCANCODE_BRIGHTNESSUP = 276,
-    #[doc = "< display mirroring/dual display"]
-    #[doc = "switch, video mode switch"]
+    #[doc = "< display mirroring/dual display\nswitch, video mode switch"]
     SDL_SCANCODE_DISPLAYSWITCH = 277,
     SDL_SCANCODE_KBDILLUMTOGGLE = 278,
     SDL_SCANCODE_KBDILLUMDOWN = 279,
     SDL_SCANCODE_KBDILLUMUP = 280,
     SDL_SCANCODE_EJECT = 281,
+    #[doc = "< SC System Sleep"]
     SDL_SCANCODE_SLEEP = 282,
     SDL_SCANCODE_APP1 = 283,
     SDL_SCANCODE_APP2 = 284,
     SDL_SCANCODE_AUDIOREWIND = 285,
     SDL_SCANCODE_AUDIOFASTFORWARD = 286,
-    #[doc = "< not a key, just marks the number of scancodes"]
-    #[doc = "for array bounds"]
+    #[doc = "< Usually situated below the display on phones and\nused as a multi-function feature key for selecting\na software defined function shown on the bottom left\nof the display."]
+    SDL_SCANCODE_SOFTLEFT = 287,
+    #[doc = "< Usually situated below the display on phones and\nused as a multi-function feature key for selecting\na software defined function shown on the bottom right\nof the display."]
+    SDL_SCANCODE_SOFTRIGHT = 288,
+    #[doc = "< Used for accepting phone calls."]
+    SDL_SCANCODE_CALL = 289,
+    #[doc = "< Used for rejecting phone calls."]
+    SDL_SCANCODE_ENDCALL = 290,
+    #[doc = "< not a key, just marks the number of scancodes\nfor array bounds"]
     SDL_NUM_SCANCODES = 512,
 }
-#[doc = "  \\brief The SDL virtual key representation."]
-#[doc = ""]
-#[doc = "  Values of this type are used to represent keyboard keys using the current"]
-#[doc = "  layout of the keyboard.  These values include Unicode values representing"]
-#[doc = "  the unmodified character that would be generated by pressing the key, or"]
-#[doc = "  an SDLK_* constant for those keys that do not generate characters."]
-#[doc = ""]
-#[doc = "  A special exception is the number keys at the top of the keyboard which"]
-#[doc = "  always map to SDLK_0...SDLK_9, regardless of layout."]
+#[doc = "  \\brief The SDL virtual key representation.\n\n  Values of this type are used to represent keyboard keys using the current\n  layout of the keyboard.  These values include Unicode values representing\n  the unmodified character that would be generated by pressing the key, or\n  an SDLK_* constant for those keys that do not generate characters.\n\n  A special exception is the number keys at the top of the keyboard which\n  always map to SDLK_0...SDLK_9, regardless of layout."]
 pub type SDL_Keycode = Sint32;
 #[repr(u32)]
-#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
+#[derive(Copy, Clone, Hash, PartialEq, Eq)]
 pub enum SDL_KeyCode {
     SDLK_UNKNOWN = 0,
     SDLK_RETURN = 13,
@@ -12631,13 +7897,17 @@ pub enum SDL_KeyCode {
     SDLK_APP2 = 1073742108,
     SDLK_AUDIOREWIND = 1073742109,
     SDLK_AUDIOFASTFORWARD = 1073742110,
+    SDLK_SOFTLEFT = 1073742111,
+    SDLK_SOFTRIGHT = 1073742112,
+    SDLK_CALL = 1073742113,
+    SDLK_ENDCALL = 1073742114,
 }
 impl SDL_Keymod {
     pub const KMOD_RESERVED: SDL_Keymod = SDL_Keymod::KMOD_SCROLL;
 }
 #[repr(u32)]
 #[doc = " \\brief Enumeration of valid key mods (possibly OR'd together)."]
-#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
+#[derive(Copy, Clone, Hash, PartialEq, Eq)]
 pub enum SDL_Keymod {
     KMOD_NONE = 0,
     KMOD_LSHIFT = 1,
@@ -12657,9 +7927,7 @@ pub enum SDL_Keymod {
     KMOD_ALT = 768,
     KMOD_GUI = 3072,
 }
-#[doc = "  \\brief The SDL keysym structure, used in key events."]
-#[doc = ""]
-#[doc = "  \\note  If you are looking for translated character input, see the ::SDL_TEXTINPUT event."]
+#[doc = "  \\brief The SDL keysym structure, used in key events.\n\n  \\note  If you are looking for translated character input, see the ::SDL_TEXTINPUT event."]
 #[repr(C)]
 #[derive(Copy, Clone)]
 pub struct SDL_Keysym {
@@ -12673,6 +7941,8 @@ pub struct SDL_Keysym {
 }
 #[test]
 fn bindgen_test_layout_SDL_Keysym() {
+    const UNINIT: ::core::mem::MaybeUninit<SDL_Keysym> = ::core::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::core::mem::size_of::<SDL_Keysym>(),
         16usize,
@@ -12684,7 +7954,7 @@ fn bindgen_test_layout_SDL_Keysym() {
         concat!("Alignment of ", stringify!(SDL_Keysym))
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_Keysym>())).scancode as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).scancode) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -12694,7 +7964,7 @@ fn bindgen_test_layout_SDL_Keysym() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_Keysym>())).sym as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).sym) as usize - ptr as usize },
         4usize,
         concat!(
             "Offset of field: ",
@@ -12704,7 +7974,7 @@ fn bindgen_test_layout_SDL_Keysym() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_Keysym>())).mod_ as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).mod_) as usize - ptr as usize },
         8usize,
         concat!(
             "Offset of field: ",
@@ -12714,7 +7984,7 @@ fn bindgen_test_layout_SDL_Keysym() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_Keysym>())).unused as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).unused) as usize - ptr as usize },
         12usize,
         concat!(
             "Offset of field: ",
@@ -12725,238 +7995,79 @@ fn bindgen_test_layout_SDL_Keysym() {
     );
 }
 extern "C" {
-    #[doc = " Query the window which currently has keyboard focus."]
-    #[doc = ""]
-    #[doc = " \\returns the window with keyboard focus."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
+    #[doc = " Query the window which currently has keyboard focus.\n\n \\returns the window with keyboard focus.\n\n \\since This function is available since SDL 2.0.0."]
     pub fn SDL_GetKeyboardFocus() -> *mut SDL_Window;
 }
 extern "C" {
-    #[doc = " Get a snapshot of the current state of the keyboard."]
-    #[doc = ""]
-    #[doc = " The pointer returned is a pointer to an internal SDL array. It will be"]
-    #[doc = " valid for the whole lifetime of the application and should not be freed by"]
-    #[doc = " the caller."]
-    #[doc = ""]
-    #[doc = " A array element with a value of 1 means that the key is pressed and a value"]
-    #[doc = " of 0 means that it is not. Indexes into this array are obtained by using"]
-    #[doc = " SDL_Scancode values."]
-    #[doc = ""]
-    #[doc = " Use SDL_PumpEvents() to update the state array."]
-    #[doc = ""]
-    #[doc = " This function gives you the current state after all events have been"]
-    #[doc = " processed, so if a key or button has been pressed and released before you"]
-    #[doc = " process events, then the pressed state will never show up in the"]
-    #[doc = " SDL_GetKeyboardState() calls."]
-    #[doc = ""]
-    #[doc = " Note: This function doesn't take into account whether shift has been"]
-    #[doc = " pressed or not."]
-    #[doc = ""]
-    #[doc = " \\param numkeys if non-NULL, receives the length of the returned array"]
-    #[doc = " \\returns a pointer to an array of key states."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_PumpEvents"]
+    #[doc = " Get a snapshot of the current state of the keyboard.\n\n The pointer returned is a pointer to an internal SDL array. It will be\n valid for the whole lifetime of the application and should not be freed by\n the caller.\n\n A array element with a value of 1 means that the key is pressed and a value\n of 0 means that it is not. Indexes into this array are obtained by using\n SDL_Scancode values.\n\n Use SDL_PumpEvents() to update the state array.\n\n This function gives you the current state after all events have been\n processed, so if a key or button has been pressed and released before you\n process events, then the pressed state will never show up in the\n SDL_GetKeyboardState() calls.\n\n Note: This function doesn't take into account whether shift has been\n pressed or not.\n\n \\param numkeys if non-NULL, receives the length of the returned array\n \\returns a pointer to an array of key states.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_PumpEvents\n \\sa SDL_ResetKeyboard"]
     pub fn SDL_GetKeyboardState(numkeys: *mut libc::c_int) -> *const Uint8;
 }
 extern "C" {
-    #[doc = " Get the current key modifier state for the keyboard."]
-    #[doc = ""]
-    #[doc = " \\returns an OR'd combination of the modifier keys for the keyboard. See"]
-    #[doc = "          SDL_Keymod for details."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_GetKeyboardState"]
-    #[doc = " \\sa SDL_SetModState"]
+    #[doc = " Clear the state of the keyboard\n\n This function will generate key up events for all pressed keys.\n\n \\since This function is available since SDL 2.24.0.\n\n \\sa SDL_GetKeyboardState"]
+    pub fn SDL_ResetKeyboard();
+}
+extern "C" {
+    #[doc = " Get the current key modifier state for the keyboard.\n\n \\returns an OR'd combination of the modifier keys for the keyboard. See\n          SDL_Keymod for details.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_GetKeyboardState\n \\sa SDL_SetModState"]
     pub fn SDL_GetModState() -> SDL_Keymod;
 }
 extern "C" {
-    #[doc = " Set the current key modifier state for the keyboard."]
-    #[doc = ""]
-    #[doc = " The inverse of SDL_GetModState(), SDL_SetModState() allows you to impose"]
-    #[doc = " modifier key states on your application. Simply pass your desired modifier"]
-    #[doc = " states into `modstate`. This value may be a bitwise, OR'd combination of"]
-    #[doc = " SDL_Keymod values."]
-    #[doc = ""]
-    #[doc = " This does not change the keyboard state, only the key modifier flags that"]
-    #[doc = " SDL reports."]
-    #[doc = ""]
-    #[doc = " \\param modstate the desired SDL_Keymod for the keyboard"]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_GetModState"]
+    #[doc = " Set the current key modifier state for the keyboard.\n\n The inverse of SDL_GetModState(), SDL_SetModState() allows you to impose\n modifier key states on your application. Simply pass your desired modifier\n states into `modstate`. This value may be a bitwise, OR'd combination of\n SDL_Keymod values.\n\n This does not change the keyboard state, only the key modifier flags that\n SDL reports.\n\n \\param modstate the desired SDL_Keymod for the keyboard\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_GetModState"]
     pub fn SDL_SetModState(modstate: SDL_Keymod);
 }
 extern "C" {
-    #[doc = " Get the key code corresponding to the given scancode according to the"]
-    #[doc = " current keyboard layout."]
-    #[doc = ""]
-    #[doc = " See SDL_Keycode for details."]
-    #[doc = ""]
-    #[doc = " \\param scancode the desired SDL_Scancode to query"]
-    #[doc = " \\returns the SDL_Keycode that corresponds to the given SDL_Scancode."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_GetKeyName"]
-    #[doc = " \\sa SDL_GetScancodeFromKey"]
+    #[doc = " Get the key code corresponding to the given scancode according to the\n current keyboard layout.\n\n See SDL_Keycode for details.\n\n \\param scancode the desired SDL_Scancode to query\n \\returns the SDL_Keycode that corresponds to the given SDL_Scancode.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_GetKeyName\n \\sa SDL_GetScancodeFromKey"]
     pub fn SDL_GetKeyFromScancode(scancode: SDL_Scancode) -> SDL_Keycode;
 }
 extern "C" {
-    #[doc = " Get the scancode corresponding to the given key code according to the"]
-    #[doc = " current keyboard layout."]
-    #[doc = ""]
-    #[doc = " See SDL_Scancode for details."]
-    #[doc = ""]
-    #[doc = " \\param key the desired SDL_Keycode to query"]
-    #[doc = " \\returns the SDL_Scancode that corresponds to the given SDL_Keycode."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_GetKeyFromScancode"]
-    #[doc = " \\sa SDL_GetScancodeName"]
+    #[doc = " Get the scancode corresponding to the given key code according to the\n current keyboard layout.\n\n See SDL_Scancode for details.\n\n \\param key the desired SDL_Keycode to query\n \\returns the SDL_Scancode that corresponds to the given SDL_Keycode.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_GetKeyFromScancode\n \\sa SDL_GetScancodeName"]
     pub fn SDL_GetScancodeFromKey(key: SDL_Keycode) -> SDL_Scancode;
 }
 extern "C" {
-    #[doc = " Get a human-readable name for a scancode."]
-    #[doc = ""]
-    #[doc = " See SDL_Scancode for details."]
-    #[doc = ""]
-    #[doc = " **Warning**: The returned name is by design not stable across platforms,"]
-    #[doc = " e.g. the name for `SDL_SCANCODE_LGUI` is \"Left GUI\" under Linux but \"Left"]
-    #[doc = " Windows\" under Microsoft Windows, and some scancodes like"]
-    #[doc = " `SDL_SCANCODE_NONUSBACKSLASH` don't have any name at all. There are even"]
-    #[doc = " scancodes that share names, e.g. `SDL_SCANCODE_RETURN` and"]
-    #[doc = " `SDL_SCANCODE_RETURN2` (both called \"Return\"). This function is therefore"]
-    #[doc = " unsuitable for creating a stable cross-platform two-way mapping between"]
-    #[doc = " strings and scancodes."]
-    #[doc = ""]
-    #[doc = " \\param scancode the desired SDL_Scancode to query"]
-    #[doc = " \\returns a pointer to the name for the scancode. If the scancode doesn't"]
-    #[doc = "          have a name this function returns an empty string (\"\")."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_GetScancodeFromKey"]
-    #[doc = " \\sa SDL_GetScancodeFromName"]
+    #[doc = " Get a human-readable name for a scancode.\n\n See SDL_Scancode for details.\n\n **Warning**: The returned name is by design not stable across platforms,\n e.g. the name for `SDL_SCANCODE_LGUI` is \"Left GUI\" under Linux but \"Left\n Windows\" under Microsoft Windows, and some scancodes like\n `SDL_SCANCODE_NONUSBACKSLASH` don't have any name at all. There are even\n scancodes that share names, e.g. `SDL_SCANCODE_RETURN` and\n `SDL_SCANCODE_RETURN2` (both called \"Return\"). This function is therefore\n unsuitable for creating a stable cross-platform two-way mapping between\n strings and scancodes.\n\n \\param scancode the desired SDL_Scancode to query\n \\returns a pointer to the name for the scancode. If the scancode doesn't\n          have a name this function returns an empty string (\"\").\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_GetScancodeFromKey\n \\sa SDL_GetScancodeFromName"]
     pub fn SDL_GetScancodeName(scancode: SDL_Scancode) -> *const libc::c_char;
 }
 extern "C" {
-    #[doc = " Get a scancode from a human-readable name."]
-    #[doc = ""]
-    #[doc = " \\param name the human-readable scancode name"]
-    #[doc = " \\returns the SDL_Scancode, or `SDL_SCANCODE_UNKNOWN` if the name wasn't"]
-    #[doc = "          recognized; call SDL_GetError() for more information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_GetKeyFromName"]
-    #[doc = " \\sa SDL_GetScancodeFromKey"]
-    #[doc = " \\sa SDL_GetScancodeName"]
+    #[doc = " Get a scancode from a human-readable name.\n\n \\param name the human-readable scancode name\n \\returns the SDL_Scancode, or `SDL_SCANCODE_UNKNOWN` if the name wasn't\n          recognized; call SDL_GetError() for more information.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_GetKeyFromName\n \\sa SDL_GetScancodeFromKey\n \\sa SDL_GetScancodeName"]
     pub fn SDL_GetScancodeFromName(name: *const libc::c_char) -> SDL_Scancode;
 }
 extern "C" {
-    #[doc = " Get a human-readable name for a key."]
-    #[doc = ""]
-    #[doc = " See SDL_Scancode and SDL_Keycode for details."]
-    #[doc = ""]
-    #[doc = " \\param key the desired SDL_Keycode to query"]
-    #[doc = " \\returns a pointer to a UTF-8 string that stays valid at least until the"]
-    #[doc = "          next call to this function. If you need it around any longer, you"]
-    #[doc = "          must copy it. If the key doesn't have a name, this function"]
-    #[doc = "          returns an empty string (\"\")."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_GetKeyFromName"]
-    #[doc = " \\sa SDL_GetKeyFromScancode"]
-    #[doc = " \\sa SDL_GetScancodeFromKey"]
+    #[doc = " Get a human-readable name for a key.\n\n See SDL_Scancode and SDL_Keycode for details.\n\n \\param key the desired SDL_Keycode to query\n \\returns a pointer to a UTF-8 string that stays valid at least until the\n          next call to this function. If you need it around any longer, you\n          must copy it. If the key doesn't have a name, this function\n          returns an empty string (\"\").\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_GetKeyFromName\n \\sa SDL_GetKeyFromScancode\n \\sa SDL_GetScancodeFromKey"]
     pub fn SDL_GetKeyName(key: SDL_Keycode) -> *const libc::c_char;
 }
 extern "C" {
-    #[doc = " Get a key code from a human-readable name."]
-    #[doc = ""]
-    #[doc = " \\param name the human-readable key name"]
-    #[doc = " \\returns key code, or `SDLK_UNKNOWN` if the name wasn't recognized; call"]
-    #[doc = "          SDL_GetError() for more information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_GetKeyFromScancode"]
-    #[doc = " \\sa SDL_GetKeyName"]
-    #[doc = " \\sa SDL_GetScancodeFromName"]
+    #[doc = " Get a key code from a human-readable name.\n\n \\param name the human-readable key name\n \\returns key code, or `SDLK_UNKNOWN` if the name wasn't recognized; call\n          SDL_GetError() for more information.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_GetKeyFromScancode\n \\sa SDL_GetKeyName\n \\sa SDL_GetScancodeFromName"]
     pub fn SDL_GetKeyFromName(name: *const libc::c_char) -> SDL_Keycode;
 }
 extern "C" {
-    #[doc = " Start accepting Unicode text input events."]
-    #[doc = ""]
-    #[doc = " This function will start accepting Unicode text input events in the focused"]
-    #[doc = " SDL window, and start emitting SDL_TextInputEvent (SDL_TEXTINPUT) and"]
-    #[doc = " SDL_TextEditingEvent (SDL_TEXTEDITING) events. Please use this function in"]
-    #[doc = " pair with SDL_StopTextInput()."]
-    #[doc = ""]
-    #[doc = " On some platforms using this function activates the screen keyboard."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_SetTextInputRect"]
-    #[doc = " \\sa SDL_StopTextInput"]
+    #[doc = " Start accepting Unicode text input events.\n\n This function will start accepting Unicode text input events in the focused\n SDL window, and start emitting SDL_TextInputEvent (SDL_TEXTINPUT) and\n SDL_TextEditingEvent (SDL_TEXTEDITING) events. Please use this function in\n pair with SDL_StopTextInput().\n\n On some platforms using this function activates the screen keyboard.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_SetTextInputRect\n \\sa SDL_StopTextInput"]
     pub fn SDL_StartTextInput();
 }
 extern "C" {
-    #[doc = " Check whether or not Unicode text input events are enabled."]
-    #[doc = ""]
-    #[doc = " \\returns SDL_TRUE if text input events are enabled else SDL_FALSE."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_StartTextInput"]
+    #[doc = " Check whether or not Unicode text input events are enabled.\n\n \\returns SDL_TRUE if text input events are enabled else SDL_FALSE.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_StartTextInput"]
     pub fn SDL_IsTextInputActive() -> SDL_bool;
 }
 extern "C" {
-    #[doc = " Stop receiving any text input events."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_StartTextInput"]
+    #[doc = " Stop receiving any text input events.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_StartTextInput"]
     pub fn SDL_StopTextInput();
 }
 extern "C" {
-    #[doc = " Set the rectangle used to type Unicode text inputs."]
-    #[doc = ""]
-    #[doc = " \\param rect the SDL_Rect structure representing the rectangle to receive"]
-    #[doc = "             text (ignored if NULL)"]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_StartTextInput"]
-    pub fn SDL_SetTextInputRect(rect: *mut SDL_Rect);
-}
-extern "C" {
-    #[doc = " Check whether the platform has screen keyboard support."]
-    #[doc = ""]
-    #[doc = " \\returns SDL_TRUE if the platform has some screen keyboard support or"]
-    #[doc = "          SDL_FALSE if not."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_StartTextInput"]
-    #[doc = " \\sa SDL_IsScreenKeyboardShown"]
+    #[doc = " Dismiss the composition window/IME without disabling the subsystem.\n\n \\since This function is available since SDL 2.0.22.\n\n \\sa SDL_StartTextInput\n \\sa SDL_StopTextInput"]
+    pub fn SDL_ClearComposition();
+}
+extern "C" {
+    #[doc = " Returns if an IME Composite or Candidate window is currently shown.\n\n \\since This function is available since SDL 2.0.22."]
+    pub fn SDL_IsTextInputShown() -> SDL_bool;
+}
+extern "C" {
+    #[doc = " Set the rectangle used to type Unicode text inputs.\n\n To start text input in a given location, this function is intended to be\n called before SDL_StartTextInput, although some platforms support moving\n the rectangle even while text input (and a composition) is active.\n\n Note: If you want to use the system native IME window, try setting hint\n **SDL_HINT_IME_SHOW_UI** to **1**, otherwise this function won't give you\n any feedback.\n\n \\param rect the SDL_Rect structure representing the rectangle to receive\n             text (ignored if NULL)\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_StartTextInput"]
+    pub fn SDL_SetTextInputRect(rect: *const SDL_Rect);
+}
+extern "C" {
+    #[doc = " Check whether the platform has screen keyboard support.\n\n \\returns SDL_TRUE if the platform has some screen keyboard support or\n          SDL_FALSE if not.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_StartTextInput\n \\sa SDL_IsScreenKeyboardShown"]
     pub fn SDL_HasScreenKeyboardSupport() -> SDL_bool;
 }
 extern "C" {
-    #[doc = " Check whether the screen keyboard is shown for given window."]
-    #[doc = ""]
-    #[doc = " \\param window the window for which screen keyboard should be queried"]
-    #[doc = " \\returns SDL_TRUE if screen keyboard is shown or SDL_FALSE if not."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_HasScreenKeyboardSupport"]
+    #[doc = " Check whether the screen keyboard is shown for given window.\n\n \\param window the window for which screen keyboard should be queried\n \\returns SDL_TRUE if screen keyboard is shown or SDL_FALSE if not.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_HasScreenKeyboardSupport"]
     pub fn SDL_IsScreenKeyboardShown(window: *mut SDL_Window) -> SDL_bool;
 }
 #[repr(C)]
@@ -12966,7 +8077,7 @@ pub struct SDL_Cursor {
 }
 #[repr(u32)]
 #[doc = " \\brief Cursor types for SDL_CreateSystemCursor()."]
-#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
+#[derive(Copy, Clone, Hash, PartialEq, Eq)]
 pub enum SDL_SystemCursor {
     #[doc = "< Arrow"]
     SDL_SYSTEM_CURSOR_ARROW = 0,
@@ -12996,7 +8107,7 @@ pub enum SDL_SystemCursor {
 }
 #[repr(u32)]
 #[doc = " \\brief Scroll direction types for the Scroll event"]
-#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
+#[derive(Copy, Clone, Hash, PartialEq, Eq)]
 pub enum SDL_MouseWheelDirection {
     #[doc = "< The scroll direction is normal"]
     SDL_MOUSEWHEEL_NORMAL = 0,
@@ -13004,230 +8115,43 @@ pub enum SDL_MouseWheelDirection {
     SDL_MOUSEWHEEL_FLIPPED = 1,
 }
 extern "C" {
-    #[doc = " Get the window which currently has mouse focus."]
-    #[doc = ""]
-    #[doc = " \\returns the window with mouse focus."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
+    #[doc = " Get the window which currently has mouse focus.\n\n \\returns the window with mouse focus.\n\n \\since This function is available since SDL 2.0.0."]
     pub fn SDL_GetMouseFocus() -> *mut SDL_Window;
 }
 extern "C" {
-    #[doc = " Retrieve the current state of the mouse."]
-    #[doc = ""]
-    #[doc = " The current button state is returned as a button bitmask, which can be"]
-    #[doc = " tested using the `SDL_BUTTON(X)` macros (where `X` is generally 1 for the"]
-    #[doc = " left, 2 for middle, 3 for the right button), and `x` and `y` are set to the"]
-    #[doc = " mouse cursor position relative to the focus window. You can pass NULL for"]
-    #[doc = " either `x` or `y`."]
-    #[doc = ""]
-    #[doc = " \\param x the x coordinate of the mouse cursor position relative to the"]
-    #[doc = "          focus window"]
-    #[doc = " \\param y the y coordinate of the mouse cursor position relative to the"]
-    #[doc = "          focus window"]
-    #[doc = " \\returns a 32-bit button bitmask of the current button state."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_GetGlobalMouseState"]
-    #[doc = " \\sa SDL_GetRelativeMouseState"]
-    #[doc = " \\sa SDL_PumpEvents"]
+    #[doc = " Retrieve the current state of the mouse.\n\n The current button state is returned as a button bitmask, which can be\n tested using the `SDL_BUTTON(X)` macros (where `X` is generally 1 for the\n left, 2 for middle, 3 for the right button), and `x` and `y` are set to the\n mouse cursor position relative to the focus window. You can pass NULL for\n either `x` or `y`.\n\n \\param x the x coordinate of the mouse cursor position relative to the\n          focus window\n \\param y the y coordinate of the mouse cursor position relative to the\n          focus window\n \\returns a 32-bit button bitmask of the current button state.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_GetGlobalMouseState\n \\sa SDL_GetRelativeMouseState\n \\sa SDL_PumpEvents"]
     pub fn SDL_GetMouseState(x: *mut libc::c_int, y: *mut libc::c_int) -> Uint32;
 }
 extern "C" {
-    #[doc = " Get the current state of the mouse in relation to the desktop."]
-    #[doc = ""]
-    #[doc = " This works similarly to SDL_GetMouseState(), but the coordinates will be"]
-    #[doc = " reported relative to the top-left of the desktop. This can be useful if you"]
-    #[doc = " need to track the mouse outside of a specific window and SDL_CaptureMouse()"]
-    #[doc = " doesn't fit your needs. For example, it could be useful if you need to"]
-    #[doc = " track the mouse while dragging a window, where coordinates relative to a"]
-    #[doc = " window might not be in sync at all times."]
-    #[doc = ""]
-    #[doc = " Note: SDL_GetMouseState() returns the mouse position as SDL understands it"]
-    #[doc = " from the last pump of the event queue. This function, however, queries the"]
-    #[doc = " OS for the current mouse position, and as such, might be a slightly less"]
-    #[doc = " efficient function. Unless you know what you're doing and have a good"]
-    #[doc = " reason to use this function, you probably want SDL_GetMouseState() instead."]
-    #[doc = ""]
-    #[doc = " \\param x filled in with the current X coord relative to the desktop; can be"]
-    #[doc = "          NULL"]
-    #[doc = " \\param y filled in with the current Y coord relative to the desktop; can be"]
-    #[doc = "          NULL"]
-    #[doc = " \\returns the current button state as a bitmask which can be tested using"]
-    #[doc = "          the SDL_BUTTON(X) macros."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.4."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_CaptureMouse"]
+    #[doc = " Get the current state of the mouse in relation to the desktop.\n\n This works similarly to SDL_GetMouseState(), but the coordinates will be\n reported relative to the top-left of the desktop. This can be useful if you\n need to track the mouse outside of a specific window and SDL_CaptureMouse()\n doesn't fit your needs. For example, it could be useful if you need to\n track the mouse while dragging a window, where coordinates relative to a\n window might not be in sync at all times.\n\n Note: SDL_GetMouseState() returns the mouse position as SDL understands it\n from the last pump of the event queue. This function, however, queries the\n OS for the current mouse position, and as such, might be a slightly less\n efficient function. Unless you know what you're doing and have a good\n reason to use this function, you probably want SDL_GetMouseState() instead.\n\n \\param x filled in with the current X coord relative to the desktop; can be\n          NULL\n \\param y filled in with the current Y coord relative to the desktop; can be\n          NULL\n \\returns the current button state as a bitmask which can be tested using\n          the SDL_BUTTON(X) macros.\n\n \\since This function is available since SDL 2.0.4.\n\n \\sa SDL_CaptureMouse"]
     pub fn SDL_GetGlobalMouseState(x: *mut libc::c_int, y: *mut libc::c_int) -> Uint32;
 }
 extern "C" {
-    #[doc = " Retrieve the relative state of the mouse."]
-    #[doc = ""]
-    #[doc = " The current button state is returned as a button bitmask, which can be"]
-    #[doc = " tested using the `SDL_BUTTON(X)` macros (where `X` is generally 1 for the"]
-    #[doc = " left, 2 for middle, 3 for the right button), and `x` and `y` are set to the"]
-    #[doc = " mouse deltas since the last call to SDL_GetRelativeMouseState() or since"]
-    #[doc = " event initialization. You can pass NULL for either `x` or `y`."]
-    #[doc = ""]
-    #[doc = " \\param x a pointer filled with the last recorded x coordinate of the mouse"]
-    #[doc = " \\param y a pointer filled with the last recorded y coordinate of the mouse"]
-    #[doc = " \\returns a 32-bit button bitmask of the relative button state."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_GetMouseState"]
+    #[doc = " Retrieve the relative state of the mouse.\n\n The current button state is returned as a button bitmask, which can be\n tested using the `SDL_BUTTON(X)` macros (where `X` is generally 1 for the\n left, 2 for middle, 3 for the right button), and `x` and `y` are set to the\n mouse deltas since the last call to SDL_GetRelativeMouseState() or since\n event initialization. You can pass NULL for either `x` or `y`.\n\n \\param x a pointer filled with the last recorded x coordinate of the mouse\n \\param y a pointer filled with the last recorded y coordinate of the mouse\n \\returns a 32-bit button bitmask of the relative button state.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_GetMouseState"]
     pub fn SDL_GetRelativeMouseState(x: *mut libc::c_int, y: *mut libc::c_int) -> Uint32;
 }
 extern "C" {
-    #[doc = " Move the mouse cursor to the given position within the window."]
-    #[doc = ""]
-    #[doc = " This function generates a mouse motion event."]
-    #[doc = ""]
-    #[doc = " Note that this function will appear to succeed, but not actually move the"]
-    #[doc = " mouse when used over Microsoft Remote Desktop."]
-    #[doc = ""]
-    #[doc = " \\param window the window to move the mouse into, or NULL for the current"]
-    #[doc = "               mouse focus"]
-    #[doc = " \\param x the x coordinate within the window"]
-    #[doc = " \\param y the y coordinate within the window"]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_WarpMouseGlobal"]
+    #[doc = " Move the mouse cursor to the given position within the window.\n\n This function generates a mouse motion event if relative mode is not\n enabled. If relative mode is enabled, you can force mouse events for the\n warp by setting the SDL_HINT_MOUSE_RELATIVE_WARP_MOTION hint.\n\n Note that this function will appear to succeed, but not actually move the\n mouse when used over Microsoft Remote Desktop.\n\n \\param window the window to move the mouse into, or NULL for the current\n               mouse focus\n \\param x the x coordinate within the window\n \\param y the y coordinate within the window\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_WarpMouseGlobal"]
     pub fn SDL_WarpMouseInWindow(window: *mut SDL_Window, x: libc::c_int, y: libc::c_int);
 }
 extern "C" {
-    #[doc = " Move the mouse to the given position in global screen space."]
-    #[doc = ""]
-    #[doc = " This function generates a mouse motion event."]
-    #[doc = ""]
-    #[doc = " A failure of this function usually means that it is unsupported by a"]
-    #[doc = " platform."]
-    #[doc = ""]
-    #[doc = " Note that this function will appear to succeed, but not actually move the"]
-    #[doc = " mouse when used over Microsoft Remote Desktop."]
-    #[doc = ""]
-    #[doc = " \\param x the x coordinate"]
-    #[doc = " \\param y the y coordinate"]
-    #[doc = " \\returns 0 on success or a negative error code on failure; call"]
-    #[doc = "          SDL_GetError() for more information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.4."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_WarpMouseInWindow"]
+    #[doc = " Move the mouse to the given position in global screen space.\n\n This function generates a mouse motion event.\n\n A failure of this function usually means that it is unsupported by a\n platform.\n\n Note that this function will appear to succeed, but not actually move the\n mouse when used over Microsoft Remote Desktop.\n\n \\param x the x coordinate\n \\param y the y coordinate\n \\returns 0 on success or a negative error code on failure; call\n          SDL_GetError() for more information.\n\n \\since This function is available since SDL 2.0.4.\n\n \\sa SDL_WarpMouseInWindow"]
     pub fn SDL_WarpMouseGlobal(x: libc::c_int, y: libc::c_int) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Set relative mouse mode."]
-    #[doc = ""]
-    #[doc = " While the mouse is in relative mode, the cursor is hidden, and the driver"]
-    #[doc = " will try to report continuous motion in the current window. Only relative"]
-    #[doc = " motion events will be delivered, the mouse position will not change."]
-    #[doc = ""]
-    #[doc = " Note that this function will not be able to provide continuous relative"]
-    #[doc = " motion when used over Microsoft Remote Desktop, instead motion is limited"]
-    #[doc = " to the bounds of the screen."]
-    #[doc = ""]
-    #[doc = " This function will flush any pending mouse motion."]
-    #[doc = ""]
-    #[doc = " \\param enabled SDL_TRUE to enable relative mode, SDL_FALSE to disable."]
-    #[doc = " \\returns 0 on success or a negative error code on failure; call"]
-    #[doc = "          SDL_GetError() for more information."]
-    #[doc = ""]
-    #[doc = "          If relative mode is not supported, this returns -1."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_GetRelativeMouseMode"]
+    #[doc = " Set relative mouse mode.\n\n While the mouse is in relative mode, the cursor is hidden, and the driver\n will try to report continuous motion in the current window. Only relative\n motion events will be delivered, the mouse position will not change.\n\n Note that this function will not be able to provide continuous relative\n motion when used over Microsoft Remote Desktop, instead motion is limited\n to the bounds of the screen.\n\n This function will flush any pending mouse motion.\n\n \\param enabled SDL_TRUE to enable relative mode, SDL_FALSE to disable.\n \\returns 0 on success or a negative error code on failure; call\n          SDL_GetError() for more information.\n\n          If relative mode is not supported, this returns -1.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_GetRelativeMouseMode"]
     pub fn SDL_SetRelativeMouseMode(enabled: SDL_bool) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Capture the mouse and to track input outside an SDL window."]
-    #[doc = ""]
-    #[doc = " Capturing enables your app to obtain mouse events globally, instead of just"]
-    #[doc = " within your window. Not all video targets support this function. When"]
-    #[doc = " capturing is enabled, the current window will get all mouse events, but"]
-    #[doc = " unlike relative mode, no change is made to the cursor and it is not"]
-    #[doc = " restrained to your window."]
-    #[doc = ""]
-    #[doc = " This function may also deny mouse input to other windows--both those in"]
-    #[doc = " your application and others on the system--so you should use this function"]
-    #[doc = " sparingly, and in small bursts. For example, you might want to track the"]
-    #[doc = " mouse while the user is dragging something, until the user releases a mouse"]
-    #[doc = " button. It is not recommended that you capture the mouse for long periods"]
-    #[doc = " of time, such as the entire time your app is running. For that, you should"]
-    #[doc = " probably use SDL_SetRelativeMouseMode() or SDL_SetWindowGrab(), depending"]
-    #[doc = " on your goals."]
-    #[doc = ""]
-    #[doc = " While captured, mouse events still report coordinates relative to the"]
-    #[doc = " current (foreground) window, but those coordinates may be outside the"]
-    #[doc = " bounds of the window (including negative values). Capturing is only allowed"]
-    #[doc = " for the foreground window. If the window loses focus while capturing, the"]
-    #[doc = " capture will be disabled automatically."]
-    #[doc = ""]
-    #[doc = " While capturing is enabled, the current window will have the"]
-    #[doc = " `SDL_WINDOW_MOUSE_CAPTURE` flag set."]
-    #[doc = ""]
-    #[doc = " \\param enabled SDL_TRUE to enable capturing, SDL_FALSE to disable."]
-    #[doc = " \\returns 0 on success or -1 if not supported; call SDL_GetError() for more"]
-    #[doc = "          information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.4."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_GetGlobalMouseState"]
+    #[doc = " Capture the mouse and to track input outside an SDL window.\n\n Capturing enables your app to obtain mouse events globally, instead of just\n within your window. Not all video targets support this function. When\n capturing is enabled, the current window will get all mouse events, but\n unlike relative mode, no change is made to the cursor and it is not\n restrained to your window.\n\n This function may also deny mouse input to other windows--both those in\n your application and others on the system--so you should use this function\n sparingly, and in small bursts. For example, you might want to track the\n mouse while the user is dragging something, until the user releases a mouse\n button. It is not recommended that you capture the mouse for long periods\n of time, such as the entire time your app is running. For that, you should\n probably use SDL_SetRelativeMouseMode() or SDL_SetWindowGrab(), depending\n on your goals.\n\n While captured, mouse events still report coordinates relative to the\n current (foreground) window, but those coordinates may be outside the\n bounds of the window (including negative values). Capturing is only allowed\n for the foreground window. If the window loses focus while capturing, the\n capture will be disabled automatically.\n\n While capturing is enabled, the current window will have the\n `SDL_WINDOW_MOUSE_CAPTURE` flag set.\n\n Please note that as of SDL 2.0.22, SDL will attempt to \"auto capture\" the\n mouse while the user is pressing a button; this is to try and make mouse\n behavior more consistent between platforms, and deal with the common case\n of a user dragging the mouse outside of the window. This means that if you\n are calling SDL_CaptureMouse() only to deal with this situation, you no\n longer have to (although it is safe to do so). If this causes problems for\n your app, you can disable auto capture by setting the\n `SDL_HINT_MOUSE_AUTO_CAPTURE` hint to zero.\n\n \\param enabled SDL_TRUE to enable capturing, SDL_FALSE to disable.\n \\returns 0 on success or -1 if not supported; call SDL_GetError() for more\n          information.\n\n \\since This function is available since SDL 2.0.4.\n\n \\sa SDL_GetGlobalMouseState"]
     pub fn SDL_CaptureMouse(enabled: SDL_bool) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Query whether relative mouse mode is enabled."]
-    #[doc = ""]
-    #[doc = " \\returns SDL_TRUE if relative mode is enabled or SDL_FALSE otherwise."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_SetRelativeMouseMode"]
+    #[doc = " Query whether relative mouse mode is enabled.\n\n \\returns SDL_TRUE if relative mode is enabled or SDL_FALSE otherwise.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_SetRelativeMouseMode"]
     pub fn SDL_GetRelativeMouseMode() -> SDL_bool;
 }
 extern "C" {
-    #[doc = " Create a cursor using the specified bitmap data and mask (in MSB format)."]
-    #[doc = ""]
-    #[doc = " `mask` has to be in MSB (Most Significant Bit) format."]
-    #[doc = ""]
-    #[doc = " The cursor width (`w`) must be a multiple of 8 bits."]
-    #[doc = ""]
-    #[doc = " The cursor is created in black and white according to the following:"]
-    #[doc = ""]
-    #[doc = " - data=0, mask=1: white"]
-    #[doc = " - data=1, mask=1: black"]
-    #[doc = " - data=0, mask=0: transparent"]
-    #[doc = " - data=1, mask=0: inverted color if possible, black if not."]
-    #[doc = ""]
-    #[doc = " Cursors created with this function must be freed with SDL_FreeCursor()."]
-    #[doc = ""]
-    #[doc = " If you want to have a color cursor, or create your cursor from an"]
-    #[doc = " SDL_Surface, you should use SDL_CreateColorCursor(). Alternately, you can"]
-    #[doc = " hide the cursor and draw your own as part of your game's rendering, but it"]
-    #[doc = " will be bound to the framerate."]
-    #[doc = ""]
-    #[doc = " Also, since SDL 2.0.0, SDL_CreateSystemCursor() is available, which"]
-    #[doc = " provides twelve readily available system cursors to pick from."]
-    #[doc = ""]
-    #[doc = " \\param data the color value for each pixel of the cursor"]
-    #[doc = " \\param mask the mask value for each pixel of the cursor"]
-    #[doc = " \\param w the width of the cursor"]
-    #[doc = " \\param h the height of the cursor"]
-    #[doc = " \\param hot_x the X-axis location of the upper left corner of the cursor"]
-    #[doc = "              relative to the actual mouse position"]
-    #[doc = " \\param hot_y the Y-axis location of the upper left corner of the cursor"]
-    #[doc = "              relative to the actual mouse position"]
-    #[doc = " \\returns a new cursor with the specified parameters on success or NULL on"]
-    #[doc = "          failure; call SDL_GetError() for more information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_FreeCursor"]
-    #[doc = " \\sa SDL_SetCursor"]
-    #[doc = " \\sa SDL_ShowCursor"]
+    #[doc = " Create a cursor using the specified bitmap data and mask (in MSB format).\n\n `mask` has to be in MSB (Most Significant Bit) format.\n\n The cursor width (`w`) must be a multiple of 8 bits.\n\n The cursor is created in black and white according to the following:\n\n - data=0, mask=1: white\n - data=1, mask=1: black\n - data=0, mask=0: transparent\n - data=1, mask=0: inverted color if possible, black if not.\n\n Cursors created with this function must be freed with SDL_FreeCursor().\n\n If you want to have a color cursor, or create your cursor from an\n SDL_Surface, you should use SDL_CreateColorCursor(). Alternately, you can\n hide the cursor and draw your own as part of your game's rendering, but it\n will be bound to the framerate.\n\n Also, since SDL 2.0.0, SDL_CreateSystemCursor() is available, which\n provides twelve readily available system cursors to pick from.\n\n \\param data the color value for each pixel of the cursor\n \\param mask the mask value for each pixel of the cursor\n \\param w the width of the cursor\n \\param h the height of the cursor\n \\param hot_x the X-axis location of the upper left corner of the cursor\n              relative to the actual mouse position\n \\param hot_y the Y-axis location of the upper left corner of the cursor\n              relative to the actual mouse position\n \\returns a new cursor with the specified parameters on success or NULL on\n          failure; call SDL_GetError() for more information.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_FreeCursor\n \\sa SDL_SetCursor\n \\sa SDL_ShowCursor"]
     pub fn SDL_CreateCursor(
         data: *const Uint8,
         mask: *const Uint8,
@@ -13238,18 +8162,7 @@ extern "C" {
     ) -> *mut SDL_Cursor;
 }
 extern "C" {
-    #[doc = " Create a color cursor."]
-    #[doc = ""]
-    #[doc = " \\param surface an SDL_Surface structure representing the cursor image"]
-    #[doc = " \\param hot_x the x position of the cursor hot spot"]
-    #[doc = " \\param hot_y the y position of the cursor hot spot"]
-    #[doc = " \\returns the new cursor on success or NULL on failure; call SDL_GetError()"]
-    #[doc = "          for more information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_CreateCursor"]
-    #[doc = " \\sa SDL_FreeCursor"]
+    #[doc = " Create a color cursor.\n\n \\param surface an SDL_Surface structure representing the cursor image\n \\param hot_x the x position of the cursor hot spot\n \\param hot_y the y position of the cursor hot spot\n \\returns the new cursor on success or NULL on failure; call SDL_GetError()\n          for more information.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_CreateCursor\n \\sa SDL_FreeCursor"]
     pub fn SDL_CreateColorCursor(
         surface: *mut SDL_Surface,
         hot_x: libc::c_int,
@@ -13257,136 +8170,81 @@ extern "C" {
     ) -> *mut SDL_Cursor;
 }
 extern "C" {
-    #[doc = " Create a system cursor."]
-    #[doc = ""]
-    #[doc = " \\param id an SDL_SystemCursor enum value"]
-    #[doc = " \\returns a cursor on success or NULL on failure; call SDL_GetError() for"]
-    #[doc = "          more information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_FreeCursor"]
+    #[doc = " Create a system cursor.\n\n \\param id an SDL_SystemCursor enum value\n \\returns a cursor on success or NULL on failure; call SDL_GetError() for\n          more information.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_FreeCursor"]
     pub fn SDL_CreateSystemCursor(id: SDL_SystemCursor) -> *mut SDL_Cursor;
 }
 extern "C" {
-    #[doc = " Set the active cursor."]
-    #[doc = ""]
-    #[doc = " This function sets the currently active cursor to the specified one. If the"]
-    #[doc = " cursor is currently visible, the change will be immediately represented on"]
-    #[doc = " the display. SDL_SetCursor(NULL) can be used to force cursor redraw, if"]
-    #[doc = " this is desired for any reason."]
-    #[doc = ""]
-    #[doc = " \\param cursor a cursor to make active"]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_CreateCursor"]
-    #[doc = " \\sa SDL_GetCursor"]
-    #[doc = " \\sa SDL_ShowCursor"]
+    #[doc = " Set the active cursor.\n\n This function sets the currently active cursor to the specified one. If the\n cursor is currently visible, the change will be immediately represented on\n the display. SDL_SetCursor(NULL) can be used to force cursor redraw, if\n this is desired for any reason.\n\n \\param cursor a cursor to make active\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_CreateCursor\n \\sa SDL_GetCursor\n \\sa SDL_ShowCursor"]
     pub fn SDL_SetCursor(cursor: *mut SDL_Cursor);
 }
 extern "C" {
-    #[doc = " Get the active cursor."]
-    #[doc = ""]
-    #[doc = " This function returns a pointer to the current cursor which is owned by the"]
-    #[doc = " library. It is not necessary to free the cursor with SDL_FreeCursor()."]
-    #[doc = ""]
-    #[doc = " \\returns the active cursor or NULL if there is no mouse."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_SetCursor"]
+    #[doc = " Get the active cursor.\n\n This function returns a pointer to the current cursor which is owned by the\n library. It is not necessary to free the cursor with SDL_FreeCursor().\n\n \\returns the active cursor or NULL if there is no mouse.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_SetCursor"]
     pub fn SDL_GetCursor() -> *mut SDL_Cursor;
 }
 extern "C" {
-    #[doc = " Get the default cursor."]
-    #[doc = ""]
-    #[doc = " \\returns the default cursor on success or NULL on failure."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_CreateSystemCursor"]
+    #[doc = " Get the default cursor.\n\n \\returns the default cursor on success or NULL on failure.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_CreateSystemCursor"]
     pub fn SDL_GetDefaultCursor() -> *mut SDL_Cursor;
 }
 extern "C" {
-    #[doc = " Free a previously-created cursor."]
-    #[doc = ""]
-    #[doc = " Use this function to free cursor resources created with SDL_CreateCursor(),"]
-    #[doc = " SDL_CreateColorCursor() or SDL_CreateSystemCursor()."]
-    #[doc = ""]
-    #[doc = " \\param cursor the cursor to free"]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_CreateColorCursor"]
-    #[doc = " \\sa SDL_CreateCursor"]
-    #[doc = " \\sa SDL_CreateSystemCursor"]
+    #[doc = " Free a previously-created cursor.\n\n Use this function to free cursor resources created with SDL_CreateCursor(),\n SDL_CreateColorCursor() or SDL_CreateSystemCursor().\n\n \\param cursor the cursor to free\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_CreateColorCursor\n \\sa SDL_CreateCursor\n \\sa SDL_CreateSystemCursor"]
     pub fn SDL_FreeCursor(cursor: *mut SDL_Cursor);
 }
 extern "C" {
-    #[doc = " Toggle whether or not the cursor is shown."]
-    #[doc = ""]
-    #[doc = " The cursor starts off displayed but can be turned off. Passing `SDL_ENABLE`"]
-    #[doc = " displays the cursor and passing `SDL_DISABLE` hides it."]
-    #[doc = ""]
-    #[doc = " The current state of the mouse cursor can be queried by passing"]
-    #[doc = " `SDL_QUERY`; either `SDL_DISABLE` or `SDL_ENABLE` will be returned."]
-    #[doc = ""]
-    #[doc = " \\param toggle `SDL_ENABLE` to show the cursor, `SDL_DISABLE` to hide it,"]
-    #[doc = "               `SDL_QUERY` to query the current state without changing it."]
-    #[doc = " \\returns `SDL_ENABLE` if the cursor is shown, or `SDL_DISABLE` if the"]
-    #[doc = "          cursor is hidden, or a negative error code on failure; call"]
-    #[doc = "          SDL_GetError() for more information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_CreateCursor"]
-    #[doc = " \\sa SDL_SetCursor"]
+    #[doc = " Toggle whether or not the cursor is shown.\n\n The cursor starts off displayed but can be turned off. Passing `SDL_ENABLE`\n displays the cursor and passing `SDL_DISABLE` hides it.\n\n The current state of the mouse cursor can be queried by passing\n `SDL_QUERY`; either `SDL_DISABLE` or `SDL_ENABLE` will be returned.\n\n \\param toggle `SDL_ENABLE` to show the cursor, `SDL_DISABLE` to hide it,\n               `SDL_QUERY` to query the current state without changing it.\n \\returns `SDL_ENABLE` if the cursor is shown, or `SDL_DISABLE` if the\n          cursor is hidden, or a negative error code on failure; call\n          SDL_GetError() for more information.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_CreateCursor\n \\sa SDL_SetCursor"]
     pub fn SDL_ShowCursor(toggle: libc::c_int) -> libc::c_int;
 }
-#[doc = " The joystick structure used to identify an SDL joystick"]
+#[doc = " An SDL_GUID is a 128-bit identifier for an input device that\n   identifies that device across runs of SDL programs on the same\n   platform.  If the device is detached and then re-attached to a\n   different port, or if the base system is rebooted, the device\n   should still report the same GUID.\n\n GUIDs are as precise as possible but are not guaranteed to\n   distinguish physically distinct but equivalent devices.  For\n   example, two game controllers from the same vendor with the same\n   product ID and revision may have the same GUID.\n\n GUIDs may be platform-dependent (i.e., the same device may report\n   different GUIDs on different operating systems)."]
 #[repr(C)]
 #[derive(Copy, Clone)]
-pub struct _SDL_Joystick {
-    _unused: [u8; 0],
-}
-pub type SDL_Joystick = _SDL_Joystick;
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub struct SDL_JoystickGUID {
+pub struct SDL_GUID {
     pub data: [Uint8; 16usize],
 }
 #[test]
-fn bindgen_test_layout_SDL_JoystickGUID() {
+fn bindgen_test_layout_SDL_GUID() {
+    const UNINIT: ::core::mem::MaybeUninit<SDL_GUID> = ::core::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
-        ::core::mem::size_of::<SDL_JoystickGUID>(),
+        ::core::mem::size_of::<SDL_GUID>(),
         16usize,
-        concat!("Size of: ", stringify!(SDL_JoystickGUID))
+        concat!("Size of: ", stringify!(SDL_GUID))
     );
     assert_eq!(
-        ::core::mem::align_of::<SDL_JoystickGUID>(),
+        ::core::mem::align_of::<SDL_GUID>(),
         1usize,
-        concat!("Alignment of ", stringify!(SDL_JoystickGUID))
+        concat!("Alignment of ", stringify!(SDL_GUID))
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_JoystickGUID>())).data as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
-            stringify!(SDL_JoystickGUID),
+            stringify!(SDL_GUID),
             "::",
             stringify!(data)
         )
     );
 }
-#[doc = " This is a unique ID for a joystick for the time it is connected to the system,"]
-#[doc = " and is never reused for the lifetime of the application. If the joystick is"]
-#[doc = " disconnected and reconnected, it will get a new ID."]
-#[doc = ""]
-#[doc = " The ID value starts at 0 and increments from there. The value -1 is an invalid ID."]
+extern "C" {
+    #[doc = " Get an ASCII string representation for a given ::SDL_GUID.\n\n You should supply at least 33 bytes for pszGUID.\n\n \\param guid the ::SDL_GUID you wish to convert to string\n \\param pszGUID buffer in which to write the ASCII string\n \\param cbGUID the size of pszGUID\n\n \\since This function is available since SDL 2.24.0.\n\n \\sa SDL_GUIDFromString"]
+    pub fn SDL_GUIDToString(guid: SDL_GUID, pszGUID: *mut libc::c_char, cbGUID: libc::c_int);
+}
+extern "C" {
+    #[doc = " Convert a GUID string into a ::SDL_GUID structure.\n\n Performs no error checking. If this function is given a string containing\n an invalid GUID, the function will silently succeed, but the GUID generated\n will not be useful.\n\n \\param pchGUID string containing an ASCII representation of a GUID\n \\returns a ::SDL_GUID structure.\n\n \\since This function is available since SDL 2.24.0.\n\n \\sa SDL_GUIDToString"]
+    pub fn SDL_GUIDFromString(pchGUID: *const libc::c_char) -> SDL_GUID;
+}
+#[doc = " The joystick structure used to identify an SDL joystick"]
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct _SDL_Joystick {
+    _unused: [u8; 0],
+}
+pub type SDL_Joystick = _SDL_Joystick;
+#[doc = " An SDL_GUID is a 128-bit identifier for an input device that\n   identifies that device across runs of SDL programs on the same\n   platform.  If the device is detached and then re-attached to a\n   different port, or if the base system is rebooted, the device\n   should still report the same GUID.\n\n GUIDs are as precise as possible but are not guaranteed to\n   distinguish physically distinct but equivalent devices.  For\n   example, two game controllers from the same vendor with the same\n   product ID and revision may have the same GUID.\n\n GUIDs may be platform-dependent (i.e., the same device may report\n   different GUIDs on different operating systems)."]
+pub type SDL_JoystickGUID = SDL_GUID;
+#[doc = " This is a unique ID for a joystick for the time it is connected to the system,\n and is never reused for the lifetime of the application. If the joystick is\n disconnected and reconnected, it will get a new ID.\n\n The ID value starts at 0 and increments from there. The value -1 is an invalid ID."]
 pub type SDL_JoystickID = Sint32;
 #[repr(u32)]
-#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
+#[derive(Copy, Clone, Hash, PartialEq, Eq)]
 pub enum SDL_JoystickType {
     SDL_JOYSTICK_TYPE_UNKNOWN = 0,
     SDL_JOYSTICK_TYPE_GAMECONTROLLER = 1,
@@ -13400,7 +8258,7 @@ pub enum SDL_JoystickType {
     SDL_JOYSTICK_TYPE_THROTTLE = 9,
 }
 #[repr(i32)]
-#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
+#[derive(Copy, Clone, Hash, PartialEq, Eq)]
 pub enum SDL_JoystickPowerLevel {
     SDL_JOYSTICK_POWER_UNKNOWN = -1,
     SDL_JOYSTICK_POWER_EMPTY = 0,
@@ -13411,199 +8269,67 @@ pub enum SDL_JoystickPowerLevel {
     SDL_JOYSTICK_POWER_MAX = 5,
 }
 extern "C" {
-    #[doc = " Locking for multi-threaded access to the joystick API"]
-    #[doc = ""]
-    #[doc = " If you are using the joystick API or handling events from multiple threads"]
-    #[doc = " you should use these locking functions to protect access to the joysticks."]
-    #[doc = ""]
-    #[doc = " In particular, you are guaranteed that the joystick list won't change, so"]
-    #[doc = " the API functions that take a joystick index will be valid, and joystick"]
-    #[doc = " and game controller events will not be delivered."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.7."]
+    #[doc = " Locking for multi-threaded access to the joystick API\n\n If you are using the joystick API or handling events from multiple threads\n you should use these locking functions to protect access to the joysticks.\n\n In particular, you are guaranteed that the joystick list won't change, so\n the API functions that take a joystick index will be valid, and joystick\n and game controller events will not be delivered.\n\n As of SDL 2.26.0, you can take the joystick lock around reinitializing the\n joystick subsystem, to prevent other threads from seeing joysticks in an\n uninitialized state. However, all open joysticks will be closed and SDL\n functions called with them will fail.\n\n \\since This function is available since SDL 2.0.7."]
     pub fn SDL_LockJoysticks();
 }
 extern "C" {
-    #[doc = " Unlocking for multi-threaded access to the joystick API"]
-    #[doc = ""]
-    #[doc = " If you are using the joystick API or handling events from multiple threads"]
-    #[doc = " you should use these locking functions to protect access to the joysticks."]
-    #[doc = ""]
-    #[doc = " In particular, you are guaranteed that the joystick list won't change, so"]
-    #[doc = " the API functions that take a joystick index will be valid, and joystick"]
-    #[doc = " and game controller events will not be delivered."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.7."]
+    #[doc = " Unlocking for multi-threaded access to the joystick API\n\n If you are using the joystick API or handling events from multiple threads\n you should use these locking functions to protect access to the joysticks.\n\n In particular, you are guaranteed that the joystick list won't change, so\n the API functions that take a joystick index will be valid, and joystick\n and game controller events will not be delivered.\n\n \\since This function is available since SDL 2.0.7."]
     pub fn SDL_UnlockJoysticks();
 }
 extern "C" {
-    #[doc = " Count the number of joysticks attached to the system."]
-    #[doc = ""]
-    #[doc = " \\returns the number of attached joysticks on success or a negative error"]
-    #[doc = "          code on failure; call SDL_GetError() for more information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_JoystickName"]
-    #[doc = " \\sa SDL_JoystickOpen"]
+    #[doc = " Count the number of joysticks attached to the system.\n\n \\returns the number of attached joysticks on success or a negative error\n          code on failure; call SDL_GetError() for more information.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_JoystickName\n \\sa SDL_JoystickPath\n \\sa SDL_JoystickOpen"]
     pub fn SDL_NumJoysticks() -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Get the implementation dependent name of a joystick."]
-    #[doc = ""]
-    #[doc = " This can be called before any joysticks are opened."]
-    #[doc = ""]
-    #[doc = " \\param device_index the index of the joystick to query (the N'th joystick"]
-    #[doc = "                     on the system)"]
-    #[doc = " \\returns the name of the selected joystick. If no name can be found, this"]
-    #[doc = "          function returns NULL; call SDL_GetError() for more information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_JoystickName"]
-    #[doc = " \\sa SDL_JoystickOpen"]
+    #[doc = " Get the implementation dependent name of a joystick.\n\n This can be called before any joysticks are opened.\n\n \\param device_index the index of the joystick to query (the N'th joystick\n                     on the system)\n \\returns the name of the selected joystick. If no name can be found, this\n          function returns NULL; call SDL_GetError() for more information.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_JoystickName\n \\sa SDL_JoystickOpen"]
     pub fn SDL_JoystickNameForIndex(device_index: libc::c_int) -> *const libc::c_char;
 }
 extern "C" {
-    #[doc = " Get the player index of a joystick, or -1 if it's not available This can be"]
-    #[doc = " called before any joysticks are opened."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.9."]
+    #[doc = " Get the implementation dependent path of a joystick.\n\n This can be called before any joysticks are opened.\n\n \\param device_index the index of the joystick to query (the N'th joystick\n                     on the system)\n \\returns the path of the selected joystick. If no path can be found, this\n          function returns NULL; call SDL_GetError() for more information.\n\n \\since This function is available since SDL 2.24.0.\n\n \\sa SDL_JoystickPath\n \\sa SDL_JoystickOpen"]
+    pub fn SDL_JoystickPathForIndex(device_index: libc::c_int) -> *const libc::c_char;
+}
+extern "C" {
+    #[doc = " Get the player index of a joystick, or -1 if it's not available This can be\n called before any joysticks are opened.\n\n \\since This function is available since SDL 2.0.9."]
     pub fn SDL_JoystickGetDevicePlayerIndex(device_index: libc::c_int) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Get the implementation-dependent GUID for the joystick at a given device"]
-    #[doc = " index."]
-    #[doc = ""]
-    #[doc = " This function can be called before any joysticks are opened."]
-    #[doc = ""]
-    #[doc = " \\param device_index the index of the joystick to query (the N'th joystick"]
-    #[doc = "                     on the system"]
-    #[doc = " \\returns the GUID of the selected joystick. If called on an invalid index,"]
-    #[doc = "          this function returns a zero GUID"]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_JoystickGetGUID"]
-    #[doc = " \\sa SDL_JoystickGetGUIDString"]
+    #[doc = " Get the implementation-dependent GUID for the joystick at a given device\n index.\n\n This function can be called before any joysticks are opened.\n\n \\param device_index the index of the joystick to query (the N'th joystick\n                     on the system\n \\returns the GUID of the selected joystick. If called on an invalid index,\n          this function returns a zero GUID\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_JoystickGetGUID\n \\sa SDL_JoystickGetGUIDString"]
     pub fn SDL_JoystickGetDeviceGUID(device_index: libc::c_int) -> SDL_JoystickGUID;
 }
 extern "C" {
-    #[doc = " Get the USB vendor ID of a joystick, if available."]
-    #[doc = ""]
-    #[doc = " This can be called before any joysticks are opened. If the vendor ID isn't"]
-    #[doc = " available this function returns 0."]
-    #[doc = ""]
-    #[doc = " \\param device_index the index of the joystick to query (the N'th joystick"]
-    #[doc = "                     on the system"]
-    #[doc = " \\returns the USB vendor ID of the selected joystick. If called on an"]
-    #[doc = "          invalid index, this function returns zero"]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.6."]
+    #[doc = " Get the USB vendor ID of a joystick, if available.\n\n This can be called before any joysticks are opened. If the vendor ID isn't\n available this function returns 0.\n\n \\param device_index the index of the joystick to query (the N'th joystick\n                     on the system\n \\returns the USB vendor ID of the selected joystick. If called on an\n          invalid index, this function returns zero\n\n \\since This function is available since SDL 2.0.6."]
     pub fn SDL_JoystickGetDeviceVendor(device_index: libc::c_int) -> Uint16;
 }
 extern "C" {
-    #[doc = " Get the USB product ID of a joystick, if available."]
-    #[doc = ""]
-    #[doc = " This can be called before any joysticks are opened. If the product ID isn't"]
-    #[doc = " available this function returns 0."]
-    #[doc = ""]
-    #[doc = " \\param device_index the index of the joystick to query (the N'th joystick"]
-    #[doc = "                     on the system"]
-    #[doc = " \\returns the USB product ID of the selected joystick. If called on an"]
-    #[doc = "          invalid index, this function returns zero"]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.6."]
+    #[doc = " Get the USB product ID of a joystick, if available.\n\n This can be called before any joysticks are opened. If the product ID isn't\n available this function returns 0.\n\n \\param device_index the index of the joystick to query (the N'th joystick\n                     on the system\n \\returns the USB product ID of the selected joystick. If called on an\n          invalid index, this function returns zero\n\n \\since This function is available since SDL 2.0.6."]
     pub fn SDL_JoystickGetDeviceProduct(device_index: libc::c_int) -> Uint16;
 }
 extern "C" {
-    #[doc = " Get the product version of a joystick, if available."]
-    #[doc = ""]
-    #[doc = " This can be called before any joysticks are opened. If the product version"]
-    #[doc = " isn't available this function returns 0."]
-    #[doc = ""]
-    #[doc = " \\param device_index the index of the joystick to query (the N'th joystick"]
-    #[doc = "                     on the system"]
-    #[doc = " \\returns the product version of the selected joystick. If called on an"]
-    #[doc = "          invalid index, this function returns zero"]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.6."]
+    #[doc = " Get the product version of a joystick, if available.\n\n This can be called before any joysticks are opened. If the product version\n isn't available this function returns 0.\n\n \\param device_index the index of the joystick to query (the N'th joystick\n                     on the system\n \\returns the product version of the selected joystick. If called on an\n          invalid index, this function returns zero\n\n \\since This function is available since SDL 2.0.6."]
     pub fn SDL_JoystickGetDeviceProductVersion(device_index: libc::c_int) -> Uint16;
 }
 extern "C" {
-    #[doc = " Get the type of a joystick, if available."]
-    #[doc = ""]
-    #[doc = " This can be called before any joysticks are opened."]
-    #[doc = ""]
-    #[doc = " \\param device_index the index of the joystick to query (the N'th joystick"]
-    #[doc = "                     on the system"]
-    #[doc = " \\returns the SDL_JoystickType of the selected joystick. If called on an"]
-    #[doc = "          invalid index, this function returns `SDL_JOYSTICK_TYPE_UNKNOWN`"]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.6."]
+    #[doc = " Get the type of a joystick, if available.\n\n This can be called before any joysticks are opened.\n\n \\param device_index the index of the joystick to query (the N'th joystick\n                     on the system\n \\returns the SDL_JoystickType of the selected joystick. If called on an\n          invalid index, this function returns `SDL_JOYSTICK_TYPE_UNKNOWN`\n\n \\since This function is available since SDL 2.0.6."]
     pub fn SDL_JoystickGetDeviceType(device_index: libc::c_int) -> SDL_JoystickType;
 }
 extern "C" {
-    #[doc = " Get the instance ID of a joystick."]
-    #[doc = ""]
-    #[doc = " This can be called before any joysticks are opened. If the index is out of"]
-    #[doc = " range, this function will return -1."]
-    #[doc = ""]
-    #[doc = " \\param device_index the index of the joystick to query (the N'th joystick"]
-    #[doc = "                     on the system"]
-    #[doc = " \\returns the instance id of the selected joystick. If called on an invalid"]
-    #[doc = "          index, this function returns zero"]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.6."]
+    #[doc = " Get the instance ID of a joystick.\n\n This can be called before any joysticks are opened. If the index is out of\n range, this function will return -1.\n\n \\param device_index the index of the joystick to query (the N'th joystick\n                     on the system\n \\returns the instance id of the selected joystick. If called on an invalid\n          index, this function returns zero\n\n \\since This function is available since SDL 2.0.6."]
     pub fn SDL_JoystickGetDeviceInstanceID(device_index: libc::c_int) -> SDL_JoystickID;
 }
 extern "C" {
-    #[doc = " Open a joystick for use."]
-    #[doc = ""]
-    #[doc = " The `device_index` argument refers to the N'th joystick presently"]
-    #[doc = " recognized by SDL on the system. It is **NOT** the same as the instance ID"]
-    #[doc = " used to identify the joystick in future events. See"]
-    #[doc = " SDL_JoystickInstanceID() for more details about instance IDs."]
-    #[doc = ""]
-    #[doc = " The joystick subsystem must be initialized before a joystick can be opened"]
-    #[doc = " for use."]
-    #[doc = ""]
-    #[doc = " \\param device_index the index of the joystick to query"]
-    #[doc = " \\returns a joystick identifier or NULL if an error occurred; call"]
-    #[doc = "          SDL_GetError() for more information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_JoystickClose"]
-    #[doc = " \\sa SDL_JoystickInstanceID"]
+    #[doc = " Open a joystick for use.\n\n The `device_index` argument refers to the N'th joystick presently\n recognized by SDL on the system. It is **NOT** the same as the instance ID\n used to identify the joystick in future events. See\n SDL_JoystickInstanceID() for more details about instance IDs.\n\n The joystick subsystem must be initialized before a joystick can be opened\n for use.\n\n \\param device_index the index of the joystick to query\n \\returns a joystick identifier or NULL if an error occurred; call\n          SDL_GetError() for more information.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_JoystickClose\n \\sa SDL_JoystickInstanceID"]
     pub fn SDL_JoystickOpen(device_index: libc::c_int) -> *mut SDL_Joystick;
 }
 extern "C" {
-    #[doc = " Get the SDL_Joystick associated with an instance id."]
-    #[doc = ""]
-    #[doc = " \\param instance_id the instance id to get the SDL_Joystick for"]
-    #[doc = " \\returns an SDL_Joystick on success or NULL on failure; call SDL_GetError()"]
-    #[doc = "          for more information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.4."]
+    #[doc = " Get the SDL_Joystick associated with an instance id.\n\n \\param instance_id the instance id to get the SDL_Joystick for\n \\returns an SDL_Joystick on success or NULL on failure; call SDL_GetError()\n          for more information.\n\n \\since This function is available since SDL 2.0.4."]
     pub fn SDL_JoystickFromInstanceID(instance_id: SDL_JoystickID) -> *mut SDL_Joystick;
 }
 extern "C" {
-    #[doc = " Get the SDL_Joystick associated with a player index."]
-    #[doc = ""]
-    #[doc = " \\param player_index the player index to get the SDL_Joystick for"]
-    #[doc = " \\returns an SDL_Joystick on success or NULL on failure; call SDL_GetError()"]
-    #[doc = "          for more information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.12."]
+    #[doc = " Get the SDL_Joystick associated with a player index.\n\n \\param player_index the player index to get the SDL_Joystick for\n \\returns an SDL_Joystick on success or NULL on failure; call SDL_GetError()\n          for more information.\n\n \\since This function is available since SDL 2.0.12."]
     pub fn SDL_JoystickFromPlayerIndex(player_index: libc::c_int) -> *mut SDL_Joystick;
 }
 extern "C" {
-    #[doc = " Attach a new virtual joystick."]
-    #[doc = ""]
-    #[doc = " \\returns the joystick's device index, or -1 if an error occurred."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.14."]
+    #[doc = " Attach a new virtual joystick.\n\n \\returns the joystick's device index, or -1 if an error occurred.\n\n \\since This function is available since SDL 2.0.14."]
     pub fn SDL_JoystickAttachVirtual(
         type_: SDL_JoystickType,
         naxes: libc::c_int,
@@ -13611,40 +8337,284 @@ extern "C" {
         nhats: libc::c_int,
     ) -> libc::c_int;
 }
+#[doc = " The structure that defines an extended virtual joystick description\n\n The caller must zero the structure and then initialize the version with `SDL_VIRTUAL_JOYSTICK_DESC_VERSION` before passing it to SDL_JoystickAttachVirtualEx()\n  All other elements of this structure are optional and can be left 0.\n\n \\sa SDL_JoystickAttachVirtualEx"]
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct SDL_VirtualJoystickDesc {
+    #[doc = "< `SDL_VIRTUAL_JOYSTICK_DESC_VERSION`"]
+    pub version: Uint16,
+    #[doc = "< `SDL_JoystickType`"]
+    pub type_: Uint16,
+    #[doc = "< the number of axes on this joystick"]
+    pub naxes: Uint16,
+    #[doc = "< the number of buttons on this joystick"]
+    pub nbuttons: Uint16,
+    #[doc = "< the number of hats on this joystick"]
+    pub nhats: Uint16,
+    #[doc = "< the USB vendor ID of this joystick"]
+    pub vendor_id: Uint16,
+    #[doc = "< the USB product ID of this joystick"]
+    pub product_id: Uint16,
+    #[doc = "< unused"]
+    pub padding: Uint16,
+    #[doc = "< A mask of which buttons are valid for this controller\ne.g. (1 << SDL_CONTROLLER_BUTTON_A)"]
+    pub button_mask: Uint32,
+    #[doc = "< A mask of which axes are valid for this controller\ne.g. (1 << SDL_CONTROLLER_AXIS_LEFTX)"]
+    pub axis_mask: Uint32,
+    #[doc = "< the name of the joystick"]
+    pub name: *const libc::c_char,
+    #[doc = "< User data pointer passed to callbacks"]
+    pub userdata: *mut libc::c_void,
+    #[doc = "< Called when the joystick state should be updated"]
+    pub Update: ::core::option::Option<unsafe extern "C" fn(userdata: *mut libc::c_void)>,
+    #[doc = "< Called when the player index is set"]
+    pub SetPlayerIndex: ::core::option::Option<
+        unsafe extern "C" fn(userdata: *mut libc::c_void, player_index: libc::c_int),
+    >,
+    #[doc = "< Implements SDL_JoystickRumble()"]
+    pub Rumble: ::core::option::Option<
+        unsafe extern "C" fn(
+            userdata: *mut libc::c_void,
+            low_frequency_rumble: Uint16,
+            high_frequency_rumble: Uint16,
+        ) -> libc::c_int,
+    >,
+    #[doc = "< Implements SDL_JoystickRumbleTriggers()"]
+    pub RumbleTriggers: ::core::option::Option<
+        unsafe extern "C" fn(
+            userdata: *mut libc::c_void,
+            left_rumble: Uint16,
+            right_rumble: Uint16,
+        ) -> libc::c_int,
+    >,
+    #[doc = "< Implements SDL_JoystickSetLED()"]
+    pub SetLED: ::core::option::Option<
+        unsafe extern "C" fn(
+            userdata: *mut libc::c_void,
+            red: Uint8,
+            green: Uint8,
+            blue: Uint8,
+        ) -> libc::c_int,
+    >,
+    #[doc = "< Implements SDL_JoystickSendEffect()"]
+    pub SendEffect: ::core::option::Option<
+        unsafe extern "C" fn(
+            userdata: *mut libc::c_void,
+            data: *const libc::c_void,
+            size: libc::c_int,
+        ) -> libc::c_int,
+    >,
+}
+#[test]
+fn bindgen_test_layout_SDL_VirtualJoystickDesc() {
+    const UNINIT: ::core::mem::MaybeUninit<SDL_VirtualJoystickDesc> =
+        ::core::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::core::mem::size_of::<SDL_VirtualJoystickDesc>(),
+        88usize,
+        concat!("Size of: ", stringify!(SDL_VirtualJoystickDesc))
+    );
+    assert_eq!(
+        ::core::mem::align_of::<SDL_VirtualJoystickDesc>(),
+        8usize,
+        concat!("Alignment of ", stringify!(SDL_VirtualJoystickDesc))
+    );
+    assert_eq!(
+        unsafe { ::core::ptr::addr_of!((*ptr).version) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(SDL_VirtualJoystickDesc),
+            "::",
+            stringify!(version)
+        )
+    );
+    assert_eq!(
+        unsafe { ::core::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
+        2usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(SDL_VirtualJoystickDesc),
+            "::",
+            stringify!(type_)
+        )
+    );
+    assert_eq!(
+        unsafe { ::core::ptr::addr_of!((*ptr).naxes) as usize - ptr as usize },
+        4usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(SDL_VirtualJoystickDesc),
+            "::",
+            stringify!(naxes)
+        )
+    );
+    assert_eq!(
+        unsafe { ::core::ptr::addr_of!((*ptr).nbuttons) as usize - ptr as usize },
+        6usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(SDL_VirtualJoystickDesc),
+            "::",
+            stringify!(nbuttons)
+        )
+    );
+    assert_eq!(
+        unsafe { ::core::ptr::addr_of!((*ptr).nhats) as usize - ptr as usize },
+        8usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(SDL_VirtualJoystickDesc),
+            "::",
+            stringify!(nhats)
+        )
+    );
+    assert_eq!(
+        unsafe { ::core::ptr::addr_of!((*ptr).vendor_id) as usize - ptr as usize },
+        10usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(SDL_VirtualJoystickDesc),
+            "::",
+            stringify!(vendor_id)
+        )
+    );
+    assert_eq!(
+        unsafe { ::core::ptr::addr_of!((*ptr).product_id) as usize - ptr as usize },
+        12usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(SDL_VirtualJoystickDesc),
+            "::",
+            stringify!(product_id)
+        )
+    );
+    assert_eq!(
+        unsafe { ::core::ptr::addr_of!((*ptr).padding) as usize - ptr as usize },
+        14usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(SDL_VirtualJoystickDesc),
+            "::",
+            stringify!(padding)
+        )
+    );
+    assert_eq!(
+        unsafe { ::core::ptr::addr_of!((*ptr).button_mask) as usize - ptr as usize },
+        16usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(SDL_VirtualJoystickDesc),
+            "::",
+            stringify!(button_mask)
+        )
+    );
+    assert_eq!(
+        unsafe { ::core::ptr::addr_of!((*ptr).axis_mask) as usize - ptr as usize },
+        20usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(SDL_VirtualJoystickDesc),
+            "::",
+            stringify!(axis_mask)
+        )
+    );
+    assert_eq!(
+        unsafe { ::core::ptr::addr_of!((*ptr).name) as usize - ptr as usize },
+        24usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(SDL_VirtualJoystickDesc),
+            "::",
+            stringify!(name)
+        )
+    );
+    assert_eq!(
+        unsafe { ::core::ptr::addr_of!((*ptr).userdata) as usize - ptr as usize },
+        32usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(SDL_VirtualJoystickDesc),
+            "::",
+            stringify!(userdata)
+        )
+    );
+    assert_eq!(
+        unsafe { ::core::ptr::addr_of!((*ptr).Update) as usize - ptr as usize },
+        40usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(SDL_VirtualJoystickDesc),
+            "::",
+            stringify!(Update)
+        )
+    );
+    assert_eq!(
+        unsafe { ::core::ptr::addr_of!((*ptr).SetPlayerIndex) as usize - ptr as usize },
+        48usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(SDL_VirtualJoystickDesc),
+            "::",
+            stringify!(SetPlayerIndex)
+        )
+    );
+    assert_eq!(
+        unsafe { ::core::ptr::addr_of!((*ptr).Rumble) as usize - ptr as usize },
+        56usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(SDL_VirtualJoystickDesc),
+            "::",
+            stringify!(Rumble)
+        )
+    );
+    assert_eq!(
+        unsafe { ::core::ptr::addr_of!((*ptr).RumbleTriggers) as usize - ptr as usize },
+        64usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(SDL_VirtualJoystickDesc),
+            "::",
+            stringify!(RumbleTriggers)
+        )
+    );
+    assert_eq!(
+        unsafe { ::core::ptr::addr_of!((*ptr).SetLED) as usize - ptr as usize },
+        72usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(SDL_VirtualJoystickDesc),
+            "::",
+            stringify!(SetLED)
+        )
+    );
+    assert_eq!(
+        unsafe { ::core::ptr::addr_of!((*ptr).SendEffect) as usize - ptr as usize },
+        80usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(SDL_VirtualJoystickDesc),
+            "::",
+            stringify!(SendEffect)
+        )
+    );
+}
 extern "C" {
-    #[doc = " Detach a virtual joystick."]
-    #[doc = ""]
-    #[doc = " \\param device_index a value previously returned from"]
-    #[doc = "                     SDL_JoystickAttachVirtual()"]
-    #[doc = " \\returns 0 on success, or -1 if an error occurred."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.14."]
+    #[doc = " Attach a new virtual joystick with extended properties.\n\n \\returns the joystick's device index, or -1 if an error occurred.\n\n \\since This function is available since SDL 2.24.0."]
+    pub fn SDL_JoystickAttachVirtualEx(desc: *const SDL_VirtualJoystickDesc) -> libc::c_int;
+}
+extern "C" {
+    #[doc = " Detach a virtual joystick.\n\n \\param device_index a value previously returned from\n                     SDL_JoystickAttachVirtual()\n \\returns 0 on success, or -1 if an error occurred.\n\n \\since This function is available since SDL 2.0.14."]
     pub fn SDL_JoystickDetachVirtual(device_index: libc::c_int) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Query whether or not the joystick at a given device index is virtual."]
-    #[doc = ""]
-    #[doc = " \\param device_index a joystick device index."]
-    #[doc = " \\returns SDL_TRUE if the joystick is virtual, SDL_FALSE otherwise."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.14."]
+    #[doc = " Query whether or not the joystick at a given device index is virtual.\n\n \\param device_index a joystick device index.\n \\returns SDL_TRUE if the joystick is virtual, SDL_FALSE otherwise.\n\n \\since This function is available since SDL 2.0.14."]
     pub fn SDL_JoystickIsVirtual(device_index: libc::c_int) -> SDL_bool;
 }
 extern "C" {
-    #[doc = " Set values on an opened, virtual-joystick's axis."]
-    #[doc = ""]
-    #[doc = " Please note that values set here will not be applied until the next call to"]
-    #[doc = " SDL_JoystickUpdate, which can either be called directly, or can be called"]
-    #[doc = " indirectly through various other SDL APIs, including, but not limited to"]
-    #[doc = " the following: SDL_PollEvent, SDL_PumpEvents, SDL_WaitEventTimeout,"]
-    #[doc = " SDL_WaitEvent."]
-    #[doc = ""]
-    #[doc = " \\param joystick the virtual joystick on which to set state."]
-    #[doc = " \\param axis the specific axis on the virtual joystick to set."]
-    #[doc = " \\param value the new value for the specified axis."]
-    #[doc = " \\returns 0 on success, -1 on error."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.14."]
+    #[doc = " Set values on an opened, virtual-joystick's axis.\n\n Please note that values set here will not be applied until the next call to\n SDL_JoystickUpdate, which can either be called directly, or can be called\n indirectly through various other SDL APIs, including, but not limited to\n the following: SDL_PollEvent, SDL_PumpEvents, SDL_WaitEventTimeout,\n SDL_WaitEvent.\n\n Note that when sending trigger axes, you should scale the value to the full\n range of Sint16. For example, a trigger at rest would have the value of\n `SDL_JOYSTICK_AXIS_MIN`.\n\n \\param joystick the virtual joystick on which to set state.\n \\param axis the specific axis on the virtual joystick to set.\n \\param value the new value for the specified axis.\n \\returns 0 on success, -1 on error.\n\n \\since This function is available since SDL 2.0.14."]
     pub fn SDL_JoystickSetVirtualAxis(
         joystick: *mut SDL_Joystick,
         axis: libc::c_int,
@@ -13652,20 +8622,7 @@ extern "C" {
     ) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Set values on an opened, virtual-joystick's button."]
-    #[doc = ""]
-    #[doc = " Please note that values set here will not be applied until the next call to"]
-    #[doc = " SDL_JoystickUpdate, which can either be called directly, or can be called"]
-    #[doc = " indirectly through various other SDL APIs, including, but not limited to"]
-    #[doc = " the following: SDL_PollEvent, SDL_PumpEvents, SDL_WaitEventTimeout,"]
-    #[doc = " SDL_WaitEvent."]
-    #[doc = ""]
-    #[doc = " \\param joystick the virtual joystick on which to set state."]
-    #[doc = " \\param button the specific button on the virtual joystick to set."]
-    #[doc = " \\param value the new value for the specified button."]
-    #[doc = " \\returns 0 on success, -1 on error."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.14."]
+    #[doc = " Set values on an opened, virtual-joystick's button.\n\n Please note that values set here will not be applied until the next call to\n SDL_JoystickUpdate, which can either be called directly, or can be called\n indirectly through various other SDL APIs, including, but not limited to\n the following: SDL_PollEvent, SDL_PumpEvents, SDL_WaitEventTimeout,\n SDL_WaitEvent.\n\n \\param joystick the virtual joystick on which to set state.\n \\param button the specific button on the virtual joystick to set.\n \\param value the new value for the specified button.\n \\returns 0 on success, -1 on error.\n\n \\since This function is available since SDL 2.0.14."]
     pub fn SDL_JoystickSetVirtualButton(
         joystick: *mut SDL_Joystick,
         button: libc::c_int,
@@ -13673,20 +8630,7 @@ extern "C" {
     ) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Set values on an opened, virtual-joystick's hat."]
-    #[doc = ""]
-    #[doc = " Please note that values set here will not be applied until the next call to"]
-    #[doc = " SDL_JoystickUpdate, which can either be called directly, or can be called"]
-    #[doc = " indirectly through various other SDL APIs, including, but not limited to"]
-    #[doc = " the following: SDL_PollEvent, SDL_PumpEvents, SDL_WaitEventTimeout,"]
-    #[doc = " SDL_WaitEvent."]
-    #[doc = ""]
-    #[doc = " \\param joystick the virtual joystick on which to set state."]
-    #[doc = " \\param hat the specific hat on the virtual joystick to set."]
-    #[doc = " \\param value the new value for the specified hat."]
-    #[doc = " \\returns 0 on success, -1 on error."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.14."]
+    #[doc = " Set values on an opened, virtual-joystick's hat.\n\n Please note that values set here will not be applied until the next call to\n SDL_JoystickUpdate, which can either be called directly, or can be called\n indirectly through various other SDL APIs, including, but not limited to\n the following: SDL_PollEvent, SDL_PumpEvents, SDL_WaitEventTimeout,\n SDL_WaitEvent.\n\n \\param joystick the virtual joystick on which to set state.\n \\param hat the specific hat on the virtual joystick to set.\n \\param value the new value for the specified hat.\n \\returns 0 on success, -1 on error.\n\n \\since This function is available since SDL 2.0.14."]
     pub fn SDL_JoystickSetVirtualHat(
         joystick: *mut SDL_Joystick,
         hat: libc::c_int,
@@ -13694,123 +8638,51 @@ extern "C" {
     ) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Get the implementation dependent name of a joystick."]
-    #[doc = ""]
-    #[doc = " \\param joystick the SDL_Joystick obtained from SDL_JoystickOpen()"]
-    #[doc = " \\returns the name of the selected joystick. If no name can be found, this"]
-    #[doc = "          function returns NULL; call SDL_GetError() for more information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_JoystickNameForIndex"]
-    #[doc = " \\sa SDL_JoystickOpen"]
+    #[doc = " Get the implementation dependent name of a joystick.\n\n \\param joystick the SDL_Joystick obtained from SDL_JoystickOpen()\n \\returns the name of the selected joystick. If no name can be found, this\n          function returns NULL; call SDL_GetError() for more information.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_JoystickNameForIndex\n \\sa SDL_JoystickOpen"]
     pub fn SDL_JoystickName(joystick: *mut SDL_Joystick) -> *const libc::c_char;
 }
 extern "C" {
-    #[doc = " Get the player index of an opened joystick."]
-    #[doc = ""]
-    #[doc = " For XInput controllers this returns the XInput user index. Many joysticks"]
-    #[doc = " will not be able to supply this information."]
-    #[doc = ""]
-    #[doc = " \\param joystick the SDL_Joystick obtained from SDL_JoystickOpen()"]
-    #[doc = " \\returns the player index, or -1 if it's not available."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.9."]
+    #[doc = " Get the implementation dependent path of a joystick.\n\n \\param joystick the SDL_Joystick obtained from SDL_JoystickOpen()\n \\returns the path of the selected joystick. If no path can be found, this\n          function returns NULL; call SDL_GetError() for more information.\n\n \\since This function is available since SDL 2.24.0.\n\n \\sa SDL_JoystickPathForIndex"]
+    pub fn SDL_JoystickPath(joystick: *mut SDL_Joystick) -> *const libc::c_char;
+}
+extern "C" {
+    #[doc = " Get the player index of an opened joystick.\n\n For XInput controllers this returns the XInput user index. Many joysticks\n will not be able to supply this information.\n\n \\param joystick the SDL_Joystick obtained from SDL_JoystickOpen()\n \\returns the player index, or -1 if it's not available.\n\n \\since This function is available since SDL 2.0.9."]
     pub fn SDL_JoystickGetPlayerIndex(joystick: *mut SDL_Joystick) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Set the player index of an opened joystick."]
-    #[doc = ""]
-    #[doc = " \\param joystick the SDL_Joystick obtained from SDL_JoystickOpen()"]
-    #[doc = " \\param player_index the player index to set."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.12."]
+    #[doc = " Set the player index of an opened joystick.\n\n \\param joystick the SDL_Joystick obtained from SDL_JoystickOpen()\n \\param player_index Player index to assign to this joystick, or -1 to clear\n                     the player index and turn off player LEDs.\n\n \\since This function is available since SDL 2.0.12."]
     pub fn SDL_JoystickSetPlayerIndex(joystick: *mut SDL_Joystick, player_index: libc::c_int);
 }
 extern "C" {
-    #[doc = " Get the implementation-dependent GUID for the joystick."]
-    #[doc = ""]
-    #[doc = " This function requires an open joystick."]
-    #[doc = ""]
-    #[doc = " \\param joystick the SDL_Joystick obtained from SDL_JoystickOpen()"]
-    #[doc = " \\returns the GUID of the given joystick. If called on an invalid index,"]
-    #[doc = "          this function returns a zero GUID; call SDL_GetError() for more"]
-    #[doc = "          information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_JoystickGetDeviceGUID"]
-    #[doc = " \\sa SDL_JoystickGetGUIDString"]
+    #[doc = " Get the implementation-dependent GUID for the joystick.\n\n This function requires an open joystick.\n\n \\param joystick the SDL_Joystick obtained from SDL_JoystickOpen()\n \\returns the GUID of the given joystick. If called on an invalid index,\n          this function returns a zero GUID; call SDL_GetError() for more\n          information.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_JoystickGetDeviceGUID\n \\sa SDL_JoystickGetGUIDString"]
     pub fn SDL_JoystickGetGUID(joystick: *mut SDL_Joystick) -> SDL_JoystickGUID;
 }
 extern "C" {
-    #[doc = " Get the USB vendor ID of an opened joystick, if available."]
-    #[doc = ""]
-    #[doc = " If the vendor ID isn't available this function returns 0."]
-    #[doc = ""]
-    #[doc = " \\param joystick the SDL_Joystick obtained from SDL_JoystickOpen()"]
-    #[doc = " \\returns the USB vendor ID of the selected joystick, or 0 if unavailable."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.6."]
+    #[doc = " Get the USB vendor ID of an opened joystick, if available.\n\n If the vendor ID isn't available this function returns 0.\n\n \\param joystick the SDL_Joystick obtained from SDL_JoystickOpen()\n \\returns the USB vendor ID of the selected joystick, or 0 if unavailable.\n\n \\since This function is available since SDL 2.0.6."]
     pub fn SDL_JoystickGetVendor(joystick: *mut SDL_Joystick) -> Uint16;
 }
 extern "C" {
-    #[doc = " Get the USB product ID of an opened joystick, if available."]
-    #[doc = ""]
-    #[doc = " If the product ID isn't available this function returns 0."]
-    #[doc = ""]
-    #[doc = " \\param joystick the SDL_Joystick obtained from SDL_JoystickOpen()"]
-    #[doc = " \\returns the USB product ID of the selected joystick, or 0 if unavailable."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.6."]
+    #[doc = " Get the USB product ID of an opened joystick, if available.\n\n If the product ID isn't available this function returns 0.\n\n \\param joystick the SDL_Joystick obtained from SDL_JoystickOpen()\n \\returns the USB product ID of the selected joystick, or 0 if unavailable.\n\n \\since This function is available since SDL 2.0.6."]
     pub fn SDL_JoystickGetProduct(joystick: *mut SDL_Joystick) -> Uint16;
 }
 extern "C" {
-    #[doc = " Get the product version of an opened joystick, if available."]
-    #[doc = ""]
-    #[doc = " If the product version isn't available this function returns 0."]
-    #[doc = ""]
-    #[doc = " \\param joystick the SDL_Joystick obtained from SDL_JoystickOpen()"]
-    #[doc = " \\returns the product version of the selected joystick, or 0 if unavailable."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.6."]
+    #[doc = " Get the product version of an opened joystick, if available.\n\n If the product version isn't available this function returns 0.\n\n \\param joystick the SDL_Joystick obtained from SDL_JoystickOpen()\n \\returns the product version of the selected joystick, or 0 if unavailable.\n\n \\since This function is available since SDL 2.0.6."]
     pub fn SDL_JoystickGetProductVersion(joystick: *mut SDL_Joystick) -> Uint16;
 }
 extern "C" {
-    #[doc = " Get the serial number of an opened joystick, if available."]
-    #[doc = ""]
-    #[doc = " Returns the serial number of the joystick, or NULL if it is not available."]
-    #[doc = ""]
-    #[doc = " \\param joystick the SDL_Joystick obtained from SDL_JoystickOpen()"]
-    #[doc = " \\returns the serial number of the selected joystick, or NULL if"]
-    #[doc = "          unavailable."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.14."]
+    #[doc = " Get the firmware version of an opened joystick, if available.\n\n If the firmware version isn't available this function returns 0.\n\n \\param joystick the SDL_Joystick obtained from SDL_JoystickOpen()\n \\returns the firmware version of the selected joystick, or 0 if\n          unavailable.\n\n \\since This function is available since SDL 2.24.0."]
+    pub fn SDL_JoystickGetFirmwareVersion(joystick: *mut SDL_Joystick) -> Uint16;
+}
+extern "C" {
+    #[doc = " Get the serial number of an opened joystick, if available.\n\n Returns the serial number of the joystick, or NULL if it is not available.\n\n \\param joystick the SDL_Joystick obtained from SDL_JoystickOpen()\n \\returns the serial number of the selected joystick, or NULL if\n          unavailable.\n\n \\since This function is available since SDL 2.0.14."]
     pub fn SDL_JoystickGetSerial(joystick: *mut SDL_Joystick) -> *const libc::c_char;
 }
 extern "C" {
-    #[doc = " Get the type of an opened joystick."]
-    #[doc = ""]
-    #[doc = " \\param joystick the SDL_Joystick obtained from SDL_JoystickOpen()"]
-    #[doc = " \\returns the SDL_JoystickType of the selected joystick."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.6."]
+    #[doc = " Get the type of an opened joystick.\n\n \\param joystick the SDL_Joystick obtained from SDL_JoystickOpen()\n \\returns the SDL_JoystickType of the selected joystick.\n\n \\since This function is available since SDL 2.0.6."]
     pub fn SDL_JoystickGetType(joystick: *mut SDL_Joystick) -> SDL_JoystickType;
 }
 extern "C" {
-    #[doc = " Get an ASCII string representation for a given SDL_JoystickGUID."]
-    #[doc = ""]
-    #[doc = " You should supply at least 33 bytes for pszGUID."]
-    #[doc = ""]
-    #[doc = " \\param guid the SDL_JoystickGUID you wish to convert to string"]
-    #[doc = " \\param pszGUID buffer in which to write the ASCII string"]
-    #[doc = " \\param cbGUID the size of pszGUID"]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_JoystickGetDeviceGUID"]
-    #[doc = " \\sa SDL_JoystickGetGUID"]
-    #[doc = " \\sa SDL_JoystickGetGUIDFromString"]
+    #[doc = " Get an ASCII string representation for a given SDL_JoystickGUID.\n\n You should supply at least 33 bytes for pszGUID.\n\n \\param guid the SDL_JoystickGUID you wish to convert to string\n \\param pszGUID buffer in which to write the ASCII string\n \\param cbGUID the size of pszGUID\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_JoystickGetDeviceGUID\n \\sa SDL_JoystickGetGUID\n \\sa SDL_JoystickGetGUIDFromString"]
     pub fn SDL_JoystickGetGUIDString(
         guid: SDL_JoystickGUID,
         pszGUID: *mut libc::c_char,
@@ -13818,177 +8690,57 @@ extern "C" {
     );
 }
 extern "C" {
-    #[doc = " Convert a GUID string into a SDL_JoystickGUID structure."]
-    #[doc = ""]
-    #[doc = " Performs no error checking. If this function is given a string containing"]
-    #[doc = " an invalid GUID, the function will silently succeed, but the GUID generated"]
-    #[doc = " will not be useful."]
-    #[doc = ""]
-    #[doc = " \\param pchGUID string containing an ASCII representation of a GUID"]
-    #[doc = " \\returns a SDL_JoystickGUID structure."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_JoystickGetGUIDString"]
+    #[doc = " Convert a GUID string into a SDL_JoystickGUID structure.\n\n Performs no error checking. If this function is given a string containing\n an invalid GUID, the function will silently succeed, but the GUID generated\n will not be useful.\n\n \\param pchGUID string containing an ASCII representation of a GUID\n \\returns a SDL_JoystickGUID structure.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_JoystickGetGUIDString"]
     pub fn SDL_JoystickGetGUIDFromString(pchGUID: *const libc::c_char) -> SDL_JoystickGUID;
 }
 extern "C" {
-    #[doc = " Get the status of a specified joystick."]
-    #[doc = ""]
-    #[doc = " \\param joystick the joystick to query"]
-    #[doc = " \\returns SDL_TRUE if the joystick has been opened, SDL_FALSE if it has not;"]
-    #[doc = "          call SDL_GetError() for more information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_JoystickClose"]
-    #[doc = " \\sa SDL_JoystickOpen"]
+    #[doc = " Get the device information encoded in a SDL_JoystickGUID structure\n\n \\param guid the SDL_JoystickGUID you wish to get info about\n \\param vendor A pointer filled in with the device VID, or 0 if not\n               available\n \\param product A pointer filled in with the device PID, or 0 if not\n                available\n \\param version A pointer filled in with the device version, or 0 if not\n                available\n \\param crc16 A pointer filled in with a CRC used to distinguish different\n              products with the same VID/PID, or 0 if not available\n\n \\since This function is available since SDL 2.26.0.\n\n \\sa SDL_JoystickGetDeviceGUID"]
+    pub fn SDL_GetJoystickGUIDInfo(
+        guid: SDL_JoystickGUID,
+        vendor: *mut Uint16,
+        product: *mut Uint16,
+        version: *mut Uint16,
+        crc16: *mut Uint16,
+    );
+}
+extern "C" {
+    #[doc = " Get the status of a specified joystick.\n\n \\param joystick the joystick to query\n \\returns SDL_TRUE if the joystick has been opened, SDL_FALSE if it has not;\n          call SDL_GetError() for more information.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_JoystickClose\n \\sa SDL_JoystickOpen"]
     pub fn SDL_JoystickGetAttached(joystick: *mut SDL_Joystick) -> SDL_bool;
 }
 extern "C" {
-    #[doc = " Get the instance ID of an opened joystick."]
-    #[doc = ""]
-    #[doc = " \\param joystick an SDL_Joystick structure containing joystick information"]
-    #[doc = " \\returns the instance ID of the specified joystick on success or a negative"]
-    #[doc = "          error code on failure; call SDL_GetError() for more information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_JoystickOpen"]
+    #[doc = " Get the instance ID of an opened joystick.\n\n \\param joystick an SDL_Joystick structure containing joystick information\n \\returns the instance ID of the specified joystick on success or a negative\n          error code on failure; call SDL_GetError() for more information.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_JoystickOpen"]
     pub fn SDL_JoystickInstanceID(joystick: *mut SDL_Joystick) -> SDL_JoystickID;
 }
 extern "C" {
-    #[doc = " Get the number of general axis controls on a joystick."]
-    #[doc = ""]
-    #[doc = " Often, the directional pad on a game controller will either look like 4"]
-    #[doc = " separate buttons or a POV hat, and not axes, but all of this is up to the"]
-    #[doc = " device and platform."]
-    #[doc = ""]
-    #[doc = " \\param joystick an SDL_Joystick structure containing joystick information"]
-    #[doc = " \\returns the number of axis controls/number of axes on success or a"]
-    #[doc = "          negative error code on failure; call SDL_GetError() for more"]
-    #[doc = "          information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_JoystickGetAxis"]
-    #[doc = " \\sa SDL_JoystickOpen"]
+    #[doc = " Get the number of general axis controls on a joystick.\n\n Often, the directional pad on a game controller will either look like 4\n separate buttons or a POV hat, and not axes, but all of this is up to the\n device and platform.\n\n \\param joystick an SDL_Joystick structure containing joystick information\n \\returns the number of axis controls/number of axes on success or a\n          negative error code on failure; call SDL_GetError() for more\n          information.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_JoystickGetAxis\n \\sa SDL_JoystickOpen"]
     pub fn SDL_JoystickNumAxes(joystick: *mut SDL_Joystick) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Get the number of trackballs on a joystick."]
-    #[doc = ""]
-    #[doc = " Joystick trackballs have only relative motion events associated with them"]
-    #[doc = " and their state cannot be polled."]
-    #[doc = ""]
-    #[doc = " Most joysticks do not have trackballs."]
-    #[doc = ""]
-    #[doc = " \\param joystick an SDL_Joystick structure containing joystick information"]
-    #[doc = " \\returns the number of trackballs on success or a negative error code on"]
-    #[doc = "          failure; call SDL_GetError() for more information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_JoystickGetBall"]
+    #[doc = " Get the number of trackballs on a joystick.\n\n Joystick trackballs have only relative motion events associated with them\n and their state cannot be polled.\n\n Most joysticks do not have trackballs.\n\n \\param joystick an SDL_Joystick structure containing joystick information\n \\returns the number of trackballs on success or a negative error code on\n          failure; call SDL_GetError() for more information.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_JoystickGetBall"]
     pub fn SDL_JoystickNumBalls(joystick: *mut SDL_Joystick) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Get the number of POV hats on a joystick."]
-    #[doc = ""]
-    #[doc = " \\param joystick an SDL_Joystick structure containing joystick information"]
-    #[doc = " \\returns the number of POV hats on success or a negative error code on"]
-    #[doc = "          failure; call SDL_GetError() for more information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_JoystickGetHat"]
-    #[doc = " \\sa SDL_JoystickOpen"]
+    #[doc = " Get the number of POV hats on a joystick.\n\n \\param joystick an SDL_Joystick structure containing joystick information\n \\returns the number of POV hats on success or a negative error code on\n          failure; call SDL_GetError() for more information.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_JoystickGetHat\n \\sa SDL_JoystickOpen"]
     pub fn SDL_JoystickNumHats(joystick: *mut SDL_Joystick) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Get the number of buttons on a joystick."]
-    #[doc = ""]
-    #[doc = " \\param joystick an SDL_Joystick structure containing joystick information"]
-    #[doc = " \\returns the number of buttons on success or a negative error code on"]
-    #[doc = "          failure; call SDL_GetError() for more information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_JoystickGetButton"]
-    #[doc = " \\sa SDL_JoystickOpen"]
+    #[doc = " Get the number of buttons on a joystick.\n\n \\param joystick an SDL_Joystick structure containing joystick information\n \\returns the number of buttons on success or a negative error code on\n          failure; call SDL_GetError() for more information.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_JoystickGetButton\n \\sa SDL_JoystickOpen"]
     pub fn SDL_JoystickNumButtons(joystick: *mut SDL_Joystick) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Update the current state of the open joysticks."]
-    #[doc = ""]
-    #[doc = " This is called automatically by the event loop if any joystick events are"]
-    #[doc = " enabled."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_JoystickEventState"]
+    #[doc = " Update the current state of the open joysticks.\n\n This is called automatically by the event loop if any joystick events are\n enabled.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_JoystickEventState"]
     pub fn SDL_JoystickUpdate();
 }
 extern "C" {
-    #[doc = " Enable/disable joystick event polling."]
-    #[doc = ""]
-    #[doc = " If joystick events are disabled, you must call SDL_JoystickUpdate()"]
-    #[doc = " yourself and manually check the state of the joystick when you want"]
-    #[doc = " joystick information."]
-    #[doc = ""]
-    #[doc = " It is recommended that you leave joystick event handling enabled."]
-    #[doc = ""]
-    #[doc = " **WARNING**: Calling this function may delete all events currently in SDL's"]
-    #[doc = " event queue."]
-    #[doc = ""]
-    #[doc = " \\param state can be one of `SDL_QUERY`, `SDL_IGNORE`, or `SDL_ENABLE`"]
-    #[doc = " \\returns 1 if enabled, 0 if disabled, or a negative error code on failure;"]
-    #[doc = "          call SDL_GetError() for more information."]
-    #[doc = ""]
-    #[doc = "          If `state` is `SDL_QUERY` then the current state is returned,"]
-    #[doc = "          otherwise the new processing state is returned."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_GameControllerEventState"]
+    #[doc = " Enable/disable joystick event polling.\n\n If joystick events are disabled, you must call SDL_JoystickUpdate()\n yourself and manually check the state of the joystick when you want\n joystick information.\n\n It is recommended that you leave joystick event handling enabled.\n\n **WARNING**: Calling this function may delete all events currently in SDL's\n event queue.\n\n \\param state can be one of `SDL_QUERY`, `SDL_IGNORE`, or `SDL_ENABLE`\n \\returns 1 if enabled, 0 if disabled, or a negative error code on failure;\n          call SDL_GetError() for more information.\n\n          If `state` is `SDL_QUERY` then the current state is returned,\n          otherwise the new processing state is returned.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_GameControllerEventState"]
     pub fn SDL_JoystickEventState(state: libc::c_int) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Get the current state of an axis control on a joystick."]
-    #[doc = ""]
-    #[doc = " SDL makes no promises about what part of the joystick any given axis refers"]
-    #[doc = " to. Your game should have some sort of configuration UI to let users"]
-    #[doc = " specify what each axis should be bound to. Alternately, SDL's higher-level"]
-    #[doc = " Game Controller API makes a great effort to apply order to this lower-level"]
-    #[doc = " interface, so you know that a specific axis is the \"left thumb stick,\" etc."]
-    #[doc = ""]
-    #[doc = " The value returned by SDL_JoystickGetAxis() is a signed integer (-32768 to"]
-    #[doc = " 32767) representing the current position of the axis. It may be necessary"]
-    #[doc = " to impose certain tolerances on these values to account for jitter."]
-    #[doc = ""]
-    #[doc = " \\param joystick an SDL_Joystick structure containing joystick information"]
-    #[doc = " \\param axis the axis to query; the axis indices start at index 0"]
-    #[doc = " \\returns a 16-bit signed integer representing the current position of the"]
-    #[doc = "          axis or 0 on failure; call SDL_GetError() for more information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_JoystickNumAxes"]
+    #[doc = " Get the current state of an axis control on a joystick.\n\n SDL makes no promises about what part of the joystick any given axis refers\n to. Your game should have some sort of configuration UI to let users\n specify what each axis should be bound to. Alternately, SDL's higher-level\n Game Controller API makes a great effort to apply order to this lower-level\n interface, so you know that a specific axis is the \"left thumb stick,\" etc.\n\n The value returned by SDL_JoystickGetAxis() is a signed integer (-32768 to\n 32767) representing the current position of the axis. It may be necessary\n to impose certain tolerances on these values to account for jitter.\n\n \\param joystick an SDL_Joystick structure containing joystick information\n \\param axis the axis to query; the axis indices start at index 0\n \\returns a 16-bit signed integer representing the current position of the\n          axis or 0 on failure; call SDL_GetError() for more information.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_JoystickNumAxes"]
     pub fn SDL_JoystickGetAxis(joystick: *mut SDL_Joystick, axis: libc::c_int) -> Sint16;
 }
 extern "C" {
-    #[doc = " Get the initial state of an axis control on a joystick."]
-    #[doc = ""]
-    #[doc = " The state is a value ranging from -32768 to 32767."]
-    #[doc = ""]
-    #[doc = " The axis indices start at index 0."]
-    #[doc = ""]
-    #[doc = " \\param joystick an SDL_Joystick structure containing joystick information"]
-    #[doc = " \\param axis the axis to query; the axis indices start at index 0"]
-    #[doc = " \\param state Upon return, the initial value is supplied here."]
-    #[doc = " \\return SDL_TRUE if this axis has any initial value, or SDL_FALSE if not."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.6."]
+    #[doc = " Get the initial state of an axis control on a joystick.\n\n The state is a value ranging from -32768 to 32767.\n\n The axis indices start at index 0.\n\n \\param joystick an SDL_Joystick structure containing joystick information\n \\param axis the axis to query; the axis indices start at index 0\n \\param state Upon return, the initial value is supplied here.\n \\return SDL_TRUE if this axis has any initial value, or SDL_FALSE if not.\n\n \\since This function is available since SDL 2.0.6."]
     pub fn SDL_JoystickGetAxisInitialState(
         joystick: *mut SDL_Joystick,
         axis: libc::c_int,
@@ -13996,47 +8748,11 @@ extern "C" {
     ) -> SDL_bool;
 }
 extern "C" {
-    #[doc = " Get the current state of a POV hat on a joystick."]
-    #[doc = ""]
-    #[doc = " The returned value will be one of the following positions:"]
-    #[doc = ""]
-    #[doc = " - `SDL_HAT_CENTERED`"]
-    #[doc = " - `SDL_HAT_UP`"]
-    #[doc = " - `SDL_HAT_RIGHT`"]
-    #[doc = " - `SDL_HAT_DOWN`"]
-    #[doc = " - `SDL_HAT_LEFT`"]
-    #[doc = " - `SDL_HAT_RIGHTUP`"]
-    #[doc = " - `SDL_HAT_RIGHTDOWN`"]
-    #[doc = " - `SDL_HAT_LEFTUP`"]
-    #[doc = " - `SDL_HAT_LEFTDOWN`"]
-    #[doc = ""]
-    #[doc = " \\param joystick an SDL_Joystick structure containing joystick information"]
-    #[doc = " \\param hat the hat index to get the state from; indices start at index 0"]
-    #[doc = " \\returns the current hat position."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_JoystickNumHats"]
+    #[doc = " Get the current state of a POV hat on a joystick.\n\n The returned value will be one of the following positions:\n\n - `SDL_HAT_CENTERED`\n - `SDL_HAT_UP`\n - `SDL_HAT_RIGHT`\n - `SDL_HAT_DOWN`\n - `SDL_HAT_LEFT`\n - `SDL_HAT_RIGHTUP`\n - `SDL_HAT_RIGHTDOWN`\n - `SDL_HAT_LEFTUP`\n - `SDL_HAT_LEFTDOWN`\n\n \\param joystick an SDL_Joystick structure containing joystick information\n \\param hat the hat index to get the state from; indices start at index 0\n \\returns the current hat position.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_JoystickNumHats"]
     pub fn SDL_JoystickGetHat(joystick: *mut SDL_Joystick, hat: libc::c_int) -> Uint8;
 }
 extern "C" {
-    #[doc = " Get the ball axis change since the last poll."]
-    #[doc = ""]
-    #[doc = " Trackballs can only return relative motion since the last call to"]
-    #[doc = " SDL_JoystickGetBall(), these motion deltas are placed into `dx` and `dy`."]
-    #[doc = ""]
-    #[doc = " Most joysticks do not have trackballs."]
-    #[doc = ""]
-    #[doc = " \\param joystick the SDL_Joystick to query"]
-    #[doc = " \\param ball the ball index to query; ball indices start at index 0"]
-    #[doc = " \\param dx stores the difference in the x axis position since the last poll"]
-    #[doc = " \\param dy stores the difference in the y axis position since the last poll"]
-    #[doc = " \\returns 0 on success or a negative error code on failure; call"]
-    #[doc = "          SDL_GetError() for more information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_JoystickNumBalls"]
+    #[doc = " Get the ball axis change since the last poll.\n\n Trackballs can only return relative motion since the last call to\n SDL_JoystickGetBall(), these motion deltas are placed into `dx` and `dy`.\n\n Most joysticks do not have trackballs.\n\n \\param joystick the SDL_Joystick to query\n \\param ball the ball index to query; ball indices start at index 0\n \\param dx stores the difference in the x axis position since the last poll\n \\param dy stores the difference in the y axis position since the last poll\n \\returns 0 on success or a negative error code on failure; call\n          SDL_GetError() for more information.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_JoystickNumBalls"]
     pub fn SDL_JoystickGetBall(
         joystick: *mut SDL_Joystick,
         ball: libc::c_int,
@@ -14045,35 +8761,11 @@ extern "C" {
     ) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Get the current state of a button on a joystick."]
-    #[doc = ""]
-    #[doc = " \\param joystick an SDL_Joystick structure containing joystick information"]
-    #[doc = " \\param button the button index to get the state from; indices start at"]
-    #[doc = "               index 0"]
-    #[doc = " \\returns 1 if the specified button is pressed, 0 otherwise."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_JoystickNumButtons"]
+    #[doc = " Get the current state of a button on a joystick.\n\n \\param joystick an SDL_Joystick structure containing joystick information\n \\param button the button index to get the state from; indices start at\n               index 0\n \\returns 1 if the specified button is pressed, 0 otherwise.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_JoystickNumButtons"]
     pub fn SDL_JoystickGetButton(joystick: *mut SDL_Joystick, button: libc::c_int) -> Uint8;
 }
 extern "C" {
-    #[doc = " Start a rumble effect."]
-    #[doc = ""]
-    #[doc = " Each call to this function cancels any previous rumble effect, and calling"]
-    #[doc = " it with 0 intensity stops any rumbling."]
-    #[doc = ""]
-    #[doc = " \\param joystick The joystick to vibrate"]
-    #[doc = " \\param low_frequency_rumble The intensity of the low frequency (left)"]
-    #[doc = "                             rumble motor, from 0 to 0xFFFF"]
-    #[doc = " \\param high_frequency_rumble The intensity of the high frequency (right)"]
-    #[doc = "                              rumble motor, from 0 to 0xFFFF"]
-    #[doc = " \\param duration_ms The duration of the rumble effect, in milliseconds"]
-    #[doc = " \\returns 0, or -1 if rumble isn't supported on this joystick"]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.9."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_JoystickHasRumble"]
+    #[doc = " Start a rumble effect.\n\n Each call to this function cancels any previous rumble effect, and calling\n it with 0 intensity stops any rumbling.\n\n \\param joystick The joystick to vibrate\n \\param low_frequency_rumble The intensity of the low frequency (left)\n                             rumble motor, from 0 to 0xFFFF\n \\param high_frequency_rumble The intensity of the high frequency (right)\n                              rumble motor, from 0 to 0xFFFF\n \\param duration_ms The duration of the rumble effect, in milliseconds\n \\returns 0, or -1 if rumble isn't supported on this joystick\n\n \\since This function is available since SDL 2.0.9.\n\n \\sa SDL_JoystickHasRumble"]
     pub fn SDL_JoystickRumble(
         joystick: *mut SDL_Joystick,
         low_frequency_rumble: Uint16,
@@ -14082,27 +8774,7 @@ extern "C" {
     ) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Start a rumble effect in the joystick's triggers"]
-    #[doc = ""]
-    #[doc = " Each call to this function cancels any previous trigger rumble effect, and"]
-    #[doc = " calling it with 0 intensity stops any rumbling."]
-    #[doc = ""]
-    #[doc = " Note that this function is for _trigger_ rumble; the first joystick to"]
-    #[doc = " support this was the PlayStation 5's DualShock 5 controller. If you want"]
-    #[doc = " the (more common) whole-controller rumble, use SDL_JoystickRumble()"]
-    #[doc = " instead."]
-    #[doc = ""]
-    #[doc = " \\param joystick The joystick to vibrate"]
-    #[doc = " \\param left_rumble The intensity of the left trigger rumble motor, from 0"]
-    #[doc = "                    to 0xFFFF"]
-    #[doc = " \\param right_rumble The intensity of the right trigger rumble motor, from 0"]
-    #[doc = "                     to 0xFFFF"]
-    #[doc = " \\param duration_ms The duration of the rumble effect, in milliseconds"]
-    #[doc = " \\returns 0, or -1 if trigger rumble isn't supported on this joystick"]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.14."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_JoystickHasRumbleTriggers"]
+    #[doc = " Start a rumble effect in the joystick's triggers\n\n Each call to this function cancels any previous trigger rumble effect, and\n calling it with 0 intensity stops any rumbling.\n\n Note that this is rumbling of the _triggers_ and not the game controller as\n a whole. This is currently only supported on Xbox One controllers. If you\n want the (more common) whole-controller rumble, use SDL_JoystickRumble()\n instead.\n\n \\param joystick The joystick to vibrate\n \\param left_rumble The intensity of the left trigger rumble motor, from 0\n                    to 0xFFFF\n \\param right_rumble The intensity of the right trigger rumble motor, from 0\n                     to 0xFFFF\n \\param duration_ms The duration of the rumble effect, in milliseconds\n \\returns 0, or -1 if trigger rumble isn't supported on this joystick\n\n \\since This function is available since SDL 2.0.14.\n\n \\sa SDL_JoystickHasRumbleTriggers"]
     pub fn SDL_JoystickRumbleTriggers(
         joystick: *mut SDL_Joystick,
         left_rumble: Uint16,
@@ -14111,52 +8783,19 @@ extern "C" {
     ) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Query whether a joystick has an LED."]
-    #[doc = ""]
-    #[doc = " An example of a joystick LED is the light on the back of a PlayStation 4's"]
-    #[doc = " DualShock 4 controller."]
-    #[doc = ""]
-    #[doc = " \\param joystick The joystick to query"]
-    #[doc = " \\return SDL_TRUE if the joystick has a modifiable LED, SDL_FALSE otherwise."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.14."]
+    #[doc = " Query whether a joystick has an LED.\n\n An example of a joystick LED is the light on the back of a PlayStation 4's\n DualShock 4 controller.\n\n \\param joystick The joystick to query\n \\return SDL_TRUE if the joystick has a modifiable LED, SDL_FALSE otherwise.\n\n \\since This function is available since SDL 2.0.14."]
     pub fn SDL_JoystickHasLED(joystick: *mut SDL_Joystick) -> SDL_bool;
 }
 extern "C" {
-    #[doc = " Query whether a joystick has rumble support."]
-    #[doc = ""]
-    #[doc = " \\param joystick The joystick to query"]
-    #[doc = " \\return SDL_TRUE if the joystick has rumble, SDL_FALSE otherwise."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.18."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_JoystickRumble"]
+    #[doc = " Query whether a joystick has rumble support.\n\n \\param joystick The joystick to query\n \\return SDL_TRUE if the joystick has rumble, SDL_FALSE otherwise.\n\n \\since This function is available since SDL 2.0.18.\n\n \\sa SDL_JoystickRumble"]
     pub fn SDL_JoystickHasRumble(joystick: *mut SDL_Joystick) -> SDL_bool;
 }
 extern "C" {
-    #[doc = " Query whether a joystick has rumble support on triggers."]
-    #[doc = ""]
-    #[doc = " \\param joystick The joystick to query"]
-    #[doc = " \\return SDL_TRUE if the joystick has trigger rumble, SDL_FALSE otherwise."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.18."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_JoystickRumbleTriggers"]
+    #[doc = " Query whether a joystick has rumble support on triggers.\n\n \\param joystick The joystick to query\n \\return SDL_TRUE if the joystick has trigger rumble, SDL_FALSE otherwise.\n\n \\since This function is available since SDL 2.0.18.\n\n \\sa SDL_JoystickRumbleTriggers"]
     pub fn SDL_JoystickHasRumbleTriggers(joystick: *mut SDL_Joystick) -> SDL_bool;
 }
 extern "C" {
-    #[doc = " Update a joystick's LED color."]
-    #[doc = ""]
-    #[doc = " An example of a joystick LED is the light on the back of a PlayStation 4's"]
-    #[doc = " DualShock 4 controller."]
-    #[doc = ""]
-    #[doc = " \\param joystick The joystick to update"]
-    #[doc = " \\param red The intensity of the red LED"]
-    #[doc = " \\param green The intensity of the green LED"]
-    #[doc = " \\param blue The intensity of the blue LED"]
-    #[doc = " \\returns 0 on success, -1 if this joystick does not have a modifiable LED"]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.14."]
+    #[doc = " Update a joystick's LED color.\n\n An example of a joystick LED is the light on the back of a PlayStation 4's\n DualShock 4 controller.\n\n \\param joystick The joystick to update\n \\param red The intensity of the red LED\n \\param green The intensity of the green LED\n \\param blue The intensity of the blue LED\n \\returns 0 on success, -1 if this joystick does not have a modifiable LED\n\n \\since This function is available since SDL 2.0.14."]
     pub fn SDL_JoystickSetLED(
         joystick: *mut SDL_Joystick,
         red: Uint8,
@@ -14165,14 +8804,7 @@ extern "C" {
     ) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Send a joystick specific effect packet"]
-    #[doc = ""]
-    #[doc = " \\param joystick The joystick to affect"]
-    #[doc = " \\param data The data to send to the joystick"]
-    #[doc = " \\param size The size of the data to send to the joystick"]
-    #[doc = " \\returns 0, or -1 if this joystick or driver doesn't support effect packets"]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.16."]
+    #[doc = " Send a joystick specific effect packet\n\n \\param joystick The joystick to affect\n \\param data The data to send to the joystick\n \\param size The size of the data to send to the joystick\n \\returns 0, or -1 if this joystick or driver doesn't support effect packets\n\n \\since This function is available since SDL 2.0.16."]
     pub fn SDL_JoystickSendEffect(
         joystick: *mut SDL_Joystick,
         data: *const libc::c_void,
@@ -14180,43 +8812,24 @@ extern "C" {
     ) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Close a joystick previously opened with SDL_JoystickOpen()."]
-    #[doc = ""]
-    #[doc = " \\param joystick The joystick device to close"]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_JoystickOpen"]
+    #[doc = " Close a joystick previously opened with SDL_JoystickOpen().\n\n \\param joystick The joystick device to close\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_JoystickOpen"]
     pub fn SDL_JoystickClose(joystick: *mut SDL_Joystick);
 }
 extern "C" {
-    #[doc = " Get the battery level of a joystick as SDL_JoystickPowerLevel."]
-    #[doc = ""]
-    #[doc = " \\param joystick the SDL_Joystick to query"]
-    #[doc = " \\returns the current battery level as SDL_JoystickPowerLevel on success or"]
-    #[doc = "          `SDL_JOYSTICK_POWER_UNKNOWN` if it is unknown"]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.4."]
+    #[doc = " Get the battery level of a joystick as SDL_JoystickPowerLevel.\n\n \\param joystick the SDL_Joystick to query\n \\returns the current battery level as SDL_JoystickPowerLevel on success or\n          `SDL_JOYSTICK_POWER_UNKNOWN` if it is unknown\n\n \\since This function is available since SDL 2.0.4."]
     pub fn SDL_JoystickCurrentPowerLevel(joystick: *mut SDL_Joystick) -> SDL_JoystickPowerLevel;
 }
-#[doc = "  \\brief SDL_sensor.h"]
-#[doc = ""]
-#[doc = "  In order to use these functions, SDL_Init() must have been called"]
-#[doc = "  with the ::SDL_INIT_SENSOR flag.  This causes SDL to scan the system"]
-#[doc = "  for sensors, and load appropriate drivers."]
+#[doc = "  \\brief SDL_sensor.h\n\n  In order to use these functions, SDL_Init() must have been called\n  with the ::SDL_INIT_SENSOR flag.  This causes SDL to scan the system\n  for sensors, and load appropriate drivers."]
 #[repr(C)]
 #[derive(Copy, Clone)]
 pub struct _SDL_Sensor {
     _unused: [u8; 0],
 }
 pub type SDL_Sensor = _SDL_Sensor;
-#[doc = " This is a unique ID for a sensor for the time it is connected to the system,"]
-#[doc = " and is never reused for the lifetime of the application."]
-#[doc = ""]
-#[doc = " The ID value starts at 0 and increments from there. The value -1 is an invalid ID."]
+#[doc = " This is a unique ID for a sensor for the time it is connected to the system,\n and is never reused for the lifetime of the application.\n\n The ID value starts at 0 and increments from there. The value -1 is an invalid ID."]
 pub type SDL_SensorID = Sint32;
 #[repr(i32)]
-#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
+#[derive(Copy, Clone, Hash, PartialEq, Eq)]
 pub enum SDL_SensorType {
     #[doc = "< Returned for an invalid sensor"]
     SDL_SENSOR_INVALID = -1,
@@ -14226,135 +8839,68 @@ pub enum SDL_SensorType {
     SDL_SENSOR_ACCEL = 1,
     #[doc = "< Gyroscope"]
     SDL_SENSOR_GYRO = 2,
+    #[doc = "< Accelerometer for left Joy-Con controller and Wii nunchuk"]
+    SDL_SENSOR_ACCEL_L = 3,
+    #[doc = "< Gyroscope for left Joy-Con controller"]
+    SDL_SENSOR_GYRO_L = 4,
+    #[doc = "< Accelerometer for right Joy-Con controller"]
+    SDL_SENSOR_ACCEL_R = 5,
+    #[doc = "< Gyroscope for right Joy-Con controller"]
+    SDL_SENSOR_GYRO_R = 6,
 }
 extern "C" {
-    #[doc = " Locking for multi-threaded access to the sensor API"]
-    #[doc = ""]
-    #[doc = " If you are using the sensor API or handling events from multiple threads"]
-    #[doc = " you should use these locking functions to protect access to the sensors."]
-    #[doc = ""]
-    #[doc = " In particular, you are guaranteed that the sensor list won't change, so the"]
-    #[doc = " API functions that take a sensor index will be valid, and sensor events"]
-    #[doc = " will not be delivered."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.14."]
+    #[doc = " Locking for multi-threaded access to the sensor API\n\n If you are using the sensor API or handling events from multiple threads\n you should use these locking functions to protect access to the sensors.\n\n In particular, you are guaranteed that the sensor list won't change, so the\n API functions that take a sensor index will be valid, and sensor events\n will not be delivered.\n\n \\since This function is available since SDL 2.0.14."]
     pub fn SDL_LockSensors();
 }
 extern "C" {
     pub fn SDL_UnlockSensors();
 }
 extern "C" {
-    #[doc = " Count the number of sensors attached to the system right now."]
-    #[doc = ""]
-    #[doc = " \\returns the number of sensors detected."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.9."]
+    #[doc = " Count the number of sensors attached to the system right now.\n\n \\returns the number of sensors detected.\n\n \\since This function is available since SDL 2.0.9."]
     pub fn SDL_NumSensors() -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Get the implementation dependent name of a sensor."]
-    #[doc = ""]
-    #[doc = " \\param device_index The sensor to obtain name from"]
-    #[doc = " \\returns the sensor name, or NULL if `device_index` is out of range."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.9."]
+    #[doc = " Get the implementation dependent name of a sensor.\n\n \\param device_index The sensor to obtain name from\n \\returns the sensor name, or NULL if `device_index` is out of range.\n\n \\since This function is available since SDL 2.0.9."]
     pub fn SDL_SensorGetDeviceName(device_index: libc::c_int) -> *const libc::c_char;
 }
 extern "C" {
-    #[doc = " Get the type of a sensor."]
-    #[doc = ""]
-    #[doc = " \\param device_index The sensor to get the type from"]
-    #[doc = " \\returns the SDL_SensorType, or `SDL_SENSOR_INVALID` if `device_index` is"]
-    #[doc = "          out of range."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.9."]
+    #[doc = " Get the type of a sensor.\n\n \\param device_index The sensor to get the type from\n \\returns the SDL_SensorType, or `SDL_SENSOR_INVALID` if `device_index` is\n          out of range.\n\n \\since This function is available since SDL 2.0.9."]
     pub fn SDL_SensorGetDeviceType(device_index: libc::c_int) -> SDL_SensorType;
 }
 extern "C" {
-    #[doc = " Get the platform dependent type of a sensor."]
-    #[doc = ""]
-    #[doc = " \\param device_index The sensor to check"]
-    #[doc = " \\returns the sensor platform dependent type, or -1 if `device_index` is out"]
-    #[doc = "          of range."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.9."]
+    #[doc = " Get the platform dependent type of a sensor.\n\n \\param device_index The sensor to check\n \\returns the sensor platform dependent type, or -1 if `device_index` is out\n          of range.\n\n \\since This function is available since SDL 2.0.9."]
     pub fn SDL_SensorGetDeviceNonPortableType(device_index: libc::c_int) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Get the instance ID of a sensor."]
-    #[doc = ""]
-    #[doc = " \\param device_index The sensor to get instance id from"]
-    #[doc = " \\returns the sensor instance ID, or -1 if `device_index` is out of range."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.9."]
+    #[doc = " Get the instance ID of a sensor.\n\n \\param device_index The sensor to get instance id from\n \\returns the sensor instance ID, or -1 if `device_index` is out of range.\n\n \\since This function is available since SDL 2.0.9."]
     pub fn SDL_SensorGetDeviceInstanceID(device_index: libc::c_int) -> SDL_SensorID;
 }
 extern "C" {
-    #[doc = " Open a sensor for use."]
-    #[doc = ""]
-    #[doc = " \\param device_index The sensor to open"]
-    #[doc = " \\returns an SDL_Sensor sensor object, or NULL if an error occurred."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.9."]
+    #[doc = " Open a sensor for use.\n\n \\param device_index The sensor to open\n \\returns an SDL_Sensor sensor object, or NULL if an error occurred.\n\n \\since This function is available since SDL 2.0.9."]
     pub fn SDL_SensorOpen(device_index: libc::c_int) -> *mut SDL_Sensor;
 }
 extern "C" {
-    #[doc = " Return the SDL_Sensor associated with an instance id."]
-    #[doc = ""]
-    #[doc = " \\param instance_id The sensor from instance id"]
-    #[doc = " \\returns an SDL_Sensor object."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.9."]
+    #[doc = " Return the SDL_Sensor associated with an instance id.\n\n \\param instance_id The sensor from instance id\n \\returns an SDL_Sensor object.\n\n \\since This function is available since SDL 2.0.9."]
     pub fn SDL_SensorFromInstanceID(instance_id: SDL_SensorID) -> *mut SDL_Sensor;
 }
 extern "C" {
-    #[doc = " Get the implementation dependent name of a sensor"]
-    #[doc = ""]
-    #[doc = " \\param sensor The SDL_Sensor object"]
-    #[doc = " \\returns the sensor name, or NULL if `sensor` is NULL."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.9."]
+    #[doc = " Get the implementation dependent name of a sensor\n\n \\param sensor The SDL_Sensor object\n \\returns the sensor name, or NULL if `sensor` is NULL.\n\n \\since This function is available since SDL 2.0.9."]
     pub fn SDL_SensorGetName(sensor: *mut SDL_Sensor) -> *const libc::c_char;
 }
 extern "C" {
-    #[doc = " Get the type of a sensor."]
-    #[doc = ""]
-    #[doc = " \\param sensor The SDL_Sensor object to inspect"]
-    #[doc = " \\returns the SDL_SensorType type, or `SDL_SENSOR_INVALID` if `sensor` is"]
-    #[doc = "          NULL."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.9."]
+    #[doc = " Get the type of a sensor.\n\n \\param sensor The SDL_Sensor object to inspect\n \\returns the SDL_SensorType type, or `SDL_SENSOR_INVALID` if `sensor` is\n          NULL.\n\n \\since This function is available since SDL 2.0.9."]
     pub fn SDL_SensorGetType(sensor: *mut SDL_Sensor) -> SDL_SensorType;
 }
 extern "C" {
-    #[doc = " Get the platform dependent type of a sensor."]
-    #[doc = ""]
-    #[doc = " \\param sensor The SDL_Sensor object to inspect"]
-    #[doc = " \\returns the sensor platform dependent type, or -1 if `sensor` is NULL."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.9."]
+    #[doc = " Get the platform dependent type of a sensor.\n\n \\param sensor The SDL_Sensor object to inspect\n \\returns the sensor platform dependent type, or -1 if `sensor` is NULL.\n\n \\since This function is available since SDL 2.0.9."]
     pub fn SDL_SensorGetNonPortableType(sensor: *mut SDL_Sensor) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Get the instance ID of a sensor."]
-    #[doc = ""]
-    #[doc = " \\param sensor The SDL_Sensor object to inspect"]
-    #[doc = " \\returns the sensor instance ID, or -1 if `sensor` is NULL."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.9."]
+    #[doc = " Get the instance ID of a sensor.\n\n \\param sensor The SDL_Sensor object to inspect\n \\returns the sensor instance ID, or -1 if `sensor` is NULL.\n\n \\since This function is available since SDL 2.0.9."]
     pub fn SDL_SensorGetInstanceID(sensor: *mut SDL_Sensor) -> SDL_SensorID;
 }
 extern "C" {
-    #[doc = " Get the current state of an opened sensor."]
-    #[doc = ""]
-    #[doc = " The number of values and interpretation of the data is sensor dependent."]
-    #[doc = ""]
-    #[doc = " \\param sensor The SDL_Sensor object to query"]
-    #[doc = " \\param data A pointer filled with the current sensor state"]
-    #[doc = " \\param num_values The number of values to write to data"]
-    #[doc = " \\returns 0 or -1 if an error occurred."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.9."]
+    #[doc = " Get the current state of an opened sensor.\n\n The number of values and interpretation of the data is sensor dependent.\n\n \\param sensor The SDL_Sensor object to query\n \\param data A pointer filled with the current sensor state\n \\param num_values The number of values to write to data\n \\returns 0 or -1 if an error occurred.\n\n \\since This function is available since SDL 2.0.9."]
     pub fn SDL_SensorGetData(
         sensor: *mut SDL_Sensor,
         data: *mut f32,
@@ -14362,23 +8908,20 @@ extern "C" {
     ) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Close a sensor previously opened with SDL_SensorOpen()."]
-    #[doc = ""]
-    #[doc = " \\param sensor The SDL_Sensor object to close"]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.9."]
+    #[doc = " Get the current state of an opened sensor with the timestamp of the last\n update.\n\n The number of values and interpretation of the data is sensor dependent.\n\n \\param sensor The SDL_Sensor object to query\n \\param timestamp A pointer filled with the timestamp in microseconds of the\n                  current sensor reading if available, or 0 if not\n \\param data A pointer filled with the current sensor state\n \\param num_values The number of values to write to data\n \\returns 0 or -1 if an error occurred.\n\n \\since This function is available since SDL 2.26.0."]
+    pub fn SDL_SensorGetDataWithTimestamp(
+        sensor: *mut SDL_Sensor,
+        timestamp: *mut Uint64,
+        data: *mut f32,
+        num_values: libc::c_int,
+    ) -> libc::c_int;
+}
+extern "C" {
+    #[doc = " Close a sensor previously opened with SDL_SensorOpen().\n\n \\param sensor The SDL_Sensor object to close\n\n \\since This function is available since SDL 2.0.9."]
     pub fn SDL_SensorClose(sensor: *mut SDL_Sensor);
 }
 extern "C" {
-    #[doc = " Update the current state of the open sensors."]
-    #[doc = ""]
-    #[doc = " This is called automatically by the event loop if sensor events are"]
-    #[doc = " enabled."]
-    #[doc = ""]
-    #[doc = " This needs to be called from the thread that initialized the sensor"]
-    #[doc = " subsystem."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.9."]
+    #[doc = " Update the current state of the open sensors.\n\n This is called automatically by the event loop if sensor events are\n enabled.\n\n This needs to be called from the thread that initialized the sensor\n subsystem.\n\n \\since This function is available since SDL 2.0.9."]
     pub fn SDL_SensorUpdate();
 }
 #[doc = " The gamecontroller structure used to identify an SDL game controller"]
@@ -14389,7 +8932,7 @@ pub struct _SDL_GameController {
 }
 pub type SDL_GameController = _SDL_GameController;
 #[repr(u32)]
-#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
+#[derive(Copy, Clone, Hash, PartialEq, Eq)]
 pub enum SDL_GameControllerType {
     SDL_CONTROLLER_TYPE_UNKNOWN = 0,
     SDL_CONTROLLER_TYPE_XBOX360 = 1,
@@ -14401,9 +8944,13 @@ pub enum SDL_GameControllerType {
     SDL_CONTROLLER_TYPE_PS5 = 7,
     SDL_CONTROLLER_TYPE_AMAZON_LUNA = 8,
     SDL_CONTROLLER_TYPE_GOOGLE_STADIA = 9,
+    SDL_CONTROLLER_TYPE_NVIDIA_SHIELD = 10,
+    SDL_CONTROLLER_TYPE_NINTENDO_SWITCH_JOYCON_LEFT = 11,
+    SDL_CONTROLLER_TYPE_NINTENDO_SWITCH_JOYCON_RIGHT = 12,
+    SDL_CONTROLLER_TYPE_NINTENDO_SWITCH_JOYCON_PAIR = 13,
 }
 #[repr(u32)]
-#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
+#[derive(Copy, Clone, Hash, PartialEq, Eq)]
 pub enum SDL_GameControllerBindType {
     SDL_CONTROLLER_BINDTYPE_NONE = 0,
     SDL_CONTROLLER_BINDTYPE_BUTTON = 1,
@@ -14423,7 +8970,6 @@ pub union SDL_GameControllerButtonBind__bindgen_ty_1 {
     pub button: libc::c_int,
     pub axis: libc::c_int,
     pub hat: SDL_GameControllerButtonBind__bindgen_ty_1__bindgen_ty_1,
-    _bindgen_union_align: [u32; 2usize],
 }
 #[repr(C)]
 #[derive(Copy, Clone)]
@@ -14433,6 +8979,10 @@ pub struct SDL_GameControllerButtonBind__bindgen_ty_1__bindgen_ty_1 {
 }
 #[test]
 fn bindgen_test_layout_SDL_GameControllerButtonBind__bindgen_ty_1__bindgen_ty_1() {
+    const UNINIT: ::core::mem::MaybeUninit<
+        SDL_GameControllerButtonBind__bindgen_ty_1__bindgen_ty_1,
+    > = ::core::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::core::mem::size_of::<SDL_GameControllerButtonBind__bindgen_ty_1__bindgen_ty_1>(),
         8usize,
@@ -14450,10 +9000,7 @@ fn bindgen_test_layout_SDL_GameControllerButtonBind__bindgen_ty_1__bindgen_ty_1(
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::core::ptr::null::<SDL_GameControllerButtonBind__bindgen_ty_1__bindgen_ty_1>()))
-                .hat as *const _ as usize
-        },
+        unsafe { ::core::ptr::addr_of!((*ptr).hat) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -14463,10 +9010,7 @@ fn bindgen_test_layout_SDL_GameControllerButtonBind__bindgen_ty_1__bindgen_ty_1(
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::core::ptr::null::<SDL_GameControllerButtonBind__bindgen_ty_1__bindgen_ty_1>()))
-                .hat_mask as *const _ as usize
-        },
+        unsafe { ::core::ptr::addr_of!((*ptr).hat_mask) as usize - ptr as usize },
         4usize,
         concat!(
             "Offset of field: ",
@@ -14478,6 +9022,9 @@ fn bindgen_test_layout_SDL_GameControllerButtonBind__bindgen_ty_1__bindgen_ty_1(
 }
 #[test]
 fn bindgen_test_layout_SDL_GameControllerButtonBind__bindgen_ty_1() {
+    const UNINIT: ::core::mem::MaybeUninit<SDL_GameControllerButtonBind__bindgen_ty_1> =
+        ::core::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::core::mem::size_of::<SDL_GameControllerButtonBind__bindgen_ty_1>(),
         8usize,
@@ -14495,10 +9042,7 @@ fn bindgen_test_layout_SDL_GameControllerButtonBind__bindgen_ty_1() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::core::ptr::null::<SDL_GameControllerButtonBind__bindgen_ty_1>())).button
-                as *const _ as usize
-        },
+        unsafe { ::core::ptr::addr_of!((*ptr).button) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -14508,10 +9052,7 @@ fn bindgen_test_layout_SDL_GameControllerButtonBind__bindgen_ty_1() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::core::ptr::null::<SDL_GameControllerButtonBind__bindgen_ty_1>())).axis as *const _
-                as usize
-        },
+        unsafe { ::core::ptr::addr_of!((*ptr).axis) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -14521,10 +9062,7 @@ fn bindgen_test_layout_SDL_GameControllerButtonBind__bindgen_ty_1() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::core::ptr::null::<SDL_GameControllerButtonBind__bindgen_ty_1>())).hat as *const _
-                as usize
-        },
+        unsafe { ::core::ptr::addr_of!((*ptr).hat) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -14536,6 +9074,9 @@ fn bindgen_test_layout_SDL_GameControllerButtonBind__bindgen_ty_1() {
 }
 #[test]
 fn bindgen_test_layout_SDL_GameControllerButtonBind() {
+    const UNINIT: ::core::mem::MaybeUninit<SDL_GameControllerButtonBind> =
+        ::core::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::core::mem::size_of::<SDL_GameControllerButtonBind>(),
         12usize,
@@ -14547,9 +9088,7 @@ fn bindgen_test_layout_SDL_GameControllerButtonBind() {
         concat!("Alignment of ", stringify!(SDL_GameControllerButtonBind))
     );
     assert_eq!(
-        unsafe {
-            &(*(::core::ptr::null::<SDL_GameControllerButtonBind>())).bindType as *const _ as usize
-        },
+        unsafe { ::core::ptr::addr_of!((*ptr).bindType) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -14559,9 +9098,7 @@ fn bindgen_test_layout_SDL_GameControllerButtonBind() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::core::ptr::null::<SDL_GameControllerButtonBind>())).value as *const _ as usize
-        },
+        unsafe { ::core::ptr::addr_of!((*ptr).value) as usize - ptr as usize },
         4usize,
         concat!(
             "Offset of field: ",
@@ -14572,404 +9109,135 @@ fn bindgen_test_layout_SDL_GameControllerButtonBind() {
     );
 }
 extern "C" {
-    #[doc = " Load a set of Game Controller mappings from a seekable SDL data stream."]
-    #[doc = ""]
-    #[doc = " You can call this function several times, if needed, to load different"]
-    #[doc = " database files."]
-    #[doc = ""]
-    #[doc = " If a new mapping is loaded for an already known controller GUID, the later"]
-    #[doc = " version will overwrite the one currently loaded."]
-    #[doc = ""]
-    #[doc = " Mappings not belonging to the current platform or with no platform field"]
-    #[doc = " specified will be ignored (i.e. mappings for Linux will be ignored in"]
-    #[doc = " Windows, etc)."]
-    #[doc = ""]
-    #[doc = " This function will load the text database entirely in memory before"]
-    #[doc = " processing it, so take this into consideration if you are in a memory"]
-    #[doc = " constrained environment."]
-    #[doc = ""]
-    #[doc = " \\param rw the data stream for the mappings to be added"]
-    #[doc = " \\param freerw non-zero to close the stream after being read"]
-    #[doc = " \\returns the number of mappings added or -1 on error; call SDL_GetError()"]
-    #[doc = "          for more information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.2."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_GameControllerAddMapping"]
-    #[doc = " \\sa SDL_GameControllerAddMappingsFromFile"]
-    #[doc = " \\sa SDL_GameControllerMappingForGUID"]
+    #[doc = " Load a set of Game Controller mappings from a seekable SDL data stream.\n\n You can call this function several times, if needed, to load different\n database files.\n\n If a new mapping is loaded for an already known controller GUID, the later\n version will overwrite the one currently loaded.\n\n Mappings not belonging to the current platform or with no platform field\n specified will be ignored (i.e. mappings for Linux will be ignored in\n Windows, etc).\n\n This function will load the text database entirely in memory before\n processing it, so take this into consideration if you are in a memory\n constrained environment.\n\n \\param rw the data stream for the mappings to be added\n \\param freerw non-zero to close the stream after being read\n \\returns the number of mappings added or -1 on error; call SDL_GetError()\n          for more information.\n\n \\since This function is available since SDL 2.0.2.\n\n \\sa SDL_GameControllerAddMapping\n \\sa SDL_GameControllerAddMappingsFromFile\n \\sa SDL_GameControllerMappingForGUID"]
     pub fn SDL_GameControllerAddMappingsFromRW(
         rw: *mut SDL_RWops,
         freerw: libc::c_int,
     ) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Add support for controllers that SDL is unaware of or to cause an existing"]
-    #[doc = " controller to have a different binding."]
-    #[doc = ""]
-    #[doc = " The mapping string has the format \"GUID,name,mapping\", where GUID is the"]
-    #[doc = " string value from SDL_JoystickGetGUIDString(), name is the human readable"]
-    #[doc = " string for the device and mappings are controller mappings to joystick"]
-    #[doc = " ones. Under Windows there is a reserved GUID of \"xinput\" that covers all"]
-    #[doc = " XInput devices. The mapping format for joystick is: {| |bX |a joystick"]
-    #[doc = " button, index X |- |hX.Y |hat X with value Y |- |aX |axis X of the joystick"]
-    #[doc = " |} Buttons can be used as a controller axes and vice versa."]
-    #[doc = ""]
-    #[doc = " This string shows an example of a valid mapping for a controller:"]
-    #[doc = ""]
-    #[doc = " ```c"]
-    #[doc = " \"341a3608000000000000504944564944,Afterglow PS3 Controller,a:b1,b:b2,y:b3,x:b0,start:b9,guide:b12,back:b8,dpup:h0.1,dpleft:h0.8,dpdown:h0.4,dpright:h0.2,leftshoulder:b4,rightshoulder:b5,leftstick:b10,rightstick:b11,leftx:a0,lefty:a1,rightx:a2,righty:a3,lefttrigger:b6,righttrigger:b7\""]
-    #[doc = " ```"]
-    #[doc = ""]
-    #[doc = " \\param mappingString the mapping string"]
-    #[doc = " \\returns 1 if a new mapping is added, 0 if an existing mapping is updated,"]
-    #[doc = "          -1 on error; call SDL_GetError() for more information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_GameControllerMapping"]
-    #[doc = " \\sa SDL_GameControllerMappingForGUID"]
+    #[doc = " Add support for controllers that SDL is unaware of or to cause an existing\n controller to have a different binding.\n\n The mapping string has the format \"GUID,name,mapping\", where GUID is the\n string value from SDL_JoystickGetGUIDString(), name is the human readable\n string for the device and mappings are controller mappings to joystick\n ones. Under Windows there is a reserved GUID of \"xinput\" that covers all\n XInput devices. The mapping format for joystick is: {| |bX |a joystick\n button, index X |- |hX.Y |hat X with value Y |- |aX |axis X of the joystick\n |} Buttons can be used as a controller axes and vice versa.\n\n This string shows an example of a valid mapping for a controller:\n\n ```c\n \"341a3608000000000000504944564944,Afterglow PS3 Controller,a:b1,b:b2,y:b3,x:b0,start:b9,guide:b12,back:b8,dpup:h0.1,dpleft:h0.8,dpdown:h0.4,dpright:h0.2,leftshoulder:b4,rightshoulder:b5,leftstick:b10,rightstick:b11,leftx:a0,lefty:a1,rightx:a2,righty:a3,lefttrigger:b6,righttrigger:b7\"\n ```\n\n \\param mappingString the mapping string\n \\returns 1 if a new mapping is added, 0 if an existing mapping is updated,\n          -1 on error; call SDL_GetError() for more information.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_GameControllerMapping\n \\sa SDL_GameControllerMappingForGUID"]
     pub fn SDL_GameControllerAddMapping(mappingString: *const libc::c_char) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Get the number of mappings installed."]
-    #[doc = ""]
-    #[doc = " \\returns the number of mappings."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.6."]
+    #[doc = " Get the number of mappings installed.\n\n \\returns the number of mappings.\n\n \\since This function is available since SDL 2.0.6."]
     pub fn SDL_GameControllerNumMappings() -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Get the mapping at a particular index."]
-    #[doc = ""]
-    #[doc = " \\returns the mapping string. Must be freed with SDL_free(). Returns NULL if"]
-    #[doc = "          the index is out of range."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.6."]
+    #[doc = " Get the mapping at a particular index.\n\n \\returns the mapping string. Must be freed with SDL_free(). Returns NULL if\n          the index is out of range.\n\n \\since This function is available since SDL 2.0.6."]
     pub fn SDL_GameControllerMappingForIndex(mapping_index: libc::c_int) -> *mut libc::c_char;
 }
 extern "C" {
-    #[doc = " Get the game controller mapping string for a given GUID."]
-    #[doc = ""]
-    #[doc = " The returned string must be freed with SDL_free()."]
-    #[doc = ""]
-    #[doc = " \\param guid a structure containing the GUID for which a mapping is desired"]
-    #[doc = " \\returns a mapping string or NULL on error; call SDL_GetError() for more"]
-    #[doc = "          information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_JoystickGetDeviceGUID"]
-    #[doc = " \\sa SDL_JoystickGetGUID"]
+    #[doc = " Get the game controller mapping string for a given GUID.\n\n The returned string must be freed with SDL_free().\n\n \\param guid a structure containing the GUID for which a mapping is desired\n \\returns a mapping string or NULL on error; call SDL_GetError() for more\n          information.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_JoystickGetDeviceGUID\n \\sa SDL_JoystickGetGUID"]
     pub fn SDL_GameControllerMappingForGUID(guid: SDL_JoystickGUID) -> *mut libc::c_char;
 }
 extern "C" {
-    #[doc = " Get the current mapping of a Game Controller."]
-    #[doc = ""]
-    #[doc = " The returned string must be freed with SDL_free()."]
-    #[doc = ""]
-    #[doc = " Details about mappings are discussed with SDL_GameControllerAddMapping()."]
-    #[doc = ""]
-    #[doc = " \\param gamecontroller the game controller you want to get the current"]
-    #[doc = "                       mapping for"]
-    #[doc = " \\returns a string that has the controller's mapping or NULL if no mapping"]
-    #[doc = "          is available; call SDL_GetError() for more information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_GameControllerAddMapping"]
-    #[doc = " \\sa SDL_GameControllerMappingForGUID"]
+    #[doc = " Get the current mapping of a Game Controller.\n\n The returned string must be freed with SDL_free().\n\n Details about mappings are discussed with SDL_GameControllerAddMapping().\n\n \\param gamecontroller the game controller you want to get the current\n                       mapping for\n \\returns a string that has the controller's mapping or NULL if no mapping\n          is available; call SDL_GetError() for more information.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_GameControllerAddMapping\n \\sa SDL_GameControllerMappingForGUID"]
     pub fn SDL_GameControllerMapping(gamecontroller: *mut SDL_GameController) -> *mut libc::c_char;
 }
 extern "C" {
-    #[doc = " Check if the given joystick is supported by the game controller interface."]
-    #[doc = ""]
-    #[doc = " `joystick_index` is the same as the `device_index` passed to"]
-    #[doc = " SDL_JoystickOpen()."]
-    #[doc = ""]
-    #[doc = " \\param joystick_index the device_index of a device, up to"]
-    #[doc = "                       SDL_NumJoysticks()"]
-    #[doc = " \\returns SDL_TRUE if the given joystick is supported by the game controller"]
-    #[doc = "          interface, SDL_FALSE if it isn't or it's an invalid index."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_GameControllerNameForIndex"]
-    #[doc = " \\sa SDL_GameControllerOpen"]
+    #[doc = " Check if the given joystick is supported by the game controller interface.\n\n `joystick_index` is the same as the `device_index` passed to\n SDL_JoystickOpen().\n\n \\param joystick_index the device_index of a device, up to\n                       SDL_NumJoysticks()\n \\returns SDL_TRUE if the given joystick is supported by the game controller\n          interface, SDL_FALSE if it isn't or it's an invalid index.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_GameControllerNameForIndex\n \\sa SDL_GameControllerOpen"]
     pub fn SDL_IsGameController(joystick_index: libc::c_int) -> SDL_bool;
 }
 extern "C" {
-    #[doc = " Get the implementation dependent name for the game controller."]
-    #[doc = ""]
-    #[doc = " This function can be called before any controllers are opened."]
-    #[doc = ""]
-    #[doc = " `joystick_index` is the same as the `device_index` passed to"]
-    #[doc = " SDL_JoystickOpen()."]
-    #[doc = ""]
-    #[doc = " \\param joystick_index the device_index of a device, from zero to"]
-    #[doc = "                       SDL_NumJoysticks()-1"]
-    #[doc = " \\returns the implementation-dependent name for the game controller, or NULL"]
-    #[doc = "          if there is no name or the index is invalid."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_GameControllerName"]
-    #[doc = " \\sa SDL_GameControllerOpen"]
-    #[doc = " \\sa SDL_IsGameController"]
+    #[doc = " Get the implementation dependent name for the game controller.\n\n This function can be called before any controllers are opened.\n\n `joystick_index` is the same as the `device_index` passed to\n SDL_JoystickOpen().\n\n \\param joystick_index the device_index of a device, from zero to\n                       SDL_NumJoysticks()-1\n \\returns the implementation-dependent name for the game controller, or NULL\n          if there is no name or the index is invalid.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_GameControllerName\n \\sa SDL_GameControllerOpen\n \\sa SDL_IsGameController"]
     pub fn SDL_GameControllerNameForIndex(joystick_index: libc::c_int) -> *const libc::c_char;
 }
 extern "C" {
-    #[doc = " Get the type of a game controller."]
-    #[doc = ""]
-    #[doc = " This can be called before any controllers are opened."]
-    #[doc = ""]
-    #[doc = " \\param joystick_index the device_index of a device, from zero to"]
-    #[doc = "                       SDL_NumJoysticks()-1"]
-    #[doc = " \\returns the controller type."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.12."]
+    #[doc = " Get the implementation dependent path for the game controller.\n\n This function can be called before any controllers are opened.\n\n `joystick_index` is the same as the `device_index` passed to\n SDL_JoystickOpen().\n\n \\param joystick_index the device_index of a device, from zero to\n                       SDL_NumJoysticks()-1\n \\returns the implementation-dependent path for the game controller, or NULL\n          if there is no path or the index is invalid.\n\n \\since This function is available since SDL 2.24.0.\n\n \\sa SDL_GameControllerPath"]
+    pub fn SDL_GameControllerPathForIndex(joystick_index: libc::c_int) -> *const libc::c_char;
+}
+extern "C" {
+    #[doc = " Get the type of a game controller.\n\n This can be called before any controllers are opened.\n\n \\param joystick_index the device_index of a device, from zero to\n                       SDL_NumJoysticks()-1\n \\returns the controller type.\n\n \\since This function is available since SDL 2.0.12."]
     pub fn SDL_GameControllerTypeForIndex(joystick_index: libc::c_int) -> SDL_GameControllerType;
 }
 extern "C" {
-    #[doc = " Get the mapping of a game controller."]
-    #[doc = ""]
-    #[doc = " This can be called before any controllers are opened."]
-    #[doc = ""]
-    #[doc = " \\param joystick_index the device_index of a device, from zero to"]
-    #[doc = "                       SDL_NumJoysticks()-1"]
-    #[doc = " \\returns the mapping string. Must be freed with SDL_free(). Returns NULL if"]
-    #[doc = "          no mapping is available."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.9."]
+    #[doc = " Get the mapping of a game controller.\n\n This can be called before any controllers are opened.\n\n \\param joystick_index the device_index of a device, from zero to\n                       SDL_NumJoysticks()-1\n \\returns the mapping string. Must be freed with SDL_free(). Returns NULL if\n          no mapping is available.\n\n \\since This function is available since SDL 2.0.9."]
     pub fn SDL_GameControllerMappingForDeviceIndex(
         joystick_index: libc::c_int,
     ) -> *mut libc::c_char;
 }
 extern "C" {
-    #[doc = " Open a game controller for use."]
-    #[doc = ""]
-    #[doc = " `joystick_index` is the same as the `device_index` passed to"]
-    #[doc = " SDL_JoystickOpen()."]
-    #[doc = ""]
-    #[doc = " The index passed as an argument refers to the N'th game controller on the"]
-    #[doc = " system. This index is not the value which will identify this controller in"]
-    #[doc = " future controller events. The joystick's instance id (SDL_JoystickID) will"]
-    #[doc = " be used there instead."]
-    #[doc = ""]
-    #[doc = " \\param joystick_index the device_index of a device, up to"]
-    #[doc = "                       SDL_NumJoysticks()"]
-    #[doc = " \\returns a gamecontroller identifier or NULL if an error occurred; call"]
-    #[doc = "          SDL_GetError() for more information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_GameControllerClose"]
-    #[doc = " \\sa SDL_GameControllerNameForIndex"]
-    #[doc = " \\sa SDL_IsGameController"]
+    #[doc = " Open a game controller for use.\n\n `joystick_index` is the same as the `device_index` passed to\n SDL_JoystickOpen().\n\n The index passed as an argument refers to the N'th game controller on the\n system. This index is not the value which will identify this controller in\n future controller events. The joystick's instance id (SDL_JoystickID) will\n be used there instead.\n\n \\param joystick_index the device_index of a device, up to\n                       SDL_NumJoysticks()\n \\returns a gamecontroller identifier or NULL if an error occurred; call\n          SDL_GetError() for more information.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_GameControllerClose\n \\sa SDL_GameControllerNameForIndex\n \\sa SDL_IsGameController"]
     pub fn SDL_GameControllerOpen(joystick_index: libc::c_int) -> *mut SDL_GameController;
 }
 extern "C" {
-    #[doc = " Get the SDL_GameController associated with an instance id."]
-    #[doc = ""]
-    #[doc = " \\param joyid the instance id to get the SDL_GameController for"]
-    #[doc = " \\returns an SDL_GameController on success or NULL on failure; call"]
-    #[doc = "          SDL_GetError() for more information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.4."]
+    #[doc = " Get the SDL_GameController associated with an instance id.\n\n \\param joyid the instance id to get the SDL_GameController for\n \\returns an SDL_GameController on success or NULL on failure; call\n          SDL_GetError() for more information.\n\n \\since This function is available since SDL 2.0.4."]
     pub fn SDL_GameControllerFromInstanceID(joyid: SDL_JoystickID) -> *mut SDL_GameController;
 }
 extern "C" {
-    #[doc = " Get the SDL_GameController associated with a player index."]
-    #[doc = ""]
-    #[doc = " Please note that the player index is _not_ the device index, nor is it the"]
-    #[doc = " instance id!"]
-    #[doc = ""]
-    #[doc = " \\param player_index the player index, which is not the device index or the"]
-    #[doc = "                     instance id!"]
-    #[doc = " \\returns the SDL_GameController associated with a player index."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.12."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_GameControllerGetPlayerIndex"]
-    #[doc = " \\sa SDL_GameControllerSetPlayerIndex"]
+    #[doc = " Get the SDL_GameController associated with a player index.\n\n Please note that the player index is _not_ the device index, nor is it the\n instance id!\n\n \\param player_index the player index, which is not the device index or the\n                     instance id!\n \\returns the SDL_GameController associated with a player index.\n\n \\since This function is available since SDL 2.0.12.\n\n \\sa SDL_GameControllerGetPlayerIndex\n \\sa SDL_GameControllerSetPlayerIndex"]
     pub fn SDL_GameControllerFromPlayerIndex(player_index: libc::c_int) -> *mut SDL_GameController;
 }
 extern "C" {
-    #[doc = " Get the implementation-dependent name for an opened game controller."]
-    #[doc = ""]
-    #[doc = " This is the same name as returned by SDL_GameControllerNameForIndex(), but"]
-    #[doc = " it takes a controller identifier instead of the (unstable) device index."]
-    #[doc = ""]
-    #[doc = " \\param gamecontroller a game controller identifier previously returned by"]
-    #[doc = "                       SDL_GameControllerOpen()"]
-    #[doc = " \\returns the implementation dependent name for the game controller, or NULL"]
-    #[doc = "          if there is no name or the identifier passed is invalid."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_GameControllerNameForIndex"]
-    #[doc = " \\sa SDL_GameControllerOpen"]
+    #[doc = " Get the implementation-dependent name for an opened game controller.\n\n This is the same name as returned by SDL_GameControllerNameForIndex(), but\n it takes a controller identifier instead of the (unstable) device index.\n\n \\param gamecontroller a game controller identifier previously returned by\n                       SDL_GameControllerOpen()\n \\returns the implementation dependent name for the game controller, or NULL\n          if there is no name or the identifier passed is invalid.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_GameControllerNameForIndex\n \\sa SDL_GameControllerOpen"]
     pub fn SDL_GameControllerName(gamecontroller: *mut SDL_GameController) -> *const libc::c_char;
 }
 extern "C" {
-    #[doc = " Get the type of this currently opened controller"]
-    #[doc = ""]
-    #[doc = " This is the same name as returned by SDL_GameControllerTypeForIndex(), but"]
-    #[doc = " it takes a controller identifier instead of the (unstable) device index."]
-    #[doc = ""]
-    #[doc = " \\param gamecontroller the game controller object to query."]
-    #[doc = " \\returns the controller type."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.12."]
+    #[doc = " Get the implementation-dependent path for an opened game controller.\n\n This is the same path as returned by SDL_GameControllerNameForIndex(), but\n it takes a controller identifier instead of the (unstable) device index.\n\n \\param gamecontroller a game controller identifier previously returned by\n                       SDL_GameControllerOpen()\n \\returns the implementation dependent path for the game controller, or NULL\n          if there is no path or the identifier passed is invalid.\n\n \\since This function is available since SDL 2.24.0.\n\n \\sa SDL_GameControllerPathForIndex"]
+    pub fn SDL_GameControllerPath(gamecontroller: *mut SDL_GameController) -> *const libc::c_char;
+}
+extern "C" {
+    #[doc = " Get the type of this currently opened controller\n\n This is the same name as returned by SDL_GameControllerTypeForIndex(), but\n it takes a controller identifier instead of the (unstable) device index.\n\n \\param gamecontroller the game controller object to query.\n \\returns the controller type.\n\n \\since This function is available since SDL 2.0.12."]
     pub fn SDL_GameControllerGetType(
         gamecontroller: *mut SDL_GameController,
     ) -> SDL_GameControllerType;
 }
 extern "C" {
-    #[doc = " Get the player index of an opened game controller."]
-    #[doc = ""]
-    #[doc = " For XInput controllers this returns the XInput user index."]
-    #[doc = ""]
-    #[doc = " \\param gamecontroller the game controller object to query."]
-    #[doc = " \\returns the player index for controller, or -1 if it's not available."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.9."]
+    #[doc = " Get the player index of an opened game controller.\n\n For XInput controllers this returns the XInput user index.\n\n \\param gamecontroller the game controller object to query.\n \\returns the player index for controller, or -1 if it's not available.\n\n \\since This function is available since SDL 2.0.9."]
     pub fn SDL_GameControllerGetPlayerIndex(gamecontroller: *mut SDL_GameController)
         -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Set the player index of an opened game controller."]
-    #[doc = ""]
-    #[doc = " \\param gamecontroller the game controller object to adjust."]
-    #[doc = " \\param player_index Player index to assign to this controller."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.12."]
+    #[doc = " Set the player index of an opened game controller.\n\n \\param gamecontroller the game controller object to adjust.\n \\param player_index Player index to assign to this controller, or -1 to\n                     clear the player index and turn off player LEDs.\n\n \\since This function is available since SDL 2.0.12."]
     pub fn SDL_GameControllerSetPlayerIndex(
         gamecontroller: *mut SDL_GameController,
         player_index: libc::c_int,
     );
 }
 extern "C" {
-    #[doc = " Get the USB vendor ID of an opened controller, if available."]
-    #[doc = ""]
-    #[doc = " If the vendor ID isn't available this function returns 0."]
-    #[doc = ""]
-    #[doc = " \\param gamecontroller the game controller object to query."]
-    #[doc = " \\return the USB vendor ID, or zero if unavailable."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.6."]
+    #[doc = " Get the USB vendor ID of an opened controller, if available.\n\n If the vendor ID isn't available this function returns 0.\n\n \\param gamecontroller the game controller object to query.\n \\return the USB vendor ID, or zero if unavailable.\n\n \\since This function is available since SDL 2.0.6."]
     pub fn SDL_GameControllerGetVendor(gamecontroller: *mut SDL_GameController) -> Uint16;
 }
 extern "C" {
-    #[doc = " Get the USB product ID of an opened controller, if available."]
-    #[doc = ""]
-    #[doc = " If the product ID isn't available this function returns 0."]
-    #[doc = ""]
-    #[doc = " \\param gamecontroller the game controller object to query."]
-    #[doc = " \\return the USB product ID, or zero if unavailable."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.6."]
+    #[doc = " Get the USB product ID of an opened controller, if available.\n\n If the product ID isn't available this function returns 0.\n\n \\param gamecontroller the game controller object to query.\n \\return the USB product ID, or zero if unavailable.\n\n \\since This function is available since SDL 2.0.6."]
     pub fn SDL_GameControllerGetProduct(gamecontroller: *mut SDL_GameController) -> Uint16;
 }
 extern "C" {
-    #[doc = " Get the product version of an opened controller, if available."]
-    #[doc = ""]
-    #[doc = " If the product version isn't available this function returns 0."]
-    #[doc = ""]
-    #[doc = " \\param gamecontroller the game controller object to query."]
-    #[doc = " \\return the USB product version, or zero if unavailable."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.6."]
+    #[doc = " Get the product version of an opened controller, if available.\n\n If the product version isn't available this function returns 0.\n\n \\param gamecontroller the game controller object to query.\n \\return the USB product version, or zero if unavailable.\n\n \\since This function is available since SDL 2.0.6."]
     pub fn SDL_GameControllerGetProductVersion(gamecontroller: *mut SDL_GameController) -> Uint16;
 }
 extern "C" {
-    #[doc = " Get the serial number of an opened controller, if available."]
-    #[doc = ""]
-    #[doc = " Returns the serial number of the controller, or NULL if it is not"]
-    #[doc = " available."]
-    #[doc = ""]
-    #[doc = " \\param gamecontroller the game controller object to query."]
-    #[doc = " \\return the serial number, or NULL if unavailable."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.14."]
+    #[doc = " Get the firmware version of an opened controller, if available.\n\n If the firmware version isn't available this function returns 0.\n\n \\param gamecontroller the game controller object to query.\n \\return the controller firmware version, or zero if unavailable.\n\n \\since This function is available since SDL 2.24.0."]
+    pub fn SDL_GameControllerGetFirmwareVersion(gamecontroller: *mut SDL_GameController) -> Uint16;
+}
+extern "C" {
+    #[doc = " Get the serial number of an opened controller, if available.\n\n Returns the serial number of the controller, or NULL if it is not\n available.\n\n \\param gamecontroller the game controller object to query.\n \\return the serial number, or NULL if unavailable.\n\n \\since This function is available since SDL 2.0.14."]
     pub fn SDL_GameControllerGetSerial(
         gamecontroller: *mut SDL_GameController,
     ) -> *const libc::c_char;
 }
 extern "C" {
-    #[doc = " Check if a controller has been opened and is currently connected."]
-    #[doc = ""]
-    #[doc = " \\param gamecontroller a game controller identifier previously returned by"]
-    #[doc = "                       SDL_GameControllerOpen()"]
-    #[doc = " \\returns SDL_TRUE if the controller has been opened and is currently"]
-    #[doc = "          connected, or SDL_FALSE if not."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_GameControllerClose"]
-    #[doc = " \\sa SDL_GameControllerOpen"]
+    #[doc = " Check if a controller has been opened and is currently connected.\n\n \\param gamecontroller a game controller identifier previously returned by\n                       SDL_GameControllerOpen()\n \\returns SDL_TRUE if the controller has been opened and is currently\n          connected, or SDL_FALSE if not.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_GameControllerClose\n \\sa SDL_GameControllerOpen"]
     pub fn SDL_GameControllerGetAttached(gamecontroller: *mut SDL_GameController) -> SDL_bool;
 }
 extern "C" {
-    #[doc = " Get the Joystick ID from a Game Controller."]
-    #[doc = ""]
-    #[doc = " This function will give you a SDL_Joystick object, which allows you to use"]
-    #[doc = " the SDL_Joystick functions with a SDL_GameController object. This would be"]
-    #[doc = " useful for getting a joystick's position at any given time, even if it"]
-    #[doc = " hasn't moved (moving it would produce an event, which would have the axis'"]
-    #[doc = " value)."]
-    #[doc = ""]
-    #[doc = " The pointer returned is owned by the SDL_GameController. You should not"]
-    #[doc = " call SDL_JoystickClose() on it, for example, since doing so will likely"]
-    #[doc = " cause SDL to crash."]
-    #[doc = ""]
-    #[doc = " \\param gamecontroller the game controller object that you want to get a"]
-    #[doc = "                       joystick from"]
-    #[doc = " \\returns a SDL_Joystick object; call SDL_GetError() for more information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
+    #[doc = " Get the Joystick ID from a Game Controller.\n\n This function will give you a SDL_Joystick object, which allows you to use\n the SDL_Joystick functions with a SDL_GameController object. This would be\n useful for getting a joystick's position at any given time, even if it\n hasn't moved (moving it would produce an event, which would have the axis'\n value).\n\n The pointer returned is owned by the SDL_GameController. You should not\n call SDL_JoystickClose() on it, for example, since doing so will likely\n cause SDL to crash.\n\n \\param gamecontroller the game controller object that you want to get a\n                       joystick from\n \\returns a SDL_Joystick object; call SDL_GetError() for more information.\n\n \\since This function is available since SDL 2.0.0."]
     pub fn SDL_GameControllerGetJoystick(
         gamecontroller: *mut SDL_GameController,
     ) -> *mut SDL_Joystick;
 }
 extern "C" {
-    #[doc = " Query or change current state of Game Controller events."]
-    #[doc = ""]
-    #[doc = " If controller events are disabled, you must call SDL_GameControllerUpdate()"]
-    #[doc = " yourself and check the state of the controller when you want controller"]
-    #[doc = " information."]
-    #[doc = ""]
-    #[doc = " Any number can be passed to SDL_GameControllerEventState(), but only -1, 0,"]
-    #[doc = " and 1 will have any effect. Other numbers will just be returned."]
-    #[doc = ""]
-    #[doc = " \\param state can be one of `SDL_QUERY`, `SDL_IGNORE`, or `SDL_ENABLE`"]
-    #[doc = " \\returns the same value passed to the function, with exception to -1"]
-    #[doc = "          (SDL_QUERY), which will return the current state."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_JoystickEventState"]
+    #[doc = " Query or change current state of Game Controller events.\n\n If controller events are disabled, you must call SDL_GameControllerUpdate()\n yourself and check the state of the controller when you want controller\n information.\n\n Any number can be passed to SDL_GameControllerEventState(), but only -1, 0,\n and 1 will have any effect. Other numbers will just be returned.\n\n \\param state can be one of `SDL_QUERY`, `SDL_IGNORE`, or `SDL_ENABLE`\n \\returns the same value passed to the function, with exception to -1\n          (SDL_QUERY), which will return the current state.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_JoystickEventState"]
     pub fn SDL_GameControllerEventState(state: libc::c_int) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Manually pump game controller updates if not using the loop."]
-    #[doc = ""]
-    #[doc = " This function is called automatically by the event loop if events are"]
-    #[doc = " enabled. Under such circumstances, it will not be necessary to call this"]
-    #[doc = " function."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
+    #[doc = " Manually pump game controller updates if not using the loop.\n\n This function is called automatically by the event loop if events are\n enabled. Under such circumstances, it will not be necessary to call this\n function.\n\n \\since This function is available since SDL 2.0.0."]
     pub fn SDL_GameControllerUpdate();
 }
 #[repr(i32)]
-#[doc = "  The list of axes available from a controller"]
-#[doc = ""]
-#[doc = "  Thumbstick axis values range from SDL_JOYSTICK_AXIS_MIN to SDL_JOYSTICK_AXIS_MAX,"]
-#[doc = "  and are centered within ~8000 of zero, though advanced UI will allow users to set"]
-#[doc = "  or autodetect the dead zone, which varies between controllers."]
-#[doc = ""]
-#[doc = "  Trigger axis values range from 0 to SDL_JOYSTICK_AXIS_MAX."]
-#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
+#[doc = "  The list of axes available from a controller\n\n  Thumbstick axis values range from SDL_JOYSTICK_AXIS_MIN to SDL_JOYSTICK_AXIS_MAX,\n  and are centered within ~8000 of zero, though advanced UI will allow users to set\n  or autodetect the dead zone, which varies between controllers.\n\n  Trigger axis values range from 0 to SDL_JOYSTICK_AXIS_MAX."]
+#[derive(Copy, Clone, Hash, PartialEq, Eq)]
 pub enum SDL_GameControllerAxis {
     SDL_CONTROLLER_AXIS_INVALID = -1,
     SDL_CONTROLLER_AXIS_LEFTX = 0,
@@ -14981,90 +9249,30 @@ pub enum SDL_GameControllerAxis {
     SDL_CONTROLLER_AXIS_MAX = 6,
 }
 extern "C" {
-    #[doc = " Convert a string into SDL_GameControllerAxis enum."]
-    #[doc = ""]
-    #[doc = " This function is called internally to translate SDL_GameController mapping"]
-    #[doc = " strings for the underlying joystick device into the consistent"]
-    #[doc = " SDL_GameController mapping. You do not normally need to call this function"]
-    #[doc = " unless you are parsing SDL_GameController mappings in your own code."]
-    #[doc = ""]
-    #[doc = " Note specially that \"righttrigger\" and \"lefttrigger\" map to"]
-    #[doc = " `SDL_CONTROLLER_AXIS_TRIGGERRIGHT` and `SDL_CONTROLLER_AXIS_TRIGGERLEFT`,"]
-    #[doc = " respectively."]
-    #[doc = ""]
-    #[doc = " \\param str string representing a SDL_GameController axis"]
-    #[doc = " \\returns the SDL_GameControllerAxis enum corresponding to the input string,"]
-    #[doc = "          or `SDL_CONTROLLER_AXIS_INVALID` if no match was found."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_GameControllerGetStringForAxis"]
-    pub fn SDL_GameControllerGetAxisFromString(str: *const libc::c_char) -> SDL_GameControllerAxis;
-}
-extern "C" {
-    #[doc = " Convert from an SDL_GameControllerAxis enum to a string."]
-    #[doc = ""]
-    #[doc = " The caller should not SDL_free() the returned string."]
-    #[doc = ""]
-    #[doc = " \\param axis an enum value for a given SDL_GameControllerAxis"]
-    #[doc = " \\returns a string for the given axis, or NULL if an invalid axis is"]
-    #[doc = "          specified. The string returned is of the format used by"]
-    #[doc = "          SDL_GameController mapping strings."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_GameControllerGetAxisFromString"]
+    #[doc = " Convert a string into SDL_GameControllerAxis enum.\n\n This function is called internally to translate SDL_GameController mapping\n strings for the underlying joystick device into the consistent\n SDL_GameController mapping. You do not normally need to call this function\n unless you are parsing SDL_GameController mappings in your own code.\n\n Note specially that \"righttrigger\" and \"lefttrigger\" map to\n `SDL_CONTROLLER_AXIS_TRIGGERRIGHT` and `SDL_CONTROLLER_AXIS_TRIGGERLEFT`,\n respectively.\n\n \\param str string representing a SDL_GameController axis\n \\returns the SDL_GameControllerAxis enum corresponding to the input string,\n          or `SDL_CONTROLLER_AXIS_INVALID` if no match was found.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_GameControllerGetStringForAxis"]
+    pub fn SDL_GameControllerGetAxisFromString(str_: *const libc::c_char)
+        -> SDL_GameControllerAxis;
+}
+extern "C" {
+    #[doc = " Convert from an SDL_GameControllerAxis enum to a string.\n\n The caller should not SDL_free() the returned string.\n\n \\param axis an enum value for a given SDL_GameControllerAxis\n \\returns a string for the given axis, or NULL if an invalid axis is\n          specified. The string returned is of the format used by\n          SDL_GameController mapping strings.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_GameControllerGetAxisFromString"]
     pub fn SDL_GameControllerGetStringForAxis(axis: SDL_GameControllerAxis) -> *const libc::c_char;
 }
 extern "C" {
-    #[doc = " Get the SDL joystick layer binding for a controller axis mapping."]
-    #[doc = ""]
-    #[doc = " \\param gamecontroller a game controller"]
-    #[doc = " \\param axis an axis enum value (one of the SDL_GameControllerAxis values)"]
-    #[doc = " \\returns a SDL_GameControllerButtonBind describing the bind. On failure"]
-    #[doc = "          (like the given Controller axis doesn't exist on the device), its"]
-    #[doc = "          `.bindType` will be `SDL_CONTROLLER_BINDTYPE_NONE`."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_GameControllerGetBindForButton"]
+    #[doc = " Get the SDL joystick layer binding for a controller axis mapping.\n\n \\param gamecontroller a game controller\n \\param axis an axis enum value (one of the SDL_GameControllerAxis values)\n \\returns a SDL_GameControllerButtonBind describing the bind. On failure\n          (like the given Controller axis doesn't exist on the device), its\n          `.bindType` will be `SDL_CONTROLLER_BINDTYPE_NONE`.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_GameControllerGetBindForButton"]
     pub fn SDL_GameControllerGetBindForAxis(
         gamecontroller: *mut SDL_GameController,
         axis: SDL_GameControllerAxis,
     ) -> SDL_GameControllerButtonBind;
 }
 extern "C" {
-    #[doc = " Query whether a game controller has a given axis."]
-    #[doc = ""]
-    #[doc = " This merely reports whether the controller's mapping defined this axis, as"]
-    #[doc = " that is all the information SDL has about the physical device."]
-    #[doc = ""]
-    #[doc = " \\param gamecontroller a game controller"]
-    #[doc = " \\param axis an axis enum value (an SDL_GameControllerAxis value)"]
-    #[doc = " \\returns SDL_TRUE if the controller has this axis, SDL_FALSE otherwise."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.14."]
+    #[doc = " Query whether a game controller has a given axis.\n\n This merely reports whether the controller's mapping defined this axis, as\n that is all the information SDL has about the physical device.\n\n \\param gamecontroller a game controller\n \\param axis an axis enum value (an SDL_GameControllerAxis value)\n \\returns SDL_TRUE if the controller has this axis, SDL_FALSE otherwise.\n\n \\since This function is available since SDL 2.0.14."]
     pub fn SDL_GameControllerHasAxis(
         gamecontroller: *mut SDL_GameController,
         axis: SDL_GameControllerAxis,
     ) -> SDL_bool;
 }
 extern "C" {
-    #[doc = " Get the current state of an axis control on a game controller."]
-    #[doc = ""]
-    #[doc = " The axis indices start at index 0."]
-    #[doc = ""]
-    #[doc = " The state is a value ranging from -32768 to 32767. Triggers, however, range"]
-    #[doc = " from 0 to 32767 (they never return a negative value)."]
-    #[doc = ""]
-    #[doc = " \\param gamecontroller a game controller"]
-    #[doc = " \\param axis an axis index (one of the SDL_GameControllerAxis values)"]
-    #[doc = " \\returns axis state (including 0) on success or 0 (also) on failure; call"]
-    #[doc = "          SDL_GetError() for more information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_GameControllerGetButton"]
+    #[doc = " Get the current state of an axis control on a game controller.\n\n The axis indices start at index 0.\n\n The state is a value ranging from -32768 to 32767. Triggers, however, range\n from 0 to 32767 (they never return a negative value).\n\n \\param gamecontroller a game controller\n \\param axis an axis index (one of the SDL_GameControllerAxis values)\n \\returns axis state (including 0) on success or 0 (also) on failure; call\n          SDL_GetError() for more information.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_GameControllerGetButton"]
     pub fn SDL_GameControllerGetAxis(
         gamecontroller: *mut SDL_GameController,
         axis: SDL_GameControllerAxis,
@@ -15072,7 +9280,7 @@ extern "C" {
 }
 #[repr(i32)]
 #[doc = "  The list of buttons available from a controller"]
-#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
+#[derive(Copy, Clone, Hash, PartialEq, Eq)]
 pub enum SDL_GameControllerButton {
     SDL_CONTROLLER_BUTTON_INVALID = -1,
     SDL_CONTROLLER_BUTTON_A = 0,
@@ -15099,110 +9307,53 @@ pub enum SDL_GameControllerButton {
     SDL_CONTROLLER_BUTTON_MAX = 21,
 }
 extern "C" {
-    #[doc = " Convert a string into an SDL_GameControllerButton enum."]
-    #[doc = ""]
-    #[doc = " This function is called internally to translate SDL_GameController mapping"]
-    #[doc = " strings for the underlying joystick device into the consistent"]
-    #[doc = " SDL_GameController mapping. You do not normally need to call this function"]
-    #[doc = " unless you are parsing SDL_GameController mappings in your own code."]
-    #[doc = ""]
-    #[doc = " \\param str string representing a SDL_GameController axis"]
-    #[doc = " \\returns the SDL_GameControllerButton enum corresponding to the input"]
-    #[doc = "          string, or `SDL_CONTROLLER_AXIS_INVALID` if no match was found."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
+    #[doc = " Convert a string into an SDL_GameControllerButton enum.\n\n This function is called internally to translate SDL_GameController mapping\n strings for the underlying joystick device into the consistent\n SDL_GameController mapping. You do not normally need to call this function\n unless you are parsing SDL_GameController mappings in your own code.\n\n \\param str string representing a SDL_GameController axis\n \\returns the SDL_GameControllerButton enum corresponding to the input\n          string, or `SDL_CONTROLLER_AXIS_INVALID` if no match was found.\n\n \\since This function is available since SDL 2.0.0."]
     pub fn SDL_GameControllerGetButtonFromString(
-        str: *const libc::c_char,
+        str_: *const libc::c_char,
     ) -> SDL_GameControllerButton;
 }
 extern "C" {
-    #[doc = " Convert from an SDL_GameControllerButton enum to a string."]
-    #[doc = ""]
-    #[doc = " The caller should not SDL_free() the returned string."]
-    #[doc = ""]
-    #[doc = " \\param button an enum value for a given SDL_GameControllerButton"]
-    #[doc = " \\returns a string for the given button, or NULL if an invalid axis is"]
-    #[doc = "          specified. The string returned is of the format used by"]
-    #[doc = "          SDL_GameController mapping strings."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_GameControllerGetButtonFromString"]
+    #[doc = " Convert from an SDL_GameControllerButton enum to a string.\n\n The caller should not SDL_free() the returned string.\n\n \\param button an enum value for a given SDL_GameControllerButton\n \\returns a string for the given button, or NULL if an invalid button is\n          specified. The string returned is of the format used by\n          SDL_GameController mapping strings.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_GameControllerGetButtonFromString"]
     pub fn SDL_GameControllerGetStringForButton(
         button: SDL_GameControllerButton,
     ) -> *const libc::c_char;
 }
 extern "C" {
-    #[doc = " Get the SDL joystick layer binding for a controller button mapping."]
-    #[doc = ""]
-    #[doc = " \\param gamecontroller a game controller"]
-    #[doc = " \\param button an button enum value (an SDL_GameControllerButton value)"]
-    #[doc = " \\returns a SDL_GameControllerButtonBind describing the bind. On failure"]
-    #[doc = "          (like the given Controller button doesn't exist on the device),"]
-    #[doc = "          its `.bindType` will be `SDL_CONTROLLER_BINDTYPE_NONE`."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_GameControllerGetBindForAxis"]
+    #[doc = " Get the SDL joystick layer binding for a controller button mapping.\n\n \\param gamecontroller a game controller\n \\param button an button enum value (an SDL_GameControllerButton value)\n \\returns a SDL_GameControllerButtonBind describing the bind. On failure\n          (like the given Controller button doesn't exist on the device),\n          its `.bindType` will be `SDL_CONTROLLER_BINDTYPE_NONE`.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_GameControllerGetBindForAxis"]
     pub fn SDL_GameControllerGetBindForButton(
         gamecontroller: *mut SDL_GameController,
         button: SDL_GameControllerButton,
     ) -> SDL_GameControllerButtonBind;
 }
 extern "C" {
-    #[doc = " Query whether a game controller has a given button."]
-    #[doc = ""]
-    #[doc = " This merely reports whether the controller's mapping defined this button,"]
-    #[doc = " as that is all the information SDL has about the physical device."]
-    #[doc = ""]
-    #[doc = " \\param gamecontroller a game controller"]
-    #[doc = " \\param button a button enum value (an SDL_GameControllerButton value)"]
-    #[doc = " \\returns SDL_TRUE if the controller has this button, SDL_FALSE otherwise."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.14."]
+    #[doc = " Query whether a game controller has a given button.\n\n This merely reports whether the controller's mapping defined this button,\n as that is all the information SDL has about the physical device.\n\n \\param gamecontroller a game controller\n \\param button a button enum value (an SDL_GameControllerButton value)\n \\returns SDL_TRUE if the controller has this button, SDL_FALSE otherwise.\n\n \\since This function is available since SDL 2.0.14."]
     pub fn SDL_GameControllerHasButton(
         gamecontroller: *mut SDL_GameController,
         button: SDL_GameControllerButton,
     ) -> SDL_bool;
 }
 extern "C" {
-    #[doc = " Get the current state of a button on a game controller."]
-    #[doc = ""]
-    #[doc = " \\param gamecontroller a game controller"]
-    #[doc = " \\param button a button index (one of the SDL_GameControllerButton values)"]
-    #[doc = " \\returns 1 for pressed state or 0 for not pressed state or error; call"]
-    #[doc = "          SDL_GetError() for more information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_GameControllerGetAxis"]
+    #[doc = " Get the current state of a button on a game controller.\n\n \\param gamecontroller a game controller\n \\param button a button index (one of the SDL_GameControllerButton values)\n \\returns 1 for pressed state or 0 for not pressed state or error; call\n          SDL_GetError() for more information.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_GameControllerGetAxis"]
     pub fn SDL_GameControllerGetButton(
         gamecontroller: *mut SDL_GameController,
         button: SDL_GameControllerButton,
     ) -> Uint8;
 }
 extern "C" {
-    #[doc = " Get the number of touchpads on a game controller."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.14."]
+    #[doc = " Get the number of touchpads on a game controller.\n\n \\since This function is available since SDL 2.0.14."]
     pub fn SDL_GameControllerGetNumTouchpads(
         gamecontroller: *mut SDL_GameController,
     ) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Get the number of supported simultaneous fingers on a touchpad on a game"]
-    #[doc = " controller."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.14."]
+    #[doc = " Get the number of supported simultaneous fingers on a touchpad on a game\n controller.\n\n \\since This function is available since SDL 2.0.14."]
     pub fn SDL_GameControllerGetNumTouchpadFingers(
         gamecontroller: *mut SDL_GameController,
         touchpad: libc::c_int,
     ) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Get the current state of a finger on a touchpad on a game controller."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.14."]
+    #[doc = " Get the current state of a finger on a touchpad on a game controller.\n\n \\since This function is available since SDL 2.0.14."]
     pub fn SDL_GameControllerGetTouchpadFinger(
         gamecontroller: *mut SDL_GameController,
         touchpad: libc::c_int,
@@ -15214,27 +9365,14 @@ extern "C" {
     ) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Return whether a game controller has a particular sensor."]
-    #[doc = ""]
-    #[doc = " \\param gamecontroller The controller to query"]
-    #[doc = " \\param type The type of sensor to query"]
-    #[doc = " \\returns SDL_TRUE if the sensor exists, SDL_FALSE otherwise."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.14."]
+    #[doc = " Return whether a game controller has a particular sensor.\n\n \\param gamecontroller The controller to query\n \\param type The type of sensor to query\n \\returns SDL_TRUE if the sensor exists, SDL_FALSE otherwise.\n\n \\since This function is available since SDL 2.0.14."]
     pub fn SDL_GameControllerHasSensor(
         gamecontroller: *mut SDL_GameController,
         type_: SDL_SensorType,
     ) -> SDL_bool;
 }
 extern "C" {
-    #[doc = " Set whether data reporting for a game controller sensor is enabled."]
-    #[doc = ""]
-    #[doc = " \\param gamecontroller The controller to update"]
-    #[doc = " \\param type The type of sensor to enable/disable"]
-    #[doc = " \\param enabled Whether data reporting should be enabled"]
-    #[doc = " \\returns 0 or -1 if an error occurred."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.14."]
+    #[doc = " Set whether data reporting for a game controller sensor is enabled.\n\n \\param gamecontroller The controller to update\n \\param type The type of sensor to enable/disable\n \\param enabled Whether data reporting should be enabled\n \\returns 0 or -1 if an error occurred.\n\n \\since This function is available since SDL 2.0.14."]
     pub fn SDL_GameControllerSetSensorEnabled(
         gamecontroller: *mut SDL_GameController,
         type_: SDL_SensorType,
@@ -15242,45 +9380,21 @@ extern "C" {
     ) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Query whether sensor data reporting is enabled for a game controller."]
-    #[doc = ""]
-    #[doc = " \\param gamecontroller The controller to query"]
-    #[doc = " \\param type The type of sensor to query"]
-    #[doc = " \\returns SDL_TRUE if the sensor is enabled, SDL_FALSE otherwise."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.14."]
+    #[doc = " Query whether sensor data reporting is enabled for a game controller.\n\n \\param gamecontroller The controller to query\n \\param type The type of sensor to query\n \\returns SDL_TRUE if the sensor is enabled, SDL_FALSE otherwise.\n\n \\since This function is available since SDL 2.0.14."]
     pub fn SDL_GameControllerIsSensorEnabled(
         gamecontroller: *mut SDL_GameController,
         type_: SDL_SensorType,
     ) -> SDL_bool;
 }
 extern "C" {
-    #[doc = " Get the data rate (number of events per second) of a game controller"]
-    #[doc = " sensor."]
-    #[doc = ""]
-    #[doc = " \\param gamecontroller The controller to query"]
-    #[doc = " \\param type The type of sensor to query"]
-    #[doc = " \\return the data rate, or 0.0f if the data rate is not available."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.16."]
+    #[doc = " Get the data rate (number of events per second) of a game controller\n sensor.\n\n \\param gamecontroller The controller to query\n \\param type The type of sensor to query\n \\return the data rate, or 0.0f if the data rate is not available.\n\n \\since This function is available since SDL 2.0.16."]
     pub fn SDL_GameControllerGetSensorDataRate(
         gamecontroller: *mut SDL_GameController,
         type_: SDL_SensorType,
     ) -> f32;
 }
 extern "C" {
-    #[doc = " Get the current state of a game controller sensor."]
-    #[doc = ""]
-    #[doc = " The number of values and interpretation of the data is sensor dependent."]
-    #[doc = " See SDL_sensor.h for the details for each type of sensor."]
-    #[doc = ""]
-    #[doc = " \\param gamecontroller The controller to query"]
-    #[doc = " \\param type The type of sensor to query"]
-    #[doc = " \\param data A pointer filled with the current sensor state"]
-    #[doc = " \\param num_values The number of values to write to data"]
-    #[doc = " \\return 0 or -1 if an error occurred."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.14."]
+    #[doc = " Get the current state of a game controller sensor.\n\n The number of values and interpretation of the data is sensor dependent.\n See SDL_sensor.h for the details for each type of sensor.\n\n \\param gamecontroller The controller to query\n \\param type The type of sensor to query\n \\param data A pointer filled with the current sensor state\n \\param num_values The number of values to write to data\n \\return 0 or -1 if an error occurred.\n\n \\since This function is available since SDL 2.0.14."]
     pub fn SDL_GameControllerGetSensorData(
         gamecontroller: *mut SDL_GameController,
         type_: SDL_SensorType,
@@ -15289,22 +9403,17 @@ extern "C" {
     ) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Start a rumble effect on a game controller."]
-    #[doc = ""]
-    #[doc = " Each call to this function cancels any previous rumble effect, and calling"]
-    #[doc = " it with 0 intensity stops any rumbling."]
-    #[doc = ""]
-    #[doc = " \\param gamecontroller The controller to vibrate"]
-    #[doc = " \\param low_frequency_rumble The intensity of the low frequency (left)"]
-    #[doc = "                             rumble motor, from 0 to 0xFFFF"]
-    #[doc = " \\param high_frequency_rumble The intensity of the high frequency (right)"]
-    #[doc = "                              rumble motor, from 0 to 0xFFFF"]
-    #[doc = " \\param duration_ms The duration of the rumble effect, in milliseconds"]
-    #[doc = " \\returns 0, or -1 if rumble isn't supported on this controller"]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.9."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_GameControllerHasRumble"]
+    #[doc = " Get the current state of a game controller sensor with the timestamp of the\n last update.\n\n The number of values and interpretation of the data is sensor dependent.\n See SDL_sensor.h for the details for each type of sensor.\n\n \\param gamecontroller The controller to query\n \\param type The type of sensor to query\n \\param timestamp A pointer filled with the timestamp in microseconds of the\n                  current sensor reading if available, or 0 if not\n \\param data A pointer filled with the current sensor state\n \\param num_values The number of values to write to data\n \\return 0 or -1 if an error occurred.\n\n \\since This function is available since SDL 2.26.0."]
+    pub fn SDL_GameControllerGetSensorDataWithTimestamp(
+        gamecontroller: *mut SDL_GameController,
+        type_: SDL_SensorType,
+        timestamp: *mut Uint64,
+        data: *mut f32,
+        num_values: libc::c_int,
+    ) -> libc::c_int;
+}
+extern "C" {
+    #[doc = " Start a rumble effect on a game controller.\n\n Each call to this function cancels any previous rumble effect, and calling\n it with 0 intensity stops any rumbling.\n\n \\param gamecontroller The controller to vibrate\n \\param low_frequency_rumble The intensity of the low frequency (left)\n                             rumble motor, from 0 to 0xFFFF\n \\param high_frequency_rumble The intensity of the high frequency (right)\n                              rumble motor, from 0 to 0xFFFF\n \\param duration_ms The duration of the rumble effect, in milliseconds\n \\returns 0, or -1 if rumble isn't supported on this controller\n\n \\since This function is available since SDL 2.0.9.\n\n \\sa SDL_GameControllerHasRumble"]
     pub fn SDL_GameControllerRumble(
         gamecontroller: *mut SDL_GameController,
         low_frequency_rumble: Uint16,
@@ -15313,26 +9422,7 @@ extern "C" {
     ) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Start a rumble effect in the game controller's triggers."]
-    #[doc = ""]
-    #[doc = " Each call to this function cancels any previous trigger rumble effect, and"]
-    #[doc = " calling it with 0 intensity stops any rumbling."]
-    #[doc = ""]
-    #[doc = " Note that this is rumbling of the _triggers_ and not the game controller as"]
-    #[doc = " a whole. The first controller to offer this feature was the PlayStation 5's"]
-    #[doc = " DualShock 5."]
-    #[doc = ""]
-    #[doc = " \\param gamecontroller The controller to vibrate"]
-    #[doc = " \\param left_rumble The intensity of the left trigger rumble motor, from 0"]
-    #[doc = "                    to 0xFFFF"]
-    #[doc = " \\param right_rumble The intensity of the right trigger rumble motor, from 0"]
-    #[doc = "                     to 0xFFFF"]
-    #[doc = " \\param duration_ms The duration of the rumble effect, in milliseconds"]
-    #[doc = " \\returns 0, or -1 if trigger rumble isn't supported on this controller"]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.14."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_GameControllerHasRumbleTriggers"]
+    #[doc = " Start a rumble effect in the game controller's triggers.\n\n Each call to this function cancels any previous trigger rumble effect, and\n calling it with 0 intensity stops any rumbling.\n\n Note that this is rumbling of the _triggers_ and not the game controller as\n a whole. This is currently only supported on Xbox One controllers. If you\n want the (more common) whole-controller rumble, use\n SDL_GameControllerRumble() instead.\n\n \\param gamecontroller The controller to vibrate\n \\param left_rumble The intensity of the left trigger rumble motor, from 0\n                    to 0xFFFF\n \\param right_rumble The intensity of the right trigger rumble motor, from 0\n                     to 0xFFFF\n \\param duration_ms The duration of the rumble effect, in milliseconds\n \\returns 0, or -1 if trigger rumble isn't supported on this controller\n\n \\since This function is available since SDL 2.0.14.\n\n \\sa SDL_GameControllerHasRumbleTriggers"]
     pub fn SDL_GameControllerRumbleTriggers(
         gamecontroller: *mut SDL_GameController,
         left_rumble: Uint16,
@@ -15341,50 +9431,20 @@ extern "C" {
     ) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Query whether a game controller has an LED."]
-    #[doc = ""]
-    #[doc = " \\param gamecontroller The controller to query"]
-    #[doc = " \\returns SDL_TRUE, or SDL_FALSE if this controller does not have a"]
-    #[doc = "          modifiable LED"]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.14."]
+    #[doc = " Query whether a game controller has an LED.\n\n \\param gamecontroller The controller to query\n \\returns SDL_TRUE, or SDL_FALSE if this controller does not have a\n          modifiable LED\n\n \\since This function is available since SDL 2.0.14."]
     pub fn SDL_GameControllerHasLED(gamecontroller: *mut SDL_GameController) -> SDL_bool;
 }
 extern "C" {
-    #[doc = " Query whether a game controller has rumble support."]
-    #[doc = ""]
-    #[doc = " \\param gamecontroller The controller to query"]
-    #[doc = " \\returns SDL_TRUE, or SDL_FALSE if this controller does not have rumble"]
-    #[doc = "          support"]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.18."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_GameControllerRumble"]
+    #[doc = " Query whether a game controller has rumble support.\n\n \\param gamecontroller The controller to query\n \\returns SDL_TRUE, or SDL_FALSE if this controller does not have rumble\n          support\n\n \\since This function is available since SDL 2.0.18.\n\n \\sa SDL_GameControllerRumble"]
     pub fn SDL_GameControllerHasRumble(gamecontroller: *mut SDL_GameController) -> SDL_bool;
 }
 extern "C" {
-    #[doc = " Query whether a game controller has rumble support on triggers."]
-    #[doc = ""]
-    #[doc = " \\param gamecontroller The controller to query"]
-    #[doc = " \\returns SDL_TRUE, or SDL_FALSE if this controller does not have trigger"]
-    #[doc = "          rumble support"]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.18."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_GameControllerRumbleTriggers"]
+    #[doc = " Query whether a game controller has rumble support on triggers.\n\n \\param gamecontroller The controller to query\n \\returns SDL_TRUE, or SDL_FALSE if this controller does not have trigger\n          rumble support\n\n \\since This function is available since SDL 2.0.18.\n\n \\sa SDL_GameControllerRumbleTriggers"]
     pub fn SDL_GameControllerHasRumbleTriggers(gamecontroller: *mut SDL_GameController)
         -> SDL_bool;
 }
 extern "C" {
-    #[doc = " Update a game controller's LED color."]
-    #[doc = ""]
-    #[doc = " \\param gamecontroller The controller to update"]
-    #[doc = " \\param red The intensity of the red LED"]
-    #[doc = " \\param green The intensity of the green LED"]
-    #[doc = " \\param blue The intensity of the blue LED"]
-    #[doc = " \\returns 0, or -1 if this controller does not have a modifiable LED"]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.14."]
+    #[doc = " Update a game controller's LED color.\n\n \\param gamecontroller The controller to update\n \\param red The intensity of the red LED\n \\param green The intensity of the green LED\n \\param blue The intensity of the blue LED\n \\returns 0, or -1 if this controller does not have a modifiable LED\n\n \\since This function is available since SDL 2.0.14."]
     pub fn SDL_GameControllerSetLED(
         gamecontroller: *mut SDL_GameController,
         red: Uint8,
@@ -15393,15 +9453,7 @@ extern "C" {
     ) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Send a controller specific effect packet"]
-    #[doc = ""]
-    #[doc = " \\param gamecontroller The controller to affect"]
-    #[doc = " \\param data The data to send to the controller"]
-    #[doc = " \\param size The size of the data to send to the controller"]
-    #[doc = " \\returns 0, or -1 if this controller or driver doesn't support effect"]
-    #[doc = "          packets"]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.16."]
+    #[doc = " Send a controller specific effect packet\n\n \\param gamecontroller The controller to affect\n \\param data The data to send to the controller\n \\param size The size of the data to send to the controller\n \\returns 0, or -1 if this controller or driver doesn't support effect\n          packets\n\n \\since This function is available since SDL 2.0.16."]
     pub fn SDL_GameControllerSendEffect(
         gamecontroller: *mut SDL_GameController,
         data: *const libc::c_void,
@@ -15409,43 +9461,18 @@ extern "C" {
     ) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Close a game controller previously opened with SDL_GameControllerOpen()."]
-    #[doc = ""]
-    #[doc = " \\param gamecontroller a game controller identifier previously returned by"]
-    #[doc = "                       SDL_GameControllerOpen()"]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_GameControllerOpen"]
+    #[doc = " Close a game controller previously opened with SDL_GameControllerOpen().\n\n \\param gamecontroller a game controller identifier previously returned by\n                       SDL_GameControllerOpen()\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_GameControllerOpen"]
     pub fn SDL_GameControllerClose(gamecontroller: *mut SDL_GameController);
 }
 extern "C" {
-    #[doc = " Return the sfSymbolsName for a given button on a game controller on Apple"]
-    #[doc = " platforms."]
-    #[doc = ""]
-    #[doc = " \\param gamecontroller the controller to query"]
-    #[doc = " \\param button a button on the game controller"]
-    #[doc = " \\returns the sfSymbolsName or NULL if the name can't be found"]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.18."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_GameControllerGetAppleSFSymbolsNameForAxis"]
+    #[doc = " Return the sfSymbolsName for a given button on a game controller on Apple\n platforms.\n\n \\param gamecontroller the controller to query\n \\param button a button on the game controller\n \\returns the sfSymbolsName or NULL if the name can't be found\n\n \\since This function is available since SDL 2.0.18.\n\n \\sa SDL_GameControllerGetAppleSFSymbolsNameForAxis"]
     pub fn SDL_GameControllerGetAppleSFSymbolsNameForButton(
         gamecontroller: *mut SDL_GameController,
         button: SDL_GameControllerButton,
     ) -> *const libc::c_char;
 }
 extern "C" {
-    #[doc = " Return the sfSymbolsName for a given axis on a game controller on Apple"]
-    #[doc = " platforms."]
-    #[doc = ""]
-    #[doc = " \\param gamecontroller the controller to query"]
-    #[doc = " \\param axis an axis on the game controller"]
-    #[doc = " \\returns the sfSymbolsName or NULL if the name can't be found"]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.18."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_GameControllerGetAppleSFSymbolsNameForButton"]
+    #[doc = " Return the sfSymbolsName for a given axis on a game controller on Apple\n platforms.\n\n \\param gamecontroller the controller to query\n \\param axis an axis on the game controller\n \\returns the sfSymbolsName or NULL if the name can't be found\n\n \\since This function is available since SDL 2.0.18.\n\n \\sa SDL_GameControllerGetAppleSFSymbolsNameForButton"]
     pub fn SDL_GameControllerGetAppleSFSymbolsNameForAxis(
         gamecontroller: *mut SDL_GameController,
         axis: SDL_GameControllerAxis,
@@ -15454,7 +9481,7 @@ extern "C" {
 pub type SDL_TouchID = Sint64;
 pub type SDL_FingerID = Sint64;
 #[repr(i32)]
-#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
+#[derive(Copy, Clone, Hash, PartialEq, Eq)]
 pub enum SDL_TouchDeviceType {
     SDL_TOUCH_DEVICE_INVALID = -1,
     SDL_TOUCH_DEVICE_DIRECT = 0,
@@ -15471,6 +9498,8 @@ pub struct SDL_Finger {
 }
 #[test]
 fn bindgen_test_layout_SDL_Finger() {
+    const UNINIT: ::core::mem::MaybeUninit<SDL_Finger> = ::core::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::core::mem::size_of::<SDL_Finger>(),
         24usize,
@@ -15482,7 +9511,7 @@ fn bindgen_test_layout_SDL_Finger() {
         concat!("Alignment of ", stringify!(SDL_Finger))
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_Finger>())).id as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).id) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -15492,7 +9521,7 @@ fn bindgen_test_layout_SDL_Finger() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_Finger>())).x as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).x) as usize - ptr as usize },
         8usize,
         concat!(
             "Offset of field: ",
@@ -15502,7 +9531,7 @@ fn bindgen_test_layout_SDL_Finger() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_Finger>())).y as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).y) as usize - ptr as usize },
         12usize,
         concat!(
             "Offset of field: ",
@@ -15512,7 +9541,7 @@ fn bindgen_test_layout_SDL_Finger() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_Finger>())).pressure as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).pressure) as usize - ptr as usize },
         16usize,
         concat!(
             "Offset of field: ",
@@ -15523,154 +9552,65 @@ fn bindgen_test_layout_SDL_Finger() {
     );
 }
 extern "C" {
-    #[doc = " Get the number of registered touch devices."]
-    #[doc = ""]
-    #[doc = " On some platforms SDL first sees the touch device if it was actually used."]
-    #[doc = " Therefore SDL_GetNumTouchDevices() may return 0 although devices are"]
-    #[doc = " available. After using all devices at least once the number will be"]
-    #[doc = " correct."]
-    #[doc = ""]
-    #[doc = " This was fixed for Android in SDL 2.0.1."]
-    #[doc = ""]
-    #[doc = " \\returns the number of registered touch devices."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_GetTouchDevice"]
+    #[doc = " Get the number of registered touch devices.\n\n On some platforms SDL first sees the touch device if it was actually used.\n Therefore SDL_GetNumTouchDevices() may return 0 although devices are\n available. After using all devices at least once the number will be\n correct.\n\n This was fixed for Android in SDL 2.0.1.\n\n \\returns the number of registered touch devices.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_GetTouchDevice"]
     pub fn SDL_GetNumTouchDevices() -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Get the touch ID with the given index."]
-    #[doc = ""]
-    #[doc = " \\param index the touch device index"]
-    #[doc = " \\returns the touch ID with the given index on success or 0 if the index is"]
-    #[doc = "          invalid; call SDL_GetError() for more information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_GetNumTouchDevices"]
+    #[doc = " Get the touch ID with the given index.\n\n \\param index the touch device index\n \\returns the touch ID with the given index on success or 0 if the index is\n          invalid; call SDL_GetError() for more information.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_GetNumTouchDevices"]
     pub fn SDL_GetTouchDevice(index: libc::c_int) -> SDL_TouchID;
 }
 extern "C" {
-    #[doc = " Get the type of the given touch device."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.10."]
+    #[doc = " Get the touch device name as reported from the driver or NULL if the index\n is invalid.\n\n \\since This function is available since SDL 2.0.22."]
+    pub fn SDL_GetTouchName(index: libc::c_int) -> *const libc::c_char;
+}
+extern "C" {
+    #[doc = " Get the type of the given touch device.\n\n \\since This function is available since SDL 2.0.10."]
     pub fn SDL_GetTouchDeviceType(touchID: SDL_TouchID) -> SDL_TouchDeviceType;
 }
 extern "C" {
-    #[doc = " Get the number of active fingers for a given touch device."]
-    #[doc = ""]
-    #[doc = " \\param touchID the ID of a touch device"]
-    #[doc = " \\returns the number of active fingers for a given touch device on success"]
-    #[doc = "          or 0 on failure; call SDL_GetError() for more information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_GetTouchFinger"]
+    #[doc = " Get the number of active fingers for a given touch device.\n\n \\param touchID the ID of a touch device\n \\returns the number of active fingers for a given touch device on success\n          or 0 on failure; call SDL_GetError() for more information.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_GetTouchFinger"]
     pub fn SDL_GetNumTouchFingers(touchID: SDL_TouchID) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Get the finger object for specified touch device ID and finger index."]
-    #[doc = ""]
-    #[doc = " The returned resource is owned by SDL and should not be deallocated."]
-    #[doc = ""]
-    #[doc = " \\param touchID the ID of the requested touch device"]
-    #[doc = " \\param index the index of the requested finger"]
-    #[doc = " \\returns a pointer to the SDL_Finger object or NULL if no object at the"]
-    #[doc = "          given ID and index could be found."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_RecordGesture"]
+    #[doc = " Get the finger object for specified touch device ID and finger index.\n\n The returned resource is owned by SDL and should not be deallocated.\n\n \\param touchID the ID of the requested touch device\n \\param index the index of the requested finger\n \\returns a pointer to the SDL_Finger object or NULL if no object at the\n          given ID and index could be found.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_RecordGesture"]
     pub fn SDL_GetTouchFinger(touchID: SDL_TouchID, index: libc::c_int) -> *mut SDL_Finger;
 }
 pub type SDL_GestureID = Sint64;
 extern "C" {
-    #[doc = " Begin recording a gesture on a specified touch device or all touch devices."]
-    #[doc = ""]
-    #[doc = " If the parameter `touchId` is -1 (i.e., all devices), this function will"]
-    #[doc = " always return 1, regardless of whether there actually are any devices."]
-    #[doc = ""]
-    #[doc = " \\param touchId the touch device id, or -1 for all touch devices"]
-    #[doc = " \\returns 1 on success or 0 if the specified device could not be found."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_GetTouchDevice"]
+    #[doc = " Begin recording a gesture on a specified touch device or all touch devices.\n\n If the parameter `touchId` is -1 (i.e., all devices), this function will\n always return 1, regardless of whether there actually are any devices.\n\n \\param touchId the touch device id, or -1 for all touch devices\n \\returns 1 on success or 0 if the specified device could not be found.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_GetTouchDevice"]
     pub fn SDL_RecordGesture(touchId: SDL_TouchID) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Save all currently loaded Dollar Gesture templates."]
-    #[doc = ""]
-    #[doc = " \\param dst a SDL_RWops to save to"]
-    #[doc = " \\returns the number of saved templates on success or 0 on failure; call"]
-    #[doc = "          SDL_GetError() for more information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_LoadDollarTemplates"]
-    #[doc = " \\sa SDL_SaveDollarTemplate"]
+    #[doc = " Save all currently loaded Dollar Gesture templates.\n\n \\param dst a SDL_RWops to save to\n \\returns the number of saved templates on success or 0 on failure; call\n          SDL_GetError() for more information.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_LoadDollarTemplates\n \\sa SDL_SaveDollarTemplate"]
     pub fn SDL_SaveAllDollarTemplates(dst: *mut SDL_RWops) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Save a currently loaded Dollar Gesture template."]
-    #[doc = ""]
-    #[doc = " \\param gestureId a gesture id"]
-    #[doc = " \\param dst a SDL_RWops to save to"]
-    #[doc = " \\returns 1 on success or 0 on failure; call SDL_GetError() for more"]
-    #[doc = "          information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_LoadDollarTemplates"]
-    #[doc = " \\sa SDL_SaveAllDollarTemplates"]
+    #[doc = " Save a currently loaded Dollar Gesture template.\n\n \\param gestureId a gesture id\n \\param dst a SDL_RWops to save to\n \\returns 1 on success or 0 on failure; call SDL_GetError() for more\n          information.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_LoadDollarTemplates\n \\sa SDL_SaveAllDollarTemplates"]
     pub fn SDL_SaveDollarTemplate(gestureId: SDL_GestureID, dst: *mut SDL_RWops) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Load Dollar Gesture templates from a file."]
-    #[doc = ""]
-    #[doc = " \\param touchId a touch id"]
-    #[doc = " \\param src a SDL_RWops to load from"]
-    #[doc = " \\returns the number of loaded templates on success or a negative error code"]
-    #[doc = "          (or 0) on failure; call SDL_GetError() for more information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_SaveAllDollarTemplates"]
-    #[doc = " \\sa SDL_SaveDollarTemplate"]
+    #[doc = " Load Dollar Gesture templates from a file.\n\n \\param touchId a touch id\n \\param src a SDL_RWops to load from\n \\returns the number of loaded templates on success or a negative error code\n          (or 0) on failure; call SDL_GetError() for more information.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_SaveAllDollarTemplates\n \\sa SDL_SaveDollarTemplate"]
     pub fn SDL_LoadDollarTemplates(touchId: SDL_TouchID, src: *mut SDL_RWops) -> libc::c_int;
 }
 #[repr(u32)]
 #[doc = " The types of events that can be delivered."]
-#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
+#[derive(Copy, Clone, Hash, PartialEq, Eq)]
 pub enum SDL_EventType {
     #[doc = "< Unused (do not remove)"]
     SDL_FIRSTEVENT = 0,
     #[doc = "< User-requested quit"]
     SDL_QUIT = 256,
-    #[doc = "< The application is being terminated by the OS"]
-    #[doc = "Called on iOS in applicationWillTerminate()"]
-    #[doc = "Called on Android in onDestroy()"]
+    #[doc = "< The application is being terminated by the OS\nCalled on iOS in applicationWillTerminate()\nCalled on Android in onDestroy()"]
     SDL_APP_TERMINATING = 257,
-    #[doc = "< The application is low on memory, free memory if possible."]
-    #[doc = "Called on iOS in applicationDidReceiveMemoryWarning()"]
-    #[doc = "Called on Android in onLowMemory()"]
+    #[doc = "< The application is low on memory, free memory if possible.\nCalled on iOS in applicationDidReceiveMemoryWarning()\nCalled on Android in onLowMemory()"]
     SDL_APP_LOWMEMORY = 258,
-    #[doc = "< The application is about to enter the background"]
-    #[doc = "Called on iOS in applicationWillResignActive()"]
-    #[doc = "Called on Android in onPause()"]
+    #[doc = "< The application is about to enter the background\nCalled on iOS in applicationWillResignActive()\nCalled on Android in onPause()"]
     SDL_APP_WILLENTERBACKGROUND = 259,
-    #[doc = "< The application did enter the background and may not get CPU for some time"]
-    #[doc = "Called on iOS in applicationDidEnterBackground()"]
-    #[doc = "Called on Android in onPause()"]
+    #[doc = "< The application did enter the background and may not get CPU for some time\nCalled on iOS in applicationDidEnterBackground()\nCalled on Android in onPause()"]
     SDL_APP_DIDENTERBACKGROUND = 260,
-    #[doc = "< The application is about to enter the foreground"]
-    #[doc = "Called on iOS in applicationWillEnterForeground()"]
-    #[doc = "Called on Android in onResume()"]
+    #[doc = "< The application is about to enter the foreground\nCalled on iOS in applicationWillEnterForeground()\nCalled on Android in onResume()"]
     SDL_APP_WILLENTERFOREGROUND = 261,
-    #[doc = "< The application is now interactive"]
-    #[doc = "Called on iOS in applicationDidBecomeActive()"]
-    #[doc = "Called on Android in onResume()"]
+    #[doc = "< The application is now interactive\nCalled on iOS in applicationDidBecomeActive()\nCalled on Android in onResume()"]
     SDL_APP_DIDENTERFOREGROUND = 262,
     #[doc = "< The user's locale preferences have changed."]
     SDL_LOCALECHANGED = 263,
@@ -15688,9 +9628,10 @@ pub enum SDL_EventType {
     SDL_TEXTEDITING = 770,
     #[doc = "< Keyboard text input"]
     SDL_TEXTINPUT = 771,
-    #[doc = "< Keymap changed due to a system event such as an"]
-    #[doc = "input language or keyboard layout change."]
+    #[doc = "< Keymap changed due to a system event such as an\ninput language or keyboard layout change."]
     SDL_KEYMAPCHANGED = 772,
+    #[doc = "< Extended keyboard text editing (composition)"]
+    SDL_TEXTEDITING_EXT = 773,
     #[doc = "< Mouse moved"]
     SDL_MOUSEMOTION = 1024,
     #[doc = "< Mouse button pressed"]
@@ -15713,6 +9654,8 @@ pub enum SDL_EventType {
     SDL_JOYDEVICEADDED = 1541,
     #[doc = "< An opened joystick has been removed"]
     SDL_JOYDEVICEREMOVED = 1542,
+    #[doc = "< Joystick battery level change"]
+    SDL_JOYBATTERYUPDATED = 1543,
     #[doc = "< Game controller axis motion"]
     SDL_CONTROLLERAXISMOTION = 1616,
     #[doc = "< Game controller button pressed"]
@@ -15739,7 +9682,7 @@ pub enum SDL_EventType {
     SDL_DOLLARGESTURE = 2048,
     SDL_DOLLARRECORD = 2049,
     SDL_MULTIGESTURE = 2050,
-    #[doc = "< The clipboard changed"]
+    #[doc = "< The clipboard or primary selection changed"]
     SDL_CLIPBOARDUPDATE = 2304,
     #[doc = "< The system requests a file open"]
     SDL_DROPFILE = 4096,
@@ -15761,8 +9704,7 @@ pub enum SDL_EventType {
     SDL_RENDER_DEVICE_RESET = 8193,
     #[doc = "< Signals the end of an event poll cycle"]
     SDL_POLLSENTINEL = 32512,
-    #[doc = " Events ::SDL_USEREVENT through ::SDL_LASTEVENT are for your use,"]
-    #[doc = "  and should be allocated with SDL_RegisterEvents()"]
+    #[doc = " Events ::SDL_USEREVENT through ::SDL_LASTEVENT are for your use,\n  and should be allocated with SDL_RegisterEvents()"]
     SDL_USEREVENT = 32768,
     #[doc = "  This last event is only for bounding internal arrays"]
     SDL_LASTEVENT = 65535,
@@ -15777,6 +9719,8 @@ pub struct SDL_CommonEvent {
 }
 #[test]
 fn bindgen_test_layout_SDL_CommonEvent() {
+    const UNINIT: ::core::mem::MaybeUninit<SDL_CommonEvent> = ::core::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::core::mem::size_of::<SDL_CommonEvent>(),
         8usize,
@@ -15788,7 +9732,7 @@ fn bindgen_test_layout_SDL_CommonEvent() {
         concat!("Alignment of ", stringify!(SDL_CommonEvent))
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_CommonEvent>())).type_ as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -15798,7 +9742,7 @@ fn bindgen_test_layout_SDL_CommonEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_CommonEvent>())).timestamp as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).timestamp) as usize - ptr as usize },
         4usize,
         concat!(
             "Offset of field: ",
@@ -15828,6 +9772,8 @@ pub struct SDL_DisplayEvent {
 }
 #[test]
 fn bindgen_test_layout_SDL_DisplayEvent() {
+    const UNINIT: ::core::mem::MaybeUninit<SDL_DisplayEvent> = ::core::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::core::mem::size_of::<SDL_DisplayEvent>(),
         20usize,
@@ -15839,7 +9785,7 @@ fn bindgen_test_layout_SDL_DisplayEvent() {
         concat!("Alignment of ", stringify!(SDL_DisplayEvent))
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_DisplayEvent>())).type_ as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -15849,7 +9795,7 @@ fn bindgen_test_layout_SDL_DisplayEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_DisplayEvent>())).timestamp as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).timestamp) as usize - ptr as usize },
         4usize,
         concat!(
             "Offset of field: ",
@@ -15859,7 +9805,7 @@ fn bindgen_test_layout_SDL_DisplayEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_DisplayEvent>())).display as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).display) as usize - ptr as usize },
         8usize,
         concat!(
             "Offset of field: ",
@@ -15869,7 +9815,7 @@ fn bindgen_test_layout_SDL_DisplayEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_DisplayEvent>())).event as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).event) as usize - ptr as usize },
         12usize,
         concat!(
             "Offset of field: ",
@@ -15879,7 +9825,7 @@ fn bindgen_test_layout_SDL_DisplayEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_DisplayEvent>())).padding1 as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).padding1) as usize - ptr as usize },
         13usize,
         concat!(
             "Offset of field: ",
@@ -15889,7 +9835,7 @@ fn bindgen_test_layout_SDL_DisplayEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_DisplayEvent>())).padding2 as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).padding2) as usize - ptr as usize },
         14usize,
         concat!(
             "Offset of field: ",
@@ -15899,7 +9845,7 @@ fn bindgen_test_layout_SDL_DisplayEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_DisplayEvent>())).padding3 as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).padding3) as usize - ptr as usize },
         15usize,
         concat!(
             "Offset of field: ",
@@ -15909,7 +9855,7 @@ fn bindgen_test_layout_SDL_DisplayEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_DisplayEvent>())).data1 as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).data1) as usize - ptr as usize },
         16usize,
         concat!(
             "Offset of field: ",
@@ -15941,6 +9887,8 @@ pub struct SDL_WindowEvent {
 }
 #[test]
 fn bindgen_test_layout_SDL_WindowEvent() {
+    const UNINIT: ::core::mem::MaybeUninit<SDL_WindowEvent> = ::core::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::core::mem::size_of::<SDL_WindowEvent>(),
         24usize,
@@ -15952,7 +9900,7 @@ fn bindgen_test_layout_SDL_WindowEvent() {
         concat!("Alignment of ", stringify!(SDL_WindowEvent))
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_WindowEvent>())).type_ as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -15962,7 +9910,7 @@ fn bindgen_test_layout_SDL_WindowEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_WindowEvent>())).timestamp as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).timestamp) as usize - ptr as usize },
         4usize,
         concat!(
             "Offset of field: ",
@@ -15972,7 +9920,7 @@ fn bindgen_test_layout_SDL_WindowEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_WindowEvent>())).windowID as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).windowID) as usize - ptr as usize },
         8usize,
         concat!(
             "Offset of field: ",
@@ -15982,7 +9930,7 @@ fn bindgen_test_layout_SDL_WindowEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_WindowEvent>())).event as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).event) as usize - ptr as usize },
         12usize,
         concat!(
             "Offset of field: ",
@@ -15992,7 +9940,7 @@ fn bindgen_test_layout_SDL_WindowEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_WindowEvent>())).padding1 as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).padding1) as usize - ptr as usize },
         13usize,
         concat!(
             "Offset of field: ",
@@ -16002,7 +9950,7 @@ fn bindgen_test_layout_SDL_WindowEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_WindowEvent>())).padding2 as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).padding2) as usize - ptr as usize },
         14usize,
         concat!(
             "Offset of field: ",
@@ -16012,7 +9960,7 @@ fn bindgen_test_layout_SDL_WindowEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_WindowEvent>())).padding3 as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).padding3) as usize - ptr as usize },
         15usize,
         concat!(
             "Offset of field: ",
@@ -16022,7 +9970,7 @@ fn bindgen_test_layout_SDL_WindowEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_WindowEvent>())).data1 as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).data1) as usize - ptr as usize },
         16usize,
         concat!(
             "Offset of field: ",
@@ -16032,7 +9980,7 @@ fn bindgen_test_layout_SDL_WindowEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_WindowEvent>())).data2 as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).data2) as usize - ptr as usize },
         20usize,
         concat!(
             "Offset of field: ",
@@ -16063,6 +10011,8 @@ pub struct SDL_KeyboardEvent {
 }
 #[test]
 fn bindgen_test_layout_SDL_KeyboardEvent() {
+    const UNINIT: ::core::mem::MaybeUninit<SDL_KeyboardEvent> = ::core::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::core::mem::size_of::<SDL_KeyboardEvent>(),
         32usize,
@@ -16074,7 +10024,7 @@ fn bindgen_test_layout_SDL_KeyboardEvent() {
         concat!("Alignment of ", stringify!(SDL_KeyboardEvent))
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_KeyboardEvent>())).type_ as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -16084,7 +10034,7 @@ fn bindgen_test_layout_SDL_KeyboardEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_KeyboardEvent>())).timestamp as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).timestamp) as usize - ptr as usize },
         4usize,
         concat!(
             "Offset of field: ",
@@ -16094,7 +10044,7 @@ fn bindgen_test_layout_SDL_KeyboardEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_KeyboardEvent>())).windowID as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).windowID) as usize - ptr as usize },
         8usize,
         concat!(
             "Offset of field: ",
@@ -16104,7 +10054,7 @@ fn bindgen_test_layout_SDL_KeyboardEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_KeyboardEvent>())).state as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).state) as usize - ptr as usize },
         12usize,
         concat!(
             "Offset of field: ",
@@ -16114,7 +10064,7 @@ fn bindgen_test_layout_SDL_KeyboardEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_KeyboardEvent>())).repeat as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).repeat) as usize - ptr as usize },
         13usize,
         concat!(
             "Offset of field: ",
@@ -16124,7 +10074,7 @@ fn bindgen_test_layout_SDL_KeyboardEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_KeyboardEvent>())).padding2 as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).padding2) as usize - ptr as usize },
         14usize,
         concat!(
             "Offset of field: ",
@@ -16134,7 +10084,7 @@ fn bindgen_test_layout_SDL_KeyboardEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_KeyboardEvent>())).padding3 as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).padding3) as usize - ptr as usize },
         15usize,
         concat!(
             "Offset of field: ",
@@ -16144,7 +10094,7 @@ fn bindgen_test_layout_SDL_KeyboardEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_KeyboardEvent>())).keysym as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).keysym) as usize - ptr as usize },
         16usize,
         concat!(
             "Offset of field: ",
@@ -16173,6 +10123,9 @@ pub struct SDL_TextEditingEvent {
 }
 #[test]
 fn bindgen_test_layout_SDL_TextEditingEvent() {
+    const UNINIT: ::core::mem::MaybeUninit<SDL_TextEditingEvent> =
+        ::core::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::core::mem::size_of::<SDL_TextEditingEvent>(),
         52usize,
@@ -16184,7 +10137,7 @@ fn bindgen_test_layout_SDL_TextEditingEvent() {
         concat!("Alignment of ", stringify!(SDL_TextEditingEvent))
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_TextEditingEvent>())).type_ as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -16194,7 +10147,7 @@ fn bindgen_test_layout_SDL_TextEditingEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_TextEditingEvent>())).timestamp as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).timestamp) as usize - ptr as usize },
         4usize,
         concat!(
             "Offset of field: ",
@@ -16204,7 +10157,7 @@ fn bindgen_test_layout_SDL_TextEditingEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_TextEditingEvent>())).windowID as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).windowID) as usize - ptr as usize },
         8usize,
         concat!(
             "Offset of field: ",
@@ -16214,7 +10167,7 @@ fn bindgen_test_layout_SDL_TextEditingEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_TextEditingEvent>())).text as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).text) as usize - ptr as usize },
         12usize,
         concat!(
             "Offset of field: ",
@@ -16224,7 +10177,7 @@ fn bindgen_test_layout_SDL_TextEditingEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_TextEditingEvent>())).start as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).start) as usize - ptr as usize },
         44usize,
         concat!(
             "Offset of field: ",
@@ -16234,7 +10187,7 @@ fn bindgen_test_layout_SDL_TextEditingEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_TextEditingEvent>())).length as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).length) as usize - ptr as usize },
         48usize,
         concat!(
             "Offset of field: ",
@@ -16244,6 +10197,99 @@ fn bindgen_test_layout_SDL_TextEditingEvent() {
         )
     );
 }
+#[doc = "  \\brief Extended keyboard text editing event structure (event.editExt.*) when text would be\n  truncated if stored in the text buffer SDL_TextEditingEvent"]
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct SDL_TextEditingExtEvent {
+    #[doc = "< ::SDL_TEXTEDITING_EXT"]
+    pub type_: Uint32,
+    #[doc = "< In milliseconds, populated using SDL_GetTicks()"]
+    pub timestamp: Uint32,
+    #[doc = "< The window with keyboard focus, if any"]
+    pub windowID: Uint32,
+    #[doc = "< The editing text, which should be freed with SDL_free(), and will not be NULL"]
+    pub text: *mut libc::c_char,
+    #[doc = "< The start cursor of selected editing text"]
+    pub start: Sint32,
+    #[doc = "< The length of selected editing text"]
+    pub length: Sint32,
+}
+#[test]
+fn bindgen_test_layout_SDL_TextEditingExtEvent() {
+    const UNINIT: ::core::mem::MaybeUninit<SDL_TextEditingExtEvent> =
+        ::core::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::core::mem::size_of::<SDL_TextEditingExtEvent>(),
+        32usize,
+        concat!("Size of: ", stringify!(SDL_TextEditingExtEvent))
+    );
+    assert_eq!(
+        ::core::mem::align_of::<SDL_TextEditingExtEvent>(),
+        8usize,
+        concat!("Alignment of ", stringify!(SDL_TextEditingExtEvent))
+    );
+    assert_eq!(
+        unsafe { ::core::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(SDL_TextEditingExtEvent),
+            "::",
+            stringify!(type_)
+        )
+    );
+    assert_eq!(
+        unsafe { ::core::ptr::addr_of!((*ptr).timestamp) as usize - ptr as usize },
+        4usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(SDL_TextEditingExtEvent),
+            "::",
+            stringify!(timestamp)
+        )
+    );
+    assert_eq!(
+        unsafe { ::core::ptr::addr_of!((*ptr).windowID) as usize - ptr as usize },
+        8usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(SDL_TextEditingExtEvent),
+            "::",
+            stringify!(windowID)
+        )
+    );
+    assert_eq!(
+        unsafe { ::core::ptr::addr_of!((*ptr).text) as usize - ptr as usize },
+        16usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(SDL_TextEditingExtEvent),
+            "::",
+            stringify!(text)
+        )
+    );
+    assert_eq!(
+        unsafe { ::core::ptr::addr_of!((*ptr).start) as usize - ptr as usize },
+        24usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(SDL_TextEditingExtEvent),
+            "::",
+            stringify!(start)
+        )
+    );
+    assert_eq!(
+        unsafe { ::core::ptr::addr_of!((*ptr).length) as usize - ptr as usize },
+        28usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(SDL_TextEditingExtEvent),
+            "::",
+            stringify!(length)
+        )
+    );
+}
 #[doc = "  \\brief Keyboard text input event structure (event.text.*)"]
 #[repr(C)]
 #[derive(Copy, Clone)]
@@ -16259,6 +10305,8 @@ pub struct SDL_TextInputEvent {
 }
 #[test]
 fn bindgen_test_layout_SDL_TextInputEvent() {
+    const UNINIT: ::core::mem::MaybeUninit<SDL_TextInputEvent> = ::core::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::core::mem::size_of::<SDL_TextInputEvent>(),
         44usize,
@@ -16270,7 +10318,7 @@ fn bindgen_test_layout_SDL_TextInputEvent() {
         concat!("Alignment of ", stringify!(SDL_TextInputEvent))
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_TextInputEvent>())).type_ as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -16280,7 +10328,7 @@ fn bindgen_test_layout_SDL_TextInputEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_TextInputEvent>())).timestamp as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).timestamp) as usize - ptr as usize },
         4usize,
         concat!(
             "Offset of field: ",
@@ -16290,7 +10338,7 @@ fn bindgen_test_layout_SDL_TextInputEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_TextInputEvent>())).windowID as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).windowID) as usize - ptr as usize },
         8usize,
         concat!(
             "Offset of field: ",
@@ -16300,7 +10348,7 @@ fn bindgen_test_layout_SDL_TextInputEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_TextInputEvent>())).text as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).text) as usize - ptr as usize },
         12usize,
         concat!(
             "Offset of field: ",
@@ -16335,6 +10383,9 @@ pub struct SDL_MouseMotionEvent {
 }
 #[test]
 fn bindgen_test_layout_SDL_MouseMotionEvent() {
+    const UNINIT: ::core::mem::MaybeUninit<SDL_MouseMotionEvent> =
+        ::core::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::core::mem::size_of::<SDL_MouseMotionEvent>(),
         36usize,
@@ -16346,7 +10397,7 @@ fn bindgen_test_layout_SDL_MouseMotionEvent() {
         concat!("Alignment of ", stringify!(SDL_MouseMotionEvent))
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_MouseMotionEvent>())).type_ as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -16356,7 +10407,7 @@ fn bindgen_test_layout_SDL_MouseMotionEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_MouseMotionEvent>())).timestamp as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).timestamp) as usize - ptr as usize },
         4usize,
         concat!(
             "Offset of field: ",
@@ -16366,7 +10417,7 @@ fn bindgen_test_layout_SDL_MouseMotionEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_MouseMotionEvent>())).windowID as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).windowID) as usize - ptr as usize },
         8usize,
         concat!(
             "Offset of field: ",
@@ -16376,7 +10427,7 @@ fn bindgen_test_layout_SDL_MouseMotionEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_MouseMotionEvent>())).which as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).which) as usize - ptr as usize },
         12usize,
         concat!(
             "Offset of field: ",
@@ -16386,7 +10437,7 @@ fn bindgen_test_layout_SDL_MouseMotionEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_MouseMotionEvent>())).state as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).state) as usize - ptr as usize },
         16usize,
         concat!(
             "Offset of field: ",
@@ -16396,7 +10447,7 @@ fn bindgen_test_layout_SDL_MouseMotionEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_MouseMotionEvent>())).x as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).x) as usize - ptr as usize },
         20usize,
         concat!(
             "Offset of field: ",
@@ -16406,7 +10457,7 @@ fn bindgen_test_layout_SDL_MouseMotionEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_MouseMotionEvent>())).y as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).y) as usize - ptr as usize },
         24usize,
         concat!(
             "Offset of field: ",
@@ -16416,7 +10467,7 @@ fn bindgen_test_layout_SDL_MouseMotionEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_MouseMotionEvent>())).xrel as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).xrel) as usize - ptr as usize },
         28usize,
         concat!(
             "Offset of field: ",
@@ -16426,7 +10477,7 @@ fn bindgen_test_layout_SDL_MouseMotionEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_MouseMotionEvent>())).yrel as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).yrel) as usize - ptr as usize },
         32usize,
         concat!(
             "Offset of field: ",
@@ -16462,6 +10513,9 @@ pub struct SDL_MouseButtonEvent {
 }
 #[test]
 fn bindgen_test_layout_SDL_MouseButtonEvent() {
+    const UNINIT: ::core::mem::MaybeUninit<SDL_MouseButtonEvent> =
+        ::core::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::core::mem::size_of::<SDL_MouseButtonEvent>(),
         28usize,
@@ -16473,7 +10527,7 @@ fn bindgen_test_layout_SDL_MouseButtonEvent() {
         concat!("Alignment of ", stringify!(SDL_MouseButtonEvent))
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_MouseButtonEvent>())).type_ as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -16483,7 +10537,7 @@ fn bindgen_test_layout_SDL_MouseButtonEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_MouseButtonEvent>())).timestamp as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).timestamp) as usize - ptr as usize },
         4usize,
         concat!(
             "Offset of field: ",
@@ -16493,7 +10547,7 @@ fn bindgen_test_layout_SDL_MouseButtonEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_MouseButtonEvent>())).windowID as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).windowID) as usize - ptr as usize },
         8usize,
         concat!(
             "Offset of field: ",
@@ -16503,7 +10557,7 @@ fn bindgen_test_layout_SDL_MouseButtonEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_MouseButtonEvent>())).which as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).which) as usize - ptr as usize },
         12usize,
         concat!(
             "Offset of field: ",
@@ -16513,7 +10567,7 @@ fn bindgen_test_layout_SDL_MouseButtonEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_MouseButtonEvent>())).button as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).button) as usize - ptr as usize },
         16usize,
         concat!(
             "Offset of field: ",
@@ -16523,7 +10577,7 @@ fn bindgen_test_layout_SDL_MouseButtonEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_MouseButtonEvent>())).state as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).state) as usize - ptr as usize },
         17usize,
         concat!(
             "Offset of field: ",
@@ -16533,7 +10587,7 @@ fn bindgen_test_layout_SDL_MouseButtonEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_MouseButtonEvent>())).clicks as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).clicks) as usize - ptr as usize },
         18usize,
         concat!(
             "Offset of field: ",
@@ -16543,7 +10597,7 @@ fn bindgen_test_layout_SDL_MouseButtonEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_MouseButtonEvent>())).padding1 as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).padding1) as usize - ptr as usize },
         19usize,
         concat!(
             "Offset of field: ",
@@ -16553,7 +10607,7 @@ fn bindgen_test_layout_SDL_MouseButtonEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_MouseButtonEvent>())).x as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).x) as usize - ptr as usize },
         20usize,
         concat!(
             "Offset of field: ",
@@ -16563,7 +10617,7 @@ fn bindgen_test_layout_SDL_MouseButtonEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_MouseButtonEvent>())).y as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).y) as usize - ptr as usize },
         24usize,
         concat!(
             "Offset of field: ",
@@ -16595,12 +10649,19 @@ pub struct SDL_MouseWheelEvent {
     pub preciseX: f32,
     #[doc = "< The amount scrolled vertically, positive away from the user and negative toward the user, with float precision (added in 2.0.18)"]
     pub preciseY: f32,
+    #[doc = "< X coordinate, relative to window (added in 2.26.0)"]
+    pub mouseX: Sint32,
+    #[doc = "< Y coordinate, relative to window (added in 2.26.0)"]
+    pub mouseY: Sint32,
 }
 #[test]
 fn bindgen_test_layout_SDL_MouseWheelEvent() {
+    const UNINIT: ::core::mem::MaybeUninit<SDL_MouseWheelEvent> =
+        ::core::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::core::mem::size_of::<SDL_MouseWheelEvent>(),
-        36usize,
+        44usize,
         concat!("Size of: ", stringify!(SDL_MouseWheelEvent))
     );
     assert_eq!(
@@ -16609,7 +10670,7 @@ fn bindgen_test_layout_SDL_MouseWheelEvent() {
         concat!("Alignment of ", stringify!(SDL_MouseWheelEvent))
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_MouseWheelEvent>())).type_ as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -16619,7 +10680,7 @@ fn bindgen_test_layout_SDL_MouseWheelEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_MouseWheelEvent>())).timestamp as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).timestamp) as usize - ptr as usize },
         4usize,
         concat!(
             "Offset of field: ",
@@ -16629,7 +10690,7 @@ fn bindgen_test_layout_SDL_MouseWheelEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_MouseWheelEvent>())).windowID as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).windowID) as usize - ptr as usize },
         8usize,
         concat!(
             "Offset of field: ",
@@ -16639,7 +10700,7 @@ fn bindgen_test_layout_SDL_MouseWheelEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_MouseWheelEvent>())).which as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).which) as usize - ptr as usize },
         12usize,
         concat!(
             "Offset of field: ",
@@ -16649,7 +10710,7 @@ fn bindgen_test_layout_SDL_MouseWheelEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_MouseWheelEvent>())).x as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).x) as usize - ptr as usize },
         16usize,
         concat!(
             "Offset of field: ",
@@ -16659,7 +10720,7 @@ fn bindgen_test_layout_SDL_MouseWheelEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_MouseWheelEvent>())).y as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).y) as usize - ptr as usize },
         20usize,
         concat!(
             "Offset of field: ",
@@ -16669,7 +10730,7 @@ fn bindgen_test_layout_SDL_MouseWheelEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_MouseWheelEvent>())).direction as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).direction) as usize - ptr as usize },
         24usize,
         concat!(
             "Offset of field: ",
@@ -16679,7 +10740,7 @@ fn bindgen_test_layout_SDL_MouseWheelEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_MouseWheelEvent>())).preciseX as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).preciseX) as usize - ptr as usize },
         28usize,
         concat!(
             "Offset of field: ",
@@ -16689,7 +10750,7 @@ fn bindgen_test_layout_SDL_MouseWheelEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_MouseWheelEvent>())).preciseY as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).preciseY) as usize - ptr as usize },
         32usize,
         concat!(
             "Offset of field: ",
@@ -16698,6 +10759,26 @@ fn bindgen_test_layout_SDL_MouseWheelEvent() {
             stringify!(preciseY)
         )
     );
+    assert_eq!(
+        unsafe { ::core::ptr::addr_of!((*ptr).mouseX) as usize - ptr as usize },
+        36usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(SDL_MouseWheelEvent),
+            "::",
+            stringify!(mouseX)
+        )
+    );
+    assert_eq!(
+        unsafe { ::core::ptr::addr_of!((*ptr).mouseY) as usize - ptr as usize },
+        40usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(SDL_MouseWheelEvent),
+            "::",
+            stringify!(mouseY)
+        )
+    );
 }
 #[doc = "  \\brief Joystick axis motion event structure (event.jaxis.*)"]
 #[repr(C)]
@@ -16720,6 +10801,8 @@ pub struct SDL_JoyAxisEvent {
 }
 #[test]
 fn bindgen_test_layout_SDL_JoyAxisEvent() {
+    const UNINIT: ::core::mem::MaybeUninit<SDL_JoyAxisEvent> = ::core::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::core::mem::size_of::<SDL_JoyAxisEvent>(),
         20usize,
@@ -16731,7 +10814,7 @@ fn bindgen_test_layout_SDL_JoyAxisEvent() {
         concat!("Alignment of ", stringify!(SDL_JoyAxisEvent))
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_JoyAxisEvent>())).type_ as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -16741,7 +10824,7 @@ fn bindgen_test_layout_SDL_JoyAxisEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_JoyAxisEvent>())).timestamp as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).timestamp) as usize - ptr as usize },
         4usize,
         concat!(
             "Offset of field: ",
@@ -16751,7 +10834,7 @@ fn bindgen_test_layout_SDL_JoyAxisEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_JoyAxisEvent>())).which as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).which) as usize - ptr as usize },
         8usize,
         concat!(
             "Offset of field: ",
@@ -16761,7 +10844,7 @@ fn bindgen_test_layout_SDL_JoyAxisEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_JoyAxisEvent>())).axis as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).axis) as usize - ptr as usize },
         12usize,
         concat!(
             "Offset of field: ",
@@ -16771,7 +10854,7 @@ fn bindgen_test_layout_SDL_JoyAxisEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_JoyAxisEvent>())).padding1 as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).padding1) as usize - ptr as usize },
         13usize,
         concat!(
             "Offset of field: ",
@@ -16781,7 +10864,7 @@ fn bindgen_test_layout_SDL_JoyAxisEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_JoyAxisEvent>())).padding2 as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).padding2) as usize - ptr as usize },
         14usize,
         concat!(
             "Offset of field: ",
@@ -16791,7 +10874,7 @@ fn bindgen_test_layout_SDL_JoyAxisEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_JoyAxisEvent>())).padding3 as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).padding3) as usize - ptr as usize },
         15usize,
         concat!(
             "Offset of field: ",
@@ -16801,7 +10884,7 @@ fn bindgen_test_layout_SDL_JoyAxisEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_JoyAxisEvent>())).value as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).value) as usize - ptr as usize },
         16usize,
         concat!(
             "Offset of field: ",
@@ -16811,7 +10894,7 @@ fn bindgen_test_layout_SDL_JoyAxisEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_JoyAxisEvent>())).padding4 as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).padding4) as usize - ptr as usize },
         18usize,
         concat!(
             "Offset of field: ",
@@ -16843,6 +10926,8 @@ pub struct SDL_JoyBallEvent {
 }
 #[test]
 fn bindgen_test_layout_SDL_JoyBallEvent() {
+    const UNINIT: ::core::mem::MaybeUninit<SDL_JoyBallEvent> = ::core::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::core::mem::size_of::<SDL_JoyBallEvent>(),
         20usize,
@@ -16854,7 +10939,7 @@ fn bindgen_test_layout_SDL_JoyBallEvent() {
         concat!("Alignment of ", stringify!(SDL_JoyBallEvent))
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_JoyBallEvent>())).type_ as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -16864,7 +10949,7 @@ fn bindgen_test_layout_SDL_JoyBallEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_JoyBallEvent>())).timestamp as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).timestamp) as usize - ptr as usize },
         4usize,
         concat!(
             "Offset of field: ",
@@ -16874,7 +10959,7 @@ fn bindgen_test_layout_SDL_JoyBallEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_JoyBallEvent>())).which as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).which) as usize - ptr as usize },
         8usize,
         concat!(
             "Offset of field: ",
@@ -16884,7 +10969,7 @@ fn bindgen_test_layout_SDL_JoyBallEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_JoyBallEvent>())).ball as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).ball) as usize - ptr as usize },
         12usize,
         concat!(
             "Offset of field: ",
@@ -16894,7 +10979,7 @@ fn bindgen_test_layout_SDL_JoyBallEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_JoyBallEvent>())).padding1 as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).padding1) as usize - ptr as usize },
         13usize,
         concat!(
             "Offset of field: ",
@@ -16904,7 +10989,7 @@ fn bindgen_test_layout_SDL_JoyBallEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_JoyBallEvent>())).padding2 as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).padding2) as usize - ptr as usize },
         14usize,
         concat!(
             "Offset of field: ",
@@ -16914,7 +10999,7 @@ fn bindgen_test_layout_SDL_JoyBallEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_JoyBallEvent>())).padding3 as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).padding3) as usize - ptr as usize },
         15usize,
         concat!(
             "Offset of field: ",
@@ -16924,7 +11009,7 @@ fn bindgen_test_layout_SDL_JoyBallEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_JoyBallEvent>())).xrel as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).xrel) as usize - ptr as usize },
         16usize,
         concat!(
             "Offset of field: ",
@@ -16934,7 +11019,7 @@ fn bindgen_test_layout_SDL_JoyBallEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_JoyBallEvent>())).yrel as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).yrel) as usize - ptr as usize },
         18usize,
         concat!(
             "Offset of field: ",
@@ -16956,18 +11041,15 @@ pub struct SDL_JoyHatEvent {
     pub which: SDL_JoystickID,
     #[doc = "< The joystick hat index"]
     pub hat: Uint8,
-    #[doc = "< The hat position value."]
-    #[doc = "   \\sa ::SDL_HAT_LEFTUP ::SDL_HAT_UP ::SDL_HAT_RIGHTUP"]
-    #[doc = "   \\sa ::SDL_HAT_LEFT ::SDL_HAT_CENTERED ::SDL_HAT_RIGHT"]
-    #[doc = "   \\sa ::SDL_HAT_LEFTDOWN ::SDL_HAT_DOWN ::SDL_HAT_RIGHTDOWN"]
-    #[doc = ""]
-    #[doc = "   Note that zero means the POV is centered."]
+    #[doc = "< The hat position value.\n   \\sa ::SDL_HAT_LEFTUP ::SDL_HAT_UP ::SDL_HAT_RIGHTUP\n   \\sa ::SDL_HAT_LEFT ::SDL_HAT_CENTERED ::SDL_HAT_RIGHT\n   \\sa ::SDL_HAT_LEFTDOWN ::SDL_HAT_DOWN ::SDL_HAT_RIGHTDOWN\n\n   Note that zero means the POV is centered."]
     pub value: Uint8,
     pub padding1: Uint8,
     pub padding2: Uint8,
 }
 #[test]
 fn bindgen_test_layout_SDL_JoyHatEvent() {
+    const UNINIT: ::core::mem::MaybeUninit<SDL_JoyHatEvent> = ::core::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::core::mem::size_of::<SDL_JoyHatEvent>(),
         16usize,
@@ -16979,7 +11061,7 @@ fn bindgen_test_layout_SDL_JoyHatEvent() {
         concat!("Alignment of ", stringify!(SDL_JoyHatEvent))
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_JoyHatEvent>())).type_ as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -16989,7 +11071,7 @@ fn bindgen_test_layout_SDL_JoyHatEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_JoyHatEvent>())).timestamp as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).timestamp) as usize - ptr as usize },
         4usize,
         concat!(
             "Offset of field: ",
@@ -16999,7 +11081,7 @@ fn bindgen_test_layout_SDL_JoyHatEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_JoyHatEvent>())).which as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).which) as usize - ptr as usize },
         8usize,
         concat!(
             "Offset of field: ",
@@ -17009,7 +11091,7 @@ fn bindgen_test_layout_SDL_JoyHatEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_JoyHatEvent>())).hat as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).hat) as usize - ptr as usize },
         12usize,
         concat!(
             "Offset of field: ",
@@ -17019,7 +11101,7 @@ fn bindgen_test_layout_SDL_JoyHatEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_JoyHatEvent>())).value as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).value) as usize - ptr as usize },
         13usize,
         concat!(
             "Offset of field: ",
@@ -17029,7 +11111,7 @@ fn bindgen_test_layout_SDL_JoyHatEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_JoyHatEvent>())).padding1 as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).padding1) as usize - ptr as usize },
         14usize,
         concat!(
             "Offset of field: ",
@@ -17039,7 +11121,7 @@ fn bindgen_test_layout_SDL_JoyHatEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_JoyHatEvent>())).padding2 as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).padding2) as usize - ptr as usize },
         15usize,
         concat!(
             "Offset of field: ",
@@ -17068,6 +11150,8 @@ pub struct SDL_JoyButtonEvent {
 }
 #[test]
 fn bindgen_test_layout_SDL_JoyButtonEvent() {
+    const UNINIT: ::core::mem::MaybeUninit<SDL_JoyButtonEvent> = ::core::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::core::mem::size_of::<SDL_JoyButtonEvent>(),
         16usize,
@@ -17079,7 +11163,7 @@ fn bindgen_test_layout_SDL_JoyButtonEvent() {
         concat!("Alignment of ", stringify!(SDL_JoyButtonEvent))
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_JoyButtonEvent>())).type_ as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -17089,7 +11173,7 @@ fn bindgen_test_layout_SDL_JoyButtonEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_JoyButtonEvent>())).timestamp as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).timestamp) as usize - ptr as usize },
         4usize,
         concat!(
             "Offset of field: ",
@@ -17099,7 +11183,7 @@ fn bindgen_test_layout_SDL_JoyButtonEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_JoyButtonEvent>())).which as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).which) as usize - ptr as usize },
         8usize,
         concat!(
             "Offset of field: ",
@@ -17109,7 +11193,7 @@ fn bindgen_test_layout_SDL_JoyButtonEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_JoyButtonEvent>())).button as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).button) as usize - ptr as usize },
         12usize,
         concat!(
             "Offset of field: ",
@@ -17119,7 +11203,7 @@ fn bindgen_test_layout_SDL_JoyButtonEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_JoyButtonEvent>())).state as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).state) as usize - ptr as usize },
         13usize,
         concat!(
             "Offset of field: ",
@@ -17129,7 +11213,7 @@ fn bindgen_test_layout_SDL_JoyButtonEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_JoyButtonEvent>())).padding1 as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).padding1) as usize - ptr as usize },
         14usize,
         concat!(
             "Offset of field: ",
@@ -17139,7 +11223,7 @@ fn bindgen_test_layout_SDL_JoyButtonEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_JoyButtonEvent>())).padding2 as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).padding2) as usize - ptr as usize },
         15usize,
         concat!(
             "Offset of field: ",
@@ -17162,6 +11246,8 @@ pub struct SDL_JoyDeviceEvent {
 }
 #[test]
 fn bindgen_test_layout_SDL_JoyDeviceEvent() {
+    const UNINIT: ::core::mem::MaybeUninit<SDL_JoyDeviceEvent> = ::core::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::core::mem::size_of::<SDL_JoyDeviceEvent>(),
         12usize,
@@ -17173,7 +11259,7 @@ fn bindgen_test_layout_SDL_JoyDeviceEvent() {
         concat!("Alignment of ", stringify!(SDL_JoyDeviceEvent))
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_JoyDeviceEvent>())).type_ as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -17183,7 +11269,7 @@ fn bindgen_test_layout_SDL_JoyDeviceEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_JoyDeviceEvent>())).timestamp as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).timestamp) as usize - ptr as usize },
         4usize,
         concat!(
             "Offset of field: ",
@@ -17193,7 +11279,7 @@ fn bindgen_test_layout_SDL_JoyDeviceEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_JoyDeviceEvent>())).which as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).which) as usize - ptr as usize },
         8usize,
         concat!(
             "Offset of field: ",
@@ -17203,6 +11289,75 @@ fn bindgen_test_layout_SDL_JoyDeviceEvent() {
         )
     );
 }
+#[doc = "  \\brief Joysick battery level change event structure (event.jbattery.*)"]
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct SDL_JoyBatteryEvent {
+    #[doc = "< ::SDL_JOYBATTERYUPDATED"]
+    pub type_: Uint32,
+    #[doc = "< In milliseconds, populated using SDL_GetTicks()"]
+    pub timestamp: Uint32,
+    #[doc = "< The joystick instance id"]
+    pub which: SDL_JoystickID,
+    #[doc = "< The joystick battery level"]
+    pub level: SDL_JoystickPowerLevel,
+}
+#[test]
+fn bindgen_test_layout_SDL_JoyBatteryEvent() {
+    const UNINIT: ::core::mem::MaybeUninit<SDL_JoyBatteryEvent> =
+        ::core::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
+    assert_eq!(
+        ::core::mem::size_of::<SDL_JoyBatteryEvent>(),
+        16usize,
+        concat!("Size of: ", stringify!(SDL_JoyBatteryEvent))
+    );
+    assert_eq!(
+        ::core::mem::align_of::<SDL_JoyBatteryEvent>(),
+        4usize,
+        concat!("Alignment of ", stringify!(SDL_JoyBatteryEvent))
+    );
+    assert_eq!(
+        unsafe { ::core::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(SDL_JoyBatteryEvent),
+            "::",
+            stringify!(type_)
+        )
+    );
+    assert_eq!(
+        unsafe { ::core::ptr::addr_of!((*ptr).timestamp) as usize - ptr as usize },
+        4usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(SDL_JoyBatteryEvent),
+            "::",
+            stringify!(timestamp)
+        )
+    );
+    assert_eq!(
+        unsafe { ::core::ptr::addr_of!((*ptr).which) as usize - ptr as usize },
+        8usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(SDL_JoyBatteryEvent),
+            "::",
+            stringify!(which)
+        )
+    );
+    assert_eq!(
+        unsafe { ::core::ptr::addr_of!((*ptr).level) as usize - ptr as usize },
+        12usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(SDL_JoyBatteryEvent),
+            "::",
+            stringify!(level)
+        )
+    );
+}
 #[doc = "  \\brief Game controller axis motion event structure (event.caxis.*)"]
 #[repr(C)]
 #[derive(Copy, Clone)]
@@ -17224,6 +11379,9 @@ pub struct SDL_ControllerAxisEvent {
 }
 #[test]
 fn bindgen_test_layout_SDL_ControllerAxisEvent() {
+    const UNINIT: ::core::mem::MaybeUninit<SDL_ControllerAxisEvent> =
+        ::core::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::core::mem::size_of::<SDL_ControllerAxisEvent>(),
         20usize,
@@ -17235,7 +11393,7 @@ fn bindgen_test_layout_SDL_ControllerAxisEvent() {
         concat!("Alignment of ", stringify!(SDL_ControllerAxisEvent))
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_ControllerAxisEvent>())).type_ as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -17245,9 +11403,7 @@ fn bindgen_test_layout_SDL_ControllerAxisEvent() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::core::ptr::null::<SDL_ControllerAxisEvent>())).timestamp as *const _ as usize
-        },
+        unsafe { ::core::ptr::addr_of!((*ptr).timestamp) as usize - ptr as usize },
         4usize,
         concat!(
             "Offset of field: ",
@@ -17257,7 +11413,7 @@ fn bindgen_test_layout_SDL_ControllerAxisEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_ControllerAxisEvent>())).which as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).which) as usize - ptr as usize },
         8usize,
         concat!(
             "Offset of field: ",
@@ -17267,7 +11423,7 @@ fn bindgen_test_layout_SDL_ControllerAxisEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_ControllerAxisEvent>())).axis as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).axis) as usize - ptr as usize },
         12usize,
         concat!(
             "Offset of field: ",
@@ -17277,9 +11433,7 @@ fn bindgen_test_layout_SDL_ControllerAxisEvent() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::core::ptr::null::<SDL_ControllerAxisEvent>())).padding1 as *const _ as usize
-        },
+        unsafe { ::core::ptr::addr_of!((*ptr).padding1) as usize - ptr as usize },
         13usize,
         concat!(
             "Offset of field: ",
@@ -17289,9 +11443,7 @@ fn bindgen_test_layout_SDL_ControllerAxisEvent() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::core::ptr::null::<SDL_ControllerAxisEvent>())).padding2 as *const _ as usize
-        },
+        unsafe { ::core::ptr::addr_of!((*ptr).padding2) as usize - ptr as usize },
         14usize,
         concat!(
             "Offset of field: ",
@@ -17301,9 +11453,7 @@ fn bindgen_test_layout_SDL_ControllerAxisEvent() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::core::ptr::null::<SDL_ControllerAxisEvent>())).padding3 as *const _ as usize
-        },
+        unsafe { ::core::ptr::addr_of!((*ptr).padding3) as usize - ptr as usize },
         15usize,
         concat!(
             "Offset of field: ",
@@ -17313,7 +11463,7 @@ fn bindgen_test_layout_SDL_ControllerAxisEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_ControllerAxisEvent>())).value as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).value) as usize - ptr as usize },
         16usize,
         concat!(
             "Offset of field: ",
@@ -17323,9 +11473,7 @@ fn bindgen_test_layout_SDL_ControllerAxisEvent() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::core::ptr::null::<SDL_ControllerAxisEvent>())).padding4 as *const _ as usize
-        },
+        unsafe { ::core::ptr::addr_of!((*ptr).padding4) as usize - ptr as usize },
         18usize,
         concat!(
             "Offset of field: ",
@@ -17354,6 +11502,9 @@ pub struct SDL_ControllerButtonEvent {
 }
 #[test]
 fn bindgen_test_layout_SDL_ControllerButtonEvent() {
+    const UNINIT: ::core::mem::MaybeUninit<SDL_ControllerButtonEvent> =
+        ::core::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::core::mem::size_of::<SDL_ControllerButtonEvent>(),
         16usize,
@@ -17365,9 +11516,7 @@ fn bindgen_test_layout_SDL_ControllerButtonEvent() {
         concat!("Alignment of ", stringify!(SDL_ControllerButtonEvent))
     );
     assert_eq!(
-        unsafe {
-            &(*(::core::ptr::null::<SDL_ControllerButtonEvent>())).type_ as *const _ as usize
-        },
+        unsafe { ::core::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -17377,9 +11526,7 @@ fn bindgen_test_layout_SDL_ControllerButtonEvent() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::core::ptr::null::<SDL_ControllerButtonEvent>())).timestamp as *const _ as usize
-        },
+        unsafe { ::core::ptr::addr_of!((*ptr).timestamp) as usize - ptr as usize },
         4usize,
         concat!(
             "Offset of field: ",
@@ -17389,9 +11536,7 @@ fn bindgen_test_layout_SDL_ControllerButtonEvent() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::core::ptr::null::<SDL_ControllerButtonEvent>())).which as *const _ as usize
-        },
+        unsafe { ::core::ptr::addr_of!((*ptr).which) as usize - ptr as usize },
         8usize,
         concat!(
             "Offset of field: ",
@@ -17401,9 +11546,7 @@ fn bindgen_test_layout_SDL_ControllerButtonEvent() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::core::ptr::null::<SDL_ControllerButtonEvent>())).button as *const _ as usize
-        },
+        unsafe { ::core::ptr::addr_of!((*ptr).button) as usize - ptr as usize },
         12usize,
         concat!(
             "Offset of field: ",
@@ -17413,9 +11556,7 @@ fn bindgen_test_layout_SDL_ControllerButtonEvent() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::core::ptr::null::<SDL_ControllerButtonEvent>())).state as *const _ as usize
-        },
+        unsafe { ::core::ptr::addr_of!((*ptr).state) as usize - ptr as usize },
         13usize,
         concat!(
             "Offset of field: ",
@@ -17425,9 +11566,7 @@ fn bindgen_test_layout_SDL_ControllerButtonEvent() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::core::ptr::null::<SDL_ControllerButtonEvent>())).padding1 as *const _ as usize
-        },
+        unsafe { ::core::ptr::addr_of!((*ptr).padding1) as usize - ptr as usize },
         14usize,
         concat!(
             "Offset of field: ",
@@ -17437,9 +11576,7 @@ fn bindgen_test_layout_SDL_ControllerButtonEvent() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::core::ptr::null::<SDL_ControllerButtonEvent>())).padding2 as *const _ as usize
-        },
+        unsafe { ::core::ptr::addr_of!((*ptr).padding2) as usize - ptr as usize },
         15usize,
         concat!(
             "Offset of field: ",
@@ -17462,6 +11599,9 @@ pub struct SDL_ControllerDeviceEvent {
 }
 #[test]
 fn bindgen_test_layout_SDL_ControllerDeviceEvent() {
+    const UNINIT: ::core::mem::MaybeUninit<SDL_ControllerDeviceEvent> =
+        ::core::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::core::mem::size_of::<SDL_ControllerDeviceEvent>(),
         12usize,
@@ -17473,9 +11613,7 @@ fn bindgen_test_layout_SDL_ControllerDeviceEvent() {
         concat!("Alignment of ", stringify!(SDL_ControllerDeviceEvent))
     );
     assert_eq!(
-        unsafe {
-            &(*(::core::ptr::null::<SDL_ControllerDeviceEvent>())).type_ as *const _ as usize
-        },
+        unsafe { ::core::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -17485,9 +11623,7 @@ fn bindgen_test_layout_SDL_ControllerDeviceEvent() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::core::ptr::null::<SDL_ControllerDeviceEvent>())).timestamp as *const _ as usize
-        },
+        unsafe { ::core::ptr::addr_of!((*ptr).timestamp) as usize - ptr as usize },
         4usize,
         concat!(
             "Offset of field: ",
@@ -17497,9 +11633,7 @@ fn bindgen_test_layout_SDL_ControllerDeviceEvent() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::core::ptr::null::<SDL_ControllerDeviceEvent>())).which as *const _ as usize
-        },
+        unsafe { ::core::ptr::addr_of!((*ptr).which) as usize - ptr as usize },
         8usize,
         concat!(
             "Offset of field: ",
@@ -17532,6 +11666,9 @@ pub struct SDL_ControllerTouchpadEvent {
 }
 #[test]
 fn bindgen_test_layout_SDL_ControllerTouchpadEvent() {
+    const UNINIT: ::core::mem::MaybeUninit<SDL_ControllerTouchpadEvent> =
+        ::core::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::core::mem::size_of::<SDL_ControllerTouchpadEvent>(),
         32usize,
@@ -17543,9 +11680,7 @@ fn bindgen_test_layout_SDL_ControllerTouchpadEvent() {
         concat!("Alignment of ", stringify!(SDL_ControllerTouchpadEvent))
     );
     assert_eq!(
-        unsafe {
-            &(*(::core::ptr::null::<SDL_ControllerTouchpadEvent>())).type_ as *const _ as usize
-        },
+        unsafe { ::core::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -17555,9 +11690,7 @@ fn bindgen_test_layout_SDL_ControllerTouchpadEvent() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::core::ptr::null::<SDL_ControllerTouchpadEvent>())).timestamp as *const _ as usize
-        },
+        unsafe { ::core::ptr::addr_of!((*ptr).timestamp) as usize - ptr as usize },
         4usize,
         concat!(
             "Offset of field: ",
@@ -17567,9 +11700,7 @@ fn bindgen_test_layout_SDL_ControllerTouchpadEvent() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::core::ptr::null::<SDL_ControllerTouchpadEvent>())).which as *const _ as usize
-        },
+        unsafe { ::core::ptr::addr_of!((*ptr).which) as usize - ptr as usize },
         8usize,
         concat!(
             "Offset of field: ",
@@ -17579,9 +11710,7 @@ fn bindgen_test_layout_SDL_ControllerTouchpadEvent() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::core::ptr::null::<SDL_ControllerTouchpadEvent>())).touchpad as *const _ as usize
-        },
+        unsafe { ::core::ptr::addr_of!((*ptr).touchpad) as usize - ptr as usize },
         12usize,
         concat!(
             "Offset of field: ",
@@ -17591,9 +11720,7 @@ fn bindgen_test_layout_SDL_ControllerTouchpadEvent() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::core::ptr::null::<SDL_ControllerTouchpadEvent>())).finger as *const _ as usize
-        },
+        unsafe { ::core::ptr::addr_of!((*ptr).finger) as usize - ptr as usize },
         16usize,
         concat!(
             "Offset of field: ",
@@ -17603,7 +11730,7 @@ fn bindgen_test_layout_SDL_ControllerTouchpadEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_ControllerTouchpadEvent>())).x as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).x) as usize - ptr as usize },
         20usize,
         concat!(
             "Offset of field: ",
@@ -17613,7 +11740,7 @@ fn bindgen_test_layout_SDL_ControllerTouchpadEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_ControllerTouchpadEvent>())).y as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).y) as usize - ptr as usize },
         24usize,
         concat!(
             "Offset of field: ",
@@ -17623,9 +11750,7 @@ fn bindgen_test_layout_SDL_ControllerTouchpadEvent() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::core::ptr::null::<SDL_ControllerTouchpadEvent>())).pressure as *const _ as usize
-        },
+        unsafe { ::core::ptr::addr_of!((*ptr).pressure) as usize - ptr as usize },
         28usize,
         concat!(
             "Offset of field: ",
@@ -17649,23 +11774,26 @@ pub struct SDL_ControllerSensorEvent {
     pub sensor: Sint32,
     #[doc = "< Up to 3 values from the sensor, as defined in SDL_sensor.h"]
     pub data: [f32; 3usize],
+    #[doc = "< The timestamp of the sensor reading in microseconds, if the hardware provides this information."]
+    pub timestamp_us: Uint64,
 }
 #[test]
 fn bindgen_test_layout_SDL_ControllerSensorEvent() {
+    const UNINIT: ::core::mem::MaybeUninit<SDL_ControllerSensorEvent> =
+        ::core::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::core::mem::size_of::<SDL_ControllerSensorEvent>(),
-        28usize,
+        40usize,
         concat!("Size of: ", stringify!(SDL_ControllerSensorEvent))
     );
     assert_eq!(
         ::core::mem::align_of::<SDL_ControllerSensorEvent>(),
-        4usize,
+        8usize,
         concat!("Alignment of ", stringify!(SDL_ControllerSensorEvent))
     );
     assert_eq!(
-        unsafe {
-            &(*(::core::ptr::null::<SDL_ControllerSensorEvent>())).type_ as *const _ as usize
-        },
+        unsafe { ::core::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -17675,9 +11803,7 @@ fn bindgen_test_layout_SDL_ControllerSensorEvent() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::core::ptr::null::<SDL_ControllerSensorEvent>())).timestamp as *const _ as usize
-        },
+        unsafe { ::core::ptr::addr_of!((*ptr).timestamp) as usize - ptr as usize },
         4usize,
         concat!(
             "Offset of field: ",
@@ -17687,9 +11813,7 @@ fn bindgen_test_layout_SDL_ControllerSensorEvent() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::core::ptr::null::<SDL_ControllerSensorEvent>())).which as *const _ as usize
-        },
+        unsafe { ::core::ptr::addr_of!((*ptr).which) as usize - ptr as usize },
         8usize,
         concat!(
             "Offset of field: ",
@@ -17699,9 +11823,7 @@ fn bindgen_test_layout_SDL_ControllerSensorEvent() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::core::ptr::null::<SDL_ControllerSensorEvent>())).sensor as *const _ as usize
-        },
+        unsafe { ::core::ptr::addr_of!((*ptr).sensor) as usize - ptr as usize },
         12usize,
         concat!(
             "Offset of field: ",
@@ -17711,7 +11833,7 @@ fn bindgen_test_layout_SDL_ControllerSensorEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_ControllerSensorEvent>())).data as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
         16usize,
         concat!(
             "Offset of field: ",
@@ -17720,6 +11842,16 @@ fn bindgen_test_layout_SDL_ControllerSensorEvent() {
             stringify!(data)
         )
     );
+    assert_eq!(
+        unsafe { ::core::ptr::addr_of!((*ptr).timestamp_us) as usize - ptr as usize },
+        32usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(SDL_ControllerSensorEvent),
+            "::",
+            stringify!(timestamp_us)
+        )
+    );
 }
 #[doc = "  \\brief Audio device event structure (event.adevice.*)"]
 #[repr(C)]
@@ -17739,6 +11871,9 @@ pub struct SDL_AudioDeviceEvent {
 }
 #[test]
 fn bindgen_test_layout_SDL_AudioDeviceEvent() {
+    const UNINIT: ::core::mem::MaybeUninit<SDL_AudioDeviceEvent> =
+        ::core::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::core::mem::size_of::<SDL_AudioDeviceEvent>(),
         16usize,
@@ -17750,7 +11885,7 @@ fn bindgen_test_layout_SDL_AudioDeviceEvent() {
         concat!("Alignment of ", stringify!(SDL_AudioDeviceEvent))
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_AudioDeviceEvent>())).type_ as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -17760,7 +11895,7 @@ fn bindgen_test_layout_SDL_AudioDeviceEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_AudioDeviceEvent>())).timestamp as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).timestamp) as usize - ptr as usize },
         4usize,
         concat!(
             "Offset of field: ",
@@ -17770,7 +11905,7 @@ fn bindgen_test_layout_SDL_AudioDeviceEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_AudioDeviceEvent>())).which as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).which) as usize - ptr as usize },
         8usize,
         concat!(
             "Offset of field: ",
@@ -17780,7 +11915,7 @@ fn bindgen_test_layout_SDL_AudioDeviceEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_AudioDeviceEvent>())).iscapture as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).iscapture) as usize - ptr as usize },
         12usize,
         concat!(
             "Offset of field: ",
@@ -17790,7 +11925,7 @@ fn bindgen_test_layout_SDL_AudioDeviceEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_AudioDeviceEvent>())).padding1 as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).padding1) as usize - ptr as usize },
         13usize,
         concat!(
             "Offset of field: ",
@@ -17800,7 +11935,7 @@ fn bindgen_test_layout_SDL_AudioDeviceEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_AudioDeviceEvent>())).padding2 as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).padding2) as usize - ptr as usize },
         14usize,
         concat!(
             "Offset of field: ",
@@ -17810,7 +11945,7 @@ fn bindgen_test_layout_SDL_AudioDeviceEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_AudioDeviceEvent>())).padding3 as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).padding3) as usize - ptr as usize },
         15usize,
         concat!(
             "Offset of field: ",
@@ -17846,6 +11981,9 @@ pub struct SDL_TouchFingerEvent {
 }
 #[test]
 fn bindgen_test_layout_SDL_TouchFingerEvent() {
+    const UNINIT: ::core::mem::MaybeUninit<SDL_TouchFingerEvent> =
+        ::core::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::core::mem::size_of::<SDL_TouchFingerEvent>(),
         48usize,
@@ -17857,7 +11995,7 @@ fn bindgen_test_layout_SDL_TouchFingerEvent() {
         concat!("Alignment of ", stringify!(SDL_TouchFingerEvent))
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_TouchFingerEvent>())).type_ as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -17867,7 +12005,7 @@ fn bindgen_test_layout_SDL_TouchFingerEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_TouchFingerEvent>())).timestamp as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).timestamp) as usize - ptr as usize },
         4usize,
         concat!(
             "Offset of field: ",
@@ -17877,7 +12015,7 @@ fn bindgen_test_layout_SDL_TouchFingerEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_TouchFingerEvent>())).touchId as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).touchId) as usize - ptr as usize },
         8usize,
         concat!(
             "Offset of field: ",
@@ -17887,7 +12025,7 @@ fn bindgen_test_layout_SDL_TouchFingerEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_TouchFingerEvent>())).fingerId as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).fingerId) as usize - ptr as usize },
         16usize,
         concat!(
             "Offset of field: ",
@@ -17897,7 +12035,7 @@ fn bindgen_test_layout_SDL_TouchFingerEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_TouchFingerEvent>())).x as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).x) as usize - ptr as usize },
         24usize,
         concat!(
             "Offset of field: ",
@@ -17907,7 +12045,7 @@ fn bindgen_test_layout_SDL_TouchFingerEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_TouchFingerEvent>())).y as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).y) as usize - ptr as usize },
         28usize,
         concat!(
             "Offset of field: ",
@@ -17917,7 +12055,7 @@ fn bindgen_test_layout_SDL_TouchFingerEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_TouchFingerEvent>())).dx as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).dx) as usize - ptr as usize },
         32usize,
         concat!(
             "Offset of field: ",
@@ -17927,7 +12065,7 @@ fn bindgen_test_layout_SDL_TouchFingerEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_TouchFingerEvent>())).dy as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).dy) as usize - ptr as usize },
         36usize,
         concat!(
             "Offset of field: ",
@@ -17937,7 +12075,7 @@ fn bindgen_test_layout_SDL_TouchFingerEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_TouchFingerEvent>())).pressure as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).pressure) as usize - ptr as usize },
         40usize,
         concat!(
             "Offset of field: ",
@@ -17947,7 +12085,7 @@ fn bindgen_test_layout_SDL_TouchFingerEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_TouchFingerEvent>())).windowID as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).windowID) as usize - ptr as usize },
         44usize,
         concat!(
             "Offset of field: ",
@@ -17976,6 +12114,9 @@ pub struct SDL_MultiGestureEvent {
 }
 #[test]
 fn bindgen_test_layout_SDL_MultiGestureEvent() {
+    const UNINIT: ::core::mem::MaybeUninit<SDL_MultiGestureEvent> =
+        ::core::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::core::mem::size_of::<SDL_MultiGestureEvent>(),
         40usize,
@@ -17987,7 +12128,7 @@ fn bindgen_test_layout_SDL_MultiGestureEvent() {
         concat!("Alignment of ", stringify!(SDL_MultiGestureEvent))
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_MultiGestureEvent>())).type_ as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -17997,9 +12138,7 @@ fn bindgen_test_layout_SDL_MultiGestureEvent() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::core::ptr::null::<SDL_MultiGestureEvent>())).timestamp as *const _ as usize
-        },
+        unsafe { ::core::ptr::addr_of!((*ptr).timestamp) as usize - ptr as usize },
         4usize,
         concat!(
             "Offset of field: ",
@@ -18009,7 +12148,7 @@ fn bindgen_test_layout_SDL_MultiGestureEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_MultiGestureEvent>())).touchId as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).touchId) as usize - ptr as usize },
         8usize,
         concat!(
             "Offset of field: ",
@@ -18019,7 +12158,7 @@ fn bindgen_test_layout_SDL_MultiGestureEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_MultiGestureEvent>())).dTheta as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).dTheta) as usize - ptr as usize },
         16usize,
         concat!(
             "Offset of field: ",
@@ -18029,7 +12168,7 @@ fn bindgen_test_layout_SDL_MultiGestureEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_MultiGestureEvent>())).dDist as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).dDist) as usize - ptr as usize },
         20usize,
         concat!(
             "Offset of field: ",
@@ -18039,7 +12178,7 @@ fn bindgen_test_layout_SDL_MultiGestureEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_MultiGestureEvent>())).x as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).x) as usize - ptr as usize },
         24usize,
         concat!(
             "Offset of field: ",
@@ -18049,7 +12188,7 @@ fn bindgen_test_layout_SDL_MultiGestureEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_MultiGestureEvent>())).y as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).y) as usize - ptr as usize },
         28usize,
         concat!(
             "Offset of field: ",
@@ -18059,9 +12198,7 @@ fn bindgen_test_layout_SDL_MultiGestureEvent() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::core::ptr::null::<SDL_MultiGestureEvent>())).numFingers as *const _ as usize
-        },
+        unsafe { ::core::ptr::addr_of!((*ptr).numFingers) as usize - ptr as usize },
         32usize,
         concat!(
             "Offset of field: ",
@@ -18071,7 +12208,7 @@ fn bindgen_test_layout_SDL_MultiGestureEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_MultiGestureEvent>())).padding as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).padding) as usize - ptr as usize },
         34usize,
         concat!(
             "Offset of field: ",
@@ -18101,6 +12238,9 @@ pub struct SDL_DollarGestureEvent {
 }
 #[test]
 fn bindgen_test_layout_SDL_DollarGestureEvent() {
+    const UNINIT: ::core::mem::MaybeUninit<SDL_DollarGestureEvent> =
+        ::core::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::core::mem::size_of::<SDL_DollarGestureEvent>(),
         40usize,
@@ -18112,7 +12252,7 @@ fn bindgen_test_layout_SDL_DollarGestureEvent() {
         concat!("Alignment of ", stringify!(SDL_DollarGestureEvent))
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_DollarGestureEvent>())).type_ as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -18122,9 +12262,7 @@ fn bindgen_test_layout_SDL_DollarGestureEvent() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::core::ptr::null::<SDL_DollarGestureEvent>())).timestamp as *const _ as usize
-        },
+        unsafe { ::core::ptr::addr_of!((*ptr).timestamp) as usize - ptr as usize },
         4usize,
         concat!(
             "Offset of field: ",
@@ -18134,7 +12272,7 @@ fn bindgen_test_layout_SDL_DollarGestureEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_DollarGestureEvent>())).touchId as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).touchId) as usize - ptr as usize },
         8usize,
         concat!(
             "Offset of field: ",
@@ -18144,9 +12282,7 @@ fn bindgen_test_layout_SDL_DollarGestureEvent() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::core::ptr::null::<SDL_DollarGestureEvent>())).gestureId as *const _ as usize
-        },
+        unsafe { ::core::ptr::addr_of!((*ptr).gestureId) as usize - ptr as usize },
         16usize,
         concat!(
             "Offset of field: ",
@@ -18156,9 +12292,7 @@ fn bindgen_test_layout_SDL_DollarGestureEvent() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::core::ptr::null::<SDL_DollarGestureEvent>())).numFingers as *const _ as usize
-        },
+        unsafe { ::core::ptr::addr_of!((*ptr).numFingers) as usize - ptr as usize },
         24usize,
         concat!(
             "Offset of field: ",
@@ -18168,7 +12302,7 @@ fn bindgen_test_layout_SDL_DollarGestureEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_DollarGestureEvent>())).error as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).error) as usize - ptr as usize },
         28usize,
         concat!(
             "Offset of field: ",
@@ -18178,7 +12312,7 @@ fn bindgen_test_layout_SDL_DollarGestureEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_DollarGestureEvent>())).x as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).x) as usize - ptr as usize },
         32usize,
         concat!(
             "Offset of field: ",
@@ -18188,7 +12322,7 @@ fn bindgen_test_layout_SDL_DollarGestureEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_DollarGestureEvent>())).y as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).y) as usize - ptr as usize },
         36usize,
         concat!(
             "Offset of field: ",
@@ -18198,9 +12332,7 @@ fn bindgen_test_layout_SDL_DollarGestureEvent() {
         )
     );
 }
-#[doc = "  \\brief An event used to request a file open by the system (event.drop.*)"]
-#[doc = "         This event is enabled by default, you can disable it with SDL_EventState()."]
-#[doc = "  \\note If this event is enabled, you must free the filename in the event."]
+#[doc = "  \\brief An event used to request a file open by the system (event.drop.*)\n         This event is enabled by default, you can disable it with SDL_EventState().\n  \\note If this event is enabled, you must free the filename in the event."]
 #[repr(C)]
 #[derive(Copy, Clone)]
 pub struct SDL_DropEvent {
@@ -18215,6 +12347,8 @@ pub struct SDL_DropEvent {
 }
 #[test]
 fn bindgen_test_layout_SDL_DropEvent() {
+    const UNINIT: ::core::mem::MaybeUninit<SDL_DropEvent> = ::core::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::core::mem::size_of::<SDL_DropEvent>(),
         24usize,
@@ -18226,7 +12360,7 @@ fn bindgen_test_layout_SDL_DropEvent() {
         concat!("Alignment of ", stringify!(SDL_DropEvent))
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_DropEvent>())).type_ as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -18236,7 +12370,7 @@ fn bindgen_test_layout_SDL_DropEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_DropEvent>())).timestamp as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).timestamp) as usize - ptr as usize },
         4usize,
         concat!(
             "Offset of field: ",
@@ -18246,7 +12380,7 @@ fn bindgen_test_layout_SDL_DropEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_DropEvent>())).file as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).file) as usize - ptr as usize },
         8usize,
         concat!(
             "Offset of field: ",
@@ -18256,7 +12390,7 @@ fn bindgen_test_layout_SDL_DropEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_DropEvent>())).windowID as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).windowID) as usize - ptr as usize },
         16usize,
         concat!(
             "Offset of field: ",
@@ -18278,21 +12412,25 @@ pub struct SDL_SensorEvent {
     pub which: Sint32,
     #[doc = "< Up to 6 values from the sensor - additional values can be queried using SDL_SensorGetData()"]
     pub data: [f32; 6usize],
+    #[doc = "< The timestamp of the sensor reading in microseconds, if the hardware provides this information."]
+    pub timestamp_us: Uint64,
 }
 #[test]
 fn bindgen_test_layout_SDL_SensorEvent() {
+    const UNINIT: ::core::mem::MaybeUninit<SDL_SensorEvent> = ::core::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::core::mem::size_of::<SDL_SensorEvent>(),
-        36usize,
+        48usize,
         concat!("Size of: ", stringify!(SDL_SensorEvent))
     );
     assert_eq!(
         ::core::mem::align_of::<SDL_SensorEvent>(),
-        4usize,
+        8usize,
         concat!("Alignment of ", stringify!(SDL_SensorEvent))
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_SensorEvent>())).type_ as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -18302,7 +12440,7 @@ fn bindgen_test_layout_SDL_SensorEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_SensorEvent>())).timestamp as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).timestamp) as usize - ptr as usize },
         4usize,
         concat!(
             "Offset of field: ",
@@ -18312,7 +12450,7 @@ fn bindgen_test_layout_SDL_SensorEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_SensorEvent>())).which as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).which) as usize - ptr as usize },
         8usize,
         concat!(
             "Offset of field: ",
@@ -18322,7 +12460,7 @@ fn bindgen_test_layout_SDL_SensorEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_SensorEvent>())).data as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
         12usize,
         concat!(
             "Offset of field: ",
@@ -18331,6 +12469,16 @@ fn bindgen_test_layout_SDL_SensorEvent() {
             stringify!(data)
         )
     );
+    assert_eq!(
+        unsafe { ::core::ptr::addr_of!((*ptr).timestamp_us) as usize - ptr as usize },
+        40usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(SDL_SensorEvent),
+            "::",
+            stringify!(timestamp_us)
+        )
+    );
 }
 #[doc = "  \\brief The \"quit requested\" event"]
 #[repr(C)]
@@ -18343,6 +12491,8 @@ pub struct SDL_QuitEvent {
 }
 #[test]
 fn bindgen_test_layout_SDL_QuitEvent() {
+    const UNINIT: ::core::mem::MaybeUninit<SDL_QuitEvent> = ::core::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::core::mem::size_of::<SDL_QuitEvent>(),
         8usize,
@@ -18354,7 +12504,7 @@ fn bindgen_test_layout_SDL_QuitEvent() {
         concat!("Alignment of ", stringify!(SDL_QuitEvent))
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_QuitEvent>())).type_ as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -18364,7 +12514,7 @@ fn bindgen_test_layout_SDL_QuitEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_QuitEvent>())).timestamp as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).timestamp) as usize - ptr as usize },
         4usize,
         concat!(
             "Offset of field: ",
@@ -18385,6 +12535,8 @@ pub struct SDL_OSEvent {
 }
 #[test]
 fn bindgen_test_layout_SDL_OSEvent() {
+    const UNINIT: ::core::mem::MaybeUninit<SDL_OSEvent> = ::core::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::core::mem::size_of::<SDL_OSEvent>(),
         8usize,
@@ -18396,7 +12548,7 @@ fn bindgen_test_layout_SDL_OSEvent() {
         concat!("Alignment of ", stringify!(SDL_OSEvent))
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_OSEvent>())).type_ as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -18406,7 +12558,7 @@ fn bindgen_test_layout_SDL_OSEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_OSEvent>())).timestamp as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).timestamp) as usize - ptr as usize },
         4usize,
         concat!(
             "Offset of field: ",
@@ -18435,6 +12587,8 @@ pub struct SDL_UserEvent {
 }
 #[test]
 fn bindgen_test_layout_SDL_UserEvent() {
+    const UNINIT: ::core::mem::MaybeUninit<SDL_UserEvent> = ::core::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::core::mem::size_of::<SDL_UserEvent>(),
         32usize,
@@ -18446,7 +12600,7 @@ fn bindgen_test_layout_SDL_UserEvent() {
         concat!("Alignment of ", stringify!(SDL_UserEvent))
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_UserEvent>())).type_ as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -18456,7 +12610,7 @@ fn bindgen_test_layout_SDL_UserEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_UserEvent>())).timestamp as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).timestamp) as usize - ptr as usize },
         4usize,
         concat!(
             "Offset of field: ",
@@ -18466,7 +12620,7 @@ fn bindgen_test_layout_SDL_UserEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_UserEvent>())).windowID as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).windowID) as usize - ptr as usize },
         8usize,
         concat!(
             "Offset of field: ",
@@ -18476,7 +12630,7 @@ fn bindgen_test_layout_SDL_UserEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_UserEvent>())).code as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).code) as usize - ptr as usize },
         12usize,
         concat!(
             "Offset of field: ",
@@ -18486,7 +12640,7 @@ fn bindgen_test_layout_SDL_UserEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_UserEvent>())).data1 as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).data1) as usize - ptr as usize },
         16usize,
         concat!(
             "Offset of field: ",
@@ -18496,7 +12650,7 @@ fn bindgen_test_layout_SDL_UserEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_UserEvent>())).data2 as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).data2) as usize - ptr as usize },
         24usize,
         concat!(
             "Offset of field: ",
@@ -18506,10 +12660,7 @@ fn bindgen_test_layout_SDL_UserEvent() {
         )
     );
 }
-#[doc = "  \\brief A video driver dependent system event (event.syswm.*)"]
-#[doc = "         This event is disabled by default, you can enable it with SDL_EventState()"]
-#[doc = ""]
-#[doc = "  \\note If you want to use this event, you should include SDL_syswm.h."]
+#[doc = "  \\brief A video driver dependent system event (event.syswm.*)\n         This event is disabled by default, you can enable it with SDL_EventState()\n\n  \\note If you want to use this event, you should include SDL_syswm.h."]
 #[repr(C)]
 #[derive(Copy, Clone)]
 pub struct SDL_SysWMEvent {
@@ -18522,6 +12673,8 @@ pub struct SDL_SysWMEvent {
 }
 #[test]
 fn bindgen_test_layout_SDL_SysWMEvent() {
+    const UNINIT: ::core::mem::MaybeUninit<SDL_SysWMEvent> = ::core::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::core::mem::size_of::<SDL_SysWMEvent>(),
         16usize,
@@ -18533,7 +12686,7 @@ fn bindgen_test_layout_SDL_SysWMEvent() {
         concat!("Alignment of ", stringify!(SDL_SysWMEvent))
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_SysWMEvent>())).type_ as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -18543,7 +12696,7 @@ fn bindgen_test_layout_SDL_SysWMEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_SysWMEvent>())).timestamp as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).timestamp) as usize - ptr as usize },
         4usize,
         concat!(
             "Offset of field: ",
@@ -18553,7 +12706,7 @@ fn bindgen_test_layout_SDL_SysWMEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_SysWMEvent>())).msg as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).msg) as usize - ptr as usize },
         8usize,
         concat!(
             "Offset of field: ",
@@ -18579,6 +12732,8 @@ pub union SDL_Event {
     pub key: SDL_KeyboardEvent,
     #[doc = "< Text editing event data"]
     pub edit: SDL_TextEditingEvent,
+    #[doc = "< Extended text editing event data"]
+    pub editExt: SDL_TextEditingExtEvent,
     #[doc = "< Text input event data"]
     pub text: SDL_TextInputEvent,
     #[doc = "< Mouse motion event data"]
@@ -18597,6 +12752,8 @@ pub union SDL_Event {
     pub jbutton: SDL_JoyButtonEvent,
     #[doc = "< Joystick device change event data"]
     pub jdevice: SDL_JoyDeviceEvent,
+    #[doc = "< Joystick battery event data"]
+    pub jbattery: SDL_JoyBatteryEvent,
     #[doc = "< Game Controller axis event data"]
     pub caxis: SDL_ControllerAxisEvent,
     #[doc = "< Game Controller button event data"]
@@ -18626,10 +12783,11 @@ pub union SDL_Event {
     #[doc = "< Drag and drop event data"]
     pub drop: SDL_DropEvent,
     pub padding: [Uint8; 56usize],
-    _bindgen_union_align: [u64; 7usize],
 }
 #[test]
 fn bindgen_test_layout_SDL_Event() {
+    const UNINIT: ::core::mem::MaybeUninit<SDL_Event> = ::core::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::core::mem::size_of::<SDL_Event>(),
         56usize,
@@ -18641,7 +12799,7 @@ fn bindgen_test_layout_SDL_Event() {
         concat!("Alignment of ", stringify!(SDL_Event))
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_Event>())).type_ as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -18651,7 +12809,7 @@ fn bindgen_test_layout_SDL_Event() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_Event>())).common as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).common) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -18661,7 +12819,7 @@ fn bindgen_test_layout_SDL_Event() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_Event>())).display as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).display) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -18671,7 +12829,7 @@ fn bindgen_test_layout_SDL_Event() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_Event>())).window as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).window) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -18681,7 +12839,7 @@ fn bindgen_test_layout_SDL_Event() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_Event>())).key as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).key) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -18691,7 +12849,7 @@ fn bindgen_test_layout_SDL_Event() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_Event>())).edit as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).edit) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -18701,7 +12859,17 @@ fn bindgen_test_layout_SDL_Event() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_Event>())).text as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).editExt) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(SDL_Event),
+            "::",
+            stringify!(editExt)
+        )
+    );
+    assert_eq!(
+        unsafe { ::core::ptr::addr_of!((*ptr).text) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -18711,7 +12879,7 @@ fn bindgen_test_layout_SDL_Event() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_Event>())).motion as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).motion) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -18721,7 +12889,7 @@ fn bindgen_test_layout_SDL_Event() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_Event>())).button as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).button) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -18731,7 +12899,7 @@ fn bindgen_test_layout_SDL_Event() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_Event>())).wheel as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).wheel) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -18741,7 +12909,7 @@ fn bindgen_test_layout_SDL_Event() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_Event>())).jaxis as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).jaxis) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -18751,7 +12919,7 @@ fn bindgen_test_layout_SDL_Event() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_Event>())).jball as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).jball) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -18761,7 +12929,7 @@ fn bindgen_test_layout_SDL_Event() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_Event>())).jhat as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).jhat) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -18771,7 +12939,7 @@ fn bindgen_test_layout_SDL_Event() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_Event>())).jbutton as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).jbutton) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -18781,7 +12949,7 @@ fn bindgen_test_layout_SDL_Event() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_Event>())).jdevice as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).jdevice) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -18791,7 +12959,17 @@ fn bindgen_test_layout_SDL_Event() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_Event>())).caxis as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).jbattery) as usize - ptr as usize },
+        0usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(SDL_Event),
+            "::",
+            stringify!(jbattery)
+        )
+    );
+    assert_eq!(
+        unsafe { ::core::ptr::addr_of!((*ptr).caxis) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -18801,7 +12979,7 @@ fn bindgen_test_layout_SDL_Event() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_Event>())).cbutton as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).cbutton) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -18811,7 +12989,7 @@ fn bindgen_test_layout_SDL_Event() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_Event>())).cdevice as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).cdevice) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -18821,7 +12999,7 @@ fn bindgen_test_layout_SDL_Event() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_Event>())).ctouchpad as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).ctouchpad) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -18831,7 +13009,7 @@ fn bindgen_test_layout_SDL_Event() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_Event>())).csensor as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).csensor) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -18841,7 +13019,7 @@ fn bindgen_test_layout_SDL_Event() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_Event>())).adevice as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).adevice) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -18851,7 +13029,7 @@ fn bindgen_test_layout_SDL_Event() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_Event>())).sensor as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).sensor) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -18861,7 +13039,7 @@ fn bindgen_test_layout_SDL_Event() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_Event>())).quit as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).quit) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -18871,7 +13049,7 @@ fn bindgen_test_layout_SDL_Event() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_Event>())).user as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).user) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -18881,7 +13059,7 @@ fn bindgen_test_layout_SDL_Event() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_Event>())).syswm as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).syswm) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -18891,7 +13069,7 @@ fn bindgen_test_layout_SDL_Event() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_Event>())).tfinger as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).tfinger) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -18901,7 +13079,7 @@ fn bindgen_test_layout_SDL_Event() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_Event>())).mgesture as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).mgesture) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -18911,7 +13089,7 @@ fn bindgen_test_layout_SDL_Event() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_Event>())).dgesture as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).dgesture) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -18921,7 +13099,7 @@ fn bindgen_test_layout_SDL_Event() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_Event>())).drop as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).drop) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -18931,7 +13109,7 @@ fn bindgen_test_layout_SDL_Event() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_Event>())).padding as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).padding) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -18941,74 +13119,19 @@ fn bindgen_test_layout_SDL_Event() {
         )
     );
 }
-pub type SDL_compile_time_assert_SDL_Event = [libc::c_int; 1usize];
-extern "C" {
-    #[doc = " Pump the event loop, gathering events from the input devices."]
-    #[doc = ""]
-    #[doc = " This function updates the event queue and internal input device state."]
-    #[doc = ""]
-    #[doc = " **WARNING**: This should only be run in the thread that initialized the"]
-    #[doc = " video subsystem, and for extra safety, you should consider only doing those"]
-    #[doc = " things on the main thread in any case."]
-    #[doc = ""]
-    #[doc = " SDL_PumpEvents() gathers all the pending input information from devices and"]
-    #[doc = " places it in the event queue. Without calls to SDL_PumpEvents() no events"]
-    #[doc = " would ever be placed on the queue. Often the need for calls to"]
-    #[doc = " SDL_PumpEvents() is hidden from the user since SDL_PollEvent() and"]
-    #[doc = " SDL_WaitEvent() implicitly call SDL_PumpEvents(). However, if you are not"]
-    #[doc = " polling or waiting for events (e.g. you are filtering them), then you must"]
-    #[doc = " call SDL_PumpEvents() to force an event queue update."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_PollEvent"]
-    #[doc = " \\sa SDL_WaitEvent"]
+extern "C" {
+    #[doc = " Pump the event loop, gathering events from the input devices.\n\n This function updates the event queue and internal input device state.\n\n **WARNING**: This should only be run in the thread that initialized the\n video subsystem, and for extra safety, you should consider only doing those\n things on the main thread in any case.\n\n SDL_PumpEvents() gathers all the pending input information from devices and\n places it in the event queue. Without calls to SDL_PumpEvents() no events\n would ever be placed on the queue. Often the need for calls to\n SDL_PumpEvents() is hidden from the user since SDL_PollEvent() and\n SDL_WaitEvent() implicitly call SDL_PumpEvents(). However, if you are not\n polling or waiting for events (e.g. you are filtering them), then you must\n call SDL_PumpEvents() to force an event queue update.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_PollEvent\n \\sa SDL_WaitEvent"]
     pub fn SDL_PumpEvents();
 }
 #[repr(u32)]
-#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
+#[derive(Copy, Clone, Hash, PartialEq, Eq)]
 pub enum SDL_eventaction {
     SDL_ADDEVENT = 0,
     SDL_PEEKEVENT = 1,
     SDL_GETEVENT = 2,
 }
 extern "C" {
-    #[doc = " Check the event queue for messages and optionally return them."]
-    #[doc = ""]
-    #[doc = " `action` may be any of the following:"]
-    #[doc = ""]
-    #[doc = " - `SDL_ADDEVENT`: up to `numevents` events will be added to the back of the"]
-    #[doc = "   event queue."]
-    #[doc = " - `SDL_PEEKEVENT`: `numevents` events at the front of the event queue,"]
-    #[doc = "   within the specified minimum and maximum type, will be returned to the"]
-    #[doc = "   caller and will _not_ be removed from the queue."]
-    #[doc = " - `SDL_GETEVENT`: up to `numevents` events at the front of the event queue,"]
-    #[doc = "   within the specified minimum and maximum type, will be returned to the"]
-    #[doc = "   caller and will be removed from the queue."]
-    #[doc = ""]
-    #[doc = " You may have to call SDL_PumpEvents() before calling this function."]
-    #[doc = " Otherwise, the events may not be ready to be filtered when you call"]
-    #[doc = " SDL_PeepEvents()."]
-    #[doc = ""]
-    #[doc = " This function is thread-safe."]
-    #[doc = ""]
-    #[doc = " \\param events destination buffer for the retrieved events"]
-    #[doc = " \\param numevents if action is SDL_ADDEVENT, the number of events to add"]
-    #[doc = "                  back to the event queue; if action is SDL_PEEKEVENT or"]
-    #[doc = "                  SDL_GETEVENT, the maximum number of events to retrieve"]
-    #[doc = " \\param action action to take; see [[#action|Remarks]] for details"]
-    #[doc = " \\param minType minimum value of the event type to be considered;"]
-    #[doc = "                SDL_FIRSTEVENT is a safe choice"]
-    #[doc = " \\param maxType maximum value of the event type to be considered;"]
-    #[doc = "                SDL_LASTEVENT is a safe choice"]
-    #[doc = " \\returns the number of events actually stored or a negative error code on"]
-    #[doc = "          failure; call SDL_GetError() for more information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_PollEvent"]
-    #[doc = " \\sa SDL_PumpEvents"]
-    #[doc = " \\sa SDL_PushEvent"]
+    #[doc = " Check the event queue for messages and optionally return them.\n\n `action` may be any of the following:\n\n - `SDL_ADDEVENT`: up to `numevents` events will be added to the back of the\n   event queue.\n - `SDL_PEEKEVENT`: `numevents` events at the front of the event queue,\n   within the specified minimum and maximum type, will be returned to the\n   caller and will _not_ be removed from the queue.\n - `SDL_GETEVENT`: up to `numevents` events at the front of the event queue,\n   within the specified minimum and maximum type, will be returned to the\n   caller and will be removed from the queue.\n\n You may have to call SDL_PumpEvents() before calling this function.\n Otherwise, the events may not be ready to be filtered when you call\n SDL_PeepEvents().\n\n This function is thread-safe.\n\n \\param events destination buffer for the retrieved events\n \\param numevents if action is SDL_ADDEVENT, the number of events to add\n                  back to the event queue; if action is SDL_PEEKEVENT or\n                  SDL_GETEVENT, the maximum number of events to retrieve\n \\param action action to take; see [[#action|Remarks]] for details\n \\param minType minimum value of the event type to be considered;\n                SDL_FIRSTEVENT is a safe choice\n \\param maxType maximum value of the event type to be considered;\n                SDL_LASTEVENT is a safe choice\n \\returns the number of events actually stored or a negative error code on\n          failure; call SDL_GetError() for more information.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_PollEvent\n \\sa SDL_PumpEvents\n \\sa SDL_PushEvent"]
     pub fn SDL_PeepEvents(
         events: *mut SDL_Event,
         numevents: libc::c_int,
@@ -19018,582 +13141,89 @@ extern "C" {
     ) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Check for the existence of a certain event type in the event queue."]
-    #[doc = ""]
-    #[doc = " If you need to check for a range of event types, use SDL_HasEvents()"]
-    #[doc = " instead."]
-    #[doc = ""]
-    #[doc = " \\param type the type of event to be queried; see SDL_EventType for details"]
-    #[doc = " \\returns SDL_TRUE if events matching `type` are present, or SDL_FALSE if"]
-    #[doc = "          events matching `type` are not present."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_HasEvents"]
+    #[doc = " Check for the existence of a certain event type in the event queue.\n\n If you need to check for a range of event types, use SDL_HasEvents()\n instead.\n\n \\param type the type of event to be queried; see SDL_EventType for details\n \\returns SDL_TRUE if events matching `type` are present, or SDL_FALSE if\n          events matching `type` are not present.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_HasEvents"]
     pub fn SDL_HasEvent(type_: Uint32) -> SDL_bool;
 }
 extern "C" {
-    #[doc = " Check for the existence of certain event types in the event queue."]
-    #[doc = ""]
-    #[doc = " If you need to check for a single event type, use SDL_HasEvent() instead."]
-    #[doc = ""]
-    #[doc = " \\param minType the low end of event type to be queried, inclusive; see"]
-    #[doc = "                SDL_EventType for details"]
-    #[doc = " \\param maxType the high end of event type to be queried, inclusive; see"]
-    #[doc = "                SDL_EventType for details"]
-    #[doc = " \\returns SDL_TRUE if events with type >= `minType` and <= `maxType` are"]
-    #[doc = "          present, or SDL_FALSE if not."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_HasEvents"]
+    #[doc = " Check for the existence of certain event types in the event queue.\n\n If you need to check for a single event type, use SDL_HasEvent() instead.\n\n \\param minType the low end of event type to be queried, inclusive; see\n                SDL_EventType for details\n \\param maxType the high end of event type to be queried, inclusive; see\n                SDL_EventType for details\n \\returns SDL_TRUE if events with type >= `minType` and <= `maxType` are\n          present, or SDL_FALSE if not.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_HasEvents"]
     pub fn SDL_HasEvents(minType: Uint32, maxType: Uint32) -> SDL_bool;
 }
 extern "C" {
-    #[doc = " Clear events of a specific type from the event queue."]
-    #[doc = ""]
-    #[doc = " This will unconditionally remove any events from the queue that match"]
-    #[doc = " `type`. If you need to remove a range of event types, use SDL_FlushEvents()"]
-    #[doc = " instead."]
-    #[doc = ""]
-    #[doc = " It's also normal to just ignore events you don't care about in your event"]
-    #[doc = " loop without calling this function."]
-    #[doc = ""]
-    #[doc = " This function only affects currently queued events. If you want to make"]
-    #[doc = " sure that all pending OS events are flushed, you can call SDL_PumpEvents()"]
-    #[doc = " on the main thread immediately before the flush call."]
-    #[doc = ""]
-    #[doc = " \\param type the type of event to be cleared; see SDL_EventType for details"]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_FlushEvents"]
+    #[doc = " Clear events of a specific type from the event queue.\n\n This will unconditionally remove any events from the queue that match\n `type`. If you need to remove a range of event types, use SDL_FlushEvents()\n instead.\n\n It's also normal to just ignore events you don't care about in your event\n loop without calling this function.\n\n This function only affects currently queued events. If you want to make\n sure that all pending OS events are flushed, you can call SDL_PumpEvents()\n on the main thread immediately before the flush call.\n\n \\param type the type of event to be cleared; see SDL_EventType for details\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_FlushEvents"]
     pub fn SDL_FlushEvent(type_: Uint32);
 }
 extern "C" {
-    #[doc = " Clear events of a range of types from the event queue."]
-    #[doc = ""]
-    #[doc = " This will unconditionally remove any events from the queue that are in the"]
-    #[doc = " range of `minType` to `maxType`, inclusive. If you need to remove a single"]
-    #[doc = " event type, use SDL_FlushEvent() instead."]
-    #[doc = ""]
-    #[doc = " It's also normal to just ignore events you don't care about in your event"]
-    #[doc = " loop without calling this function."]
-    #[doc = ""]
-    #[doc = " This function only affects currently queued events. If you want to make"]
-    #[doc = " sure that all pending OS events are flushed, you can call SDL_PumpEvents()"]
-    #[doc = " on the main thread immediately before the flush call."]
-    #[doc = ""]
-    #[doc = " \\param minType the low end of event type to be cleared, inclusive; see"]
-    #[doc = "                SDL_EventType for details"]
-    #[doc = " \\param maxType the high end of event type to be cleared, inclusive; see"]
-    #[doc = "                SDL_EventType for details"]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_FlushEvent"]
+    #[doc = " Clear events of a range of types from the event queue.\n\n This will unconditionally remove any events from the queue that are in the\n range of `minType` to `maxType`, inclusive. If you need to remove a single\n event type, use SDL_FlushEvent() instead.\n\n It's also normal to just ignore events you don't care about in your event\n loop without calling this function.\n\n This function only affects currently queued events. If you want to make\n sure that all pending OS events are flushed, you can call SDL_PumpEvents()\n on the main thread immediately before the flush call.\n\n \\param minType the low end of event type to be cleared, inclusive; see\n                SDL_EventType for details\n \\param maxType the high end of event type to be cleared, inclusive; see\n                SDL_EventType for details\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_FlushEvent"]
     pub fn SDL_FlushEvents(minType: Uint32, maxType: Uint32);
 }
 extern "C" {
-    #[doc = " Poll for currently pending events."]
-    #[doc = ""]
-    #[doc = " If `event` is not NULL, the next event is removed from the queue and stored"]
-    #[doc = " in the SDL_Event structure pointed to by `event`. The 1 returned refers to"]
-    #[doc = " this event, immediately stored in the SDL Event structure -- not an event"]
-    #[doc = " to follow."]
-    #[doc = ""]
-    #[doc = " If `event` is NULL, it simply returns 1 if there is an event in the queue,"]
-    #[doc = " but will not remove it from the queue."]
-    #[doc = ""]
-    #[doc = " As this function may implicitly call SDL_PumpEvents(), you can only call"]
-    #[doc = " this function in the thread that set the video mode."]
-    #[doc = ""]
-    #[doc = " SDL_PollEvent() is the favored way of receiving system events since it can"]
-    #[doc = " be done from the main loop and does not suspend the main loop while waiting"]
-    #[doc = " on an event to be posted."]
-    #[doc = ""]
-    #[doc = " The common practice is to fully process the event queue once every frame,"]
-    #[doc = " usually as a first step before updating the game's state:"]
-    #[doc = ""]
-    #[doc = " ```c"]
-    #[doc = " while (game_is_still_running) {"]
-    #[doc = "     SDL_Event event;"]
-    #[doc = "     while (SDL_PollEvent(&event)) {  // poll until all events are handled!"]
-    #[doc = "         // decide what to do with this event."]
-    #[doc = "     }"]
-    #[doc = ""]
-    #[doc = "     // update game state, draw the current frame"]
-    #[doc = " }"]
-    #[doc = " ```"]
-    #[doc = ""]
-    #[doc = " \\param event the SDL_Event structure to be filled with the next event from"]
-    #[doc = "              the queue, or NULL"]
-    #[doc = " \\returns 1 if there is a pending event or 0 if there are none available."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_GetEventFilter"]
-    #[doc = " \\sa SDL_PeepEvents"]
-    #[doc = " \\sa SDL_PushEvent"]
-    #[doc = " \\sa SDL_SetEventFilter"]
-    #[doc = " \\sa SDL_WaitEvent"]
-    #[doc = " \\sa SDL_WaitEventTimeout"]
+    #[doc = " Poll for currently pending events.\n\n If `event` is not NULL, the next event is removed from the queue and stored\n in the SDL_Event structure pointed to by `event`. The 1 returned refers to\n this event, immediately stored in the SDL Event structure -- not an event\n to follow.\n\n If `event` is NULL, it simply returns 1 if there is an event in the queue,\n but will not remove it from the queue.\n\n As this function may implicitly call SDL_PumpEvents(), you can only call\n this function in the thread that set the video mode.\n\n SDL_PollEvent() is the favored way of receiving system events since it can\n be done from the main loop and does not suspend the main loop while waiting\n on an event to be posted.\n\n The common practice is to fully process the event queue once every frame,\n usually as a first step before updating the game's state:\n\n ```c\n while (game_is_still_running) {\n     SDL_Event event;\n     while (SDL_PollEvent(&event)) {  // poll until all events are handled!\n         // decide what to do with this event.\n     }\n\n     // update game state, draw the current frame\n }\n ```\n\n \\param event the SDL_Event structure to be filled with the next event from\n              the queue, or NULL\n \\returns 1 if there is a pending event or 0 if there are none available.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_GetEventFilter\n \\sa SDL_PeepEvents\n \\sa SDL_PushEvent\n \\sa SDL_SetEventFilter\n \\sa SDL_WaitEvent\n \\sa SDL_WaitEventTimeout"]
     pub fn SDL_PollEvent(event: *mut SDL_Event) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Wait indefinitely for the next available event."]
-    #[doc = ""]
-    #[doc = " If `event` is not NULL, the next event is removed from the queue and stored"]
-    #[doc = " in the SDL_Event structure pointed to by `event`."]
-    #[doc = ""]
-    #[doc = " As this function may implicitly call SDL_PumpEvents(), you can only call"]
-    #[doc = " this function in the thread that initialized the video subsystem."]
-    #[doc = ""]
-    #[doc = " \\param event the SDL_Event structure to be filled in with the next event"]
-    #[doc = "              from the queue, or NULL"]
-    #[doc = " \\returns 1 on success or 0 if there was an error while waiting for events;"]
-    #[doc = "          call SDL_GetError() for more information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_PollEvent"]
-    #[doc = " \\sa SDL_PumpEvents"]
-    #[doc = " \\sa SDL_WaitEventTimeout"]
+    #[doc = " Wait indefinitely for the next available event.\n\n If `event` is not NULL, the next event is removed from the queue and stored\n in the SDL_Event structure pointed to by `event`.\n\n As this function may implicitly call SDL_PumpEvents(), you can only call\n this function in the thread that initialized the video subsystem.\n\n \\param event the SDL_Event structure to be filled in with the next event\n              from the queue, or NULL\n \\returns 1 on success or 0 if there was an error while waiting for events;\n          call SDL_GetError() for more information.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_PollEvent\n \\sa SDL_PumpEvents\n \\sa SDL_WaitEventTimeout"]
     pub fn SDL_WaitEvent(event: *mut SDL_Event) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Wait until the specified timeout (in milliseconds) for the next available"]
-    #[doc = " event."]
-    #[doc = ""]
-    #[doc = " If `event` is not NULL, the next event is removed from the queue and stored"]
-    #[doc = " in the SDL_Event structure pointed to by `event`."]
-    #[doc = ""]
-    #[doc = " As this function may implicitly call SDL_PumpEvents(), you can only call"]
-    #[doc = " this function in the thread that initialized the video subsystem."]
-    #[doc = ""]
-    #[doc = " \\param event the SDL_Event structure to be filled in with the next event"]
-    #[doc = "              from the queue, or NULL"]
-    #[doc = " \\param timeout the maximum number of milliseconds to wait for the next"]
-    #[doc = "                available event"]
-    #[doc = " \\returns 1 on success or 0 if there was an error while waiting for events;"]
-    #[doc = "          call SDL_GetError() for more information. This also returns 0 if"]
-    #[doc = "          the timeout elapsed without an event arriving."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_PollEvent"]
-    #[doc = " \\sa SDL_PumpEvents"]
-    #[doc = " \\sa SDL_WaitEvent"]
+    #[doc = " Wait until the specified timeout (in milliseconds) for the next available\n event.\n\n If `event` is not NULL, the next event is removed from the queue and stored\n in the SDL_Event structure pointed to by `event`.\n\n As this function may implicitly call SDL_PumpEvents(), you can only call\n this function in the thread that initialized the video subsystem.\n\n \\param event the SDL_Event structure to be filled in with the next event\n              from the queue, or NULL\n \\param timeout the maximum number of milliseconds to wait for the next\n                available event\n \\returns 1 on success or 0 if there was an error while waiting for events;\n          call SDL_GetError() for more information. This also returns 0 if\n          the timeout elapsed without an event arriving.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_PollEvent\n \\sa SDL_PumpEvents\n \\sa SDL_WaitEvent"]
     pub fn SDL_WaitEventTimeout(event: *mut SDL_Event, timeout: libc::c_int) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Add an event to the event queue."]
-    #[doc = ""]
-    #[doc = " The event queue can actually be used as a two way communication channel."]
-    #[doc = " Not only can events be read from the queue, but the user can also push"]
-    #[doc = " their own events onto it. `event` is a pointer to the event structure you"]
-    #[doc = " wish to push onto the queue. The event is copied into the queue, and the"]
-    #[doc = " caller may dispose of the memory pointed to after SDL_PushEvent() returns."]
-    #[doc = ""]
-    #[doc = " Note: Pushing device input events onto the queue doesn't modify the state"]
-    #[doc = " of the device within SDL."]
-    #[doc = ""]
-    #[doc = " This function is thread-safe, and can be called from other threads safely."]
-    #[doc = ""]
-    #[doc = " Note: Events pushed onto the queue with SDL_PushEvent() get passed through"]
-    #[doc = " the event filter but events added with SDL_PeepEvents() do not."]
-    #[doc = ""]
-    #[doc = " For pushing application-specific events, please use SDL_RegisterEvents() to"]
-    #[doc = " get an event type that does not conflict with other code that also wants"]
-    #[doc = " its own custom event types."]
-    #[doc = ""]
-    #[doc = " \\param event the SDL_Event to be added to the queue"]
-    #[doc = " \\returns 1 on success, 0 if the event was filtered, or a negative error"]
-    #[doc = "          code on failure; call SDL_GetError() for more information. A"]
-    #[doc = "          common reason for error is the event queue being full."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_PeepEvents"]
-    #[doc = " \\sa SDL_PollEvent"]
-    #[doc = " \\sa SDL_RegisterEvents"]
+    #[doc = " Add an event to the event queue.\n\n The event queue can actually be used as a two way communication channel.\n Not only can events be read from the queue, but the user can also push\n their own events onto it. `event` is a pointer to the event structure you\n wish to push onto the queue. The event is copied into the queue, and the\n caller may dispose of the memory pointed to after SDL_PushEvent() returns.\n\n Note: Pushing device input events onto the queue doesn't modify the state\n of the device within SDL.\n\n This function is thread-safe, and can be called from other threads safely.\n\n Note: Events pushed onto the queue with SDL_PushEvent() get passed through\n the event filter but events added with SDL_PeepEvents() do not.\n\n For pushing application-specific events, please use SDL_RegisterEvents() to\n get an event type that does not conflict with other code that also wants\n its own custom event types.\n\n \\param event the SDL_Event to be added to the queue\n \\returns 1 on success, 0 if the event was filtered, or a negative error\n          code on failure; call SDL_GetError() for more information. A\n          common reason for error is the event queue being full.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_PeepEvents\n \\sa SDL_PollEvent\n \\sa SDL_RegisterEvents"]
     pub fn SDL_PushEvent(event: *mut SDL_Event) -> libc::c_int;
 }
-#[doc = " A function pointer used for callbacks that watch the event queue."]
-#[doc = ""]
-#[doc = " \\param userdata what was passed as `userdata` to SDL_SetEventFilter()"]
-#[doc = "        or SDL_AddEventWatch, etc"]
-#[doc = " \\param event the event that triggered the callback"]
-#[doc = " \\returns 1 to permit event to be added to the queue, and 0 to disallow"]
-#[doc = "          it. When used with SDL_AddEventWatch, the return value is ignored."]
-#[doc = ""]
-#[doc = " \\sa SDL_SetEventFilter"]
-#[doc = " \\sa SDL_AddEventWatch"]
+#[doc = " A function pointer used for callbacks that watch the event queue.\n\n \\param userdata what was passed as `userdata` to SDL_SetEventFilter()\n        or SDL_AddEventWatch, etc\n \\param event the event that triggered the callback\n \\returns 1 to permit event to be added to the queue, and 0 to disallow\n          it. When used with SDL_AddEventWatch, the return value is ignored.\n\n \\sa SDL_SetEventFilter\n \\sa SDL_AddEventWatch"]
 pub type SDL_EventFilter = ::core::option::Option<
     unsafe extern "C" fn(userdata: *mut libc::c_void, event: *mut SDL_Event) -> libc::c_int,
 >;
 extern "C" {
-    #[doc = " Set up a filter to process all events before they change internal state and"]
-    #[doc = " are posted to the internal event queue."]
-    #[doc = ""]
-    #[doc = " If the filter function returns 1 when called, then the event will be added"]
-    #[doc = " to the internal queue. If it returns 0, then the event will be dropped from"]
-    #[doc = " the queue, but the internal state will still be updated. This allows"]
-    #[doc = " selective filtering of dynamically arriving events."]
-    #[doc = ""]
-    #[doc = " **WARNING**: Be very careful of what you do in the event filter function,"]
-    #[doc = " as it may run in a different thread!"]
-    #[doc = ""]
-    #[doc = " On platforms that support it, if the quit event is generated by an"]
-    #[doc = " interrupt signal (e.g. pressing Ctrl-C), it will be delivered to the"]
-    #[doc = " application at the next event poll."]
-    #[doc = ""]
-    #[doc = " There is one caveat when dealing with the ::SDL_QuitEvent event type. The"]
-    #[doc = " event filter is only called when the window manager desires to close the"]
-    #[doc = " application window. If the event filter returns 1, then the window will be"]
-    #[doc = " closed, otherwise the window will remain open if possible."]
-    #[doc = ""]
-    #[doc = " Note: Disabled events never make it to the event filter function; see"]
-    #[doc = " SDL_EventState()."]
-    #[doc = ""]
-    #[doc = " Note: If you just want to inspect events without filtering, you should use"]
-    #[doc = " SDL_AddEventWatch() instead."]
-    #[doc = ""]
-    #[doc = " Note: Events pushed onto the queue with SDL_PushEvent() get passed through"]
-    #[doc = " the event filter, but events pushed onto the queue with SDL_PeepEvents() do"]
-    #[doc = " not."]
-    #[doc = ""]
-    #[doc = " \\param filter An SDL_EventFilter function to call when an event happens"]
-    #[doc = " \\param userdata a pointer that is passed to `filter`"]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_AddEventWatch"]
-    #[doc = " \\sa SDL_EventState"]
-    #[doc = " \\sa SDL_GetEventFilter"]
-    #[doc = " \\sa SDL_PeepEvents"]
-    #[doc = " \\sa SDL_PushEvent"]
+    #[doc = " Set up a filter to process all events before they change internal state and\n are posted to the internal event queue.\n\n If the filter function returns 1 when called, then the event will be added\n to the internal queue. If it returns 0, then the event will be dropped from\n the queue, but the internal state will still be updated. This allows\n selective filtering of dynamically arriving events.\n\n **WARNING**: Be very careful of what you do in the event filter function,\n as it may run in a different thread!\n\n On platforms that support it, if the quit event is generated by an\n interrupt signal (e.g. pressing Ctrl-C), it will be delivered to the\n application at the next event poll.\n\n There is one caveat when dealing with the ::SDL_QuitEvent event type. The\n event filter is only called when the window manager desires to close the\n application window. If the event filter returns 1, then the window will be\n closed, otherwise the window will remain open if possible.\n\n Note: Disabled events never make it to the event filter function; see\n SDL_EventState().\n\n Note: If you just want to inspect events without filtering, you should use\n SDL_AddEventWatch() instead.\n\n Note: Events pushed onto the queue with SDL_PushEvent() get passed through\n the event filter, but events pushed onto the queue with SDL_PeepEvents() do\n not.\n\n \\param filter An SDL_EventFilter function to call when an event happens\n \\param userdata a pointer that is passed to `filter`\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_AddEventWatch\n \\sa SDL_EventState\n \\sa SDL_GetEventFilter\n \\sa SDL_PeepEvents\n \\sa SDL_PushEvent"]
     pub fn SDL_SetEventFilter(filter: SDL_EventFilter, userdata: *mut libc::c_void);
 }
 extern "C" {
-    #[doc = " Query the current event filter."]
-    #[doc = ""]
-    #[doc = " This function can be used to \"chain\" filters, by saving the existing filter"]
-    #[doc = " before replacing it with a function that will call that saved filter."]
-    #[doc = ""]
-    #[doc = " \\param filter the current callback function will be stored here"]
-    #[doc = " \\param userdata the pointer that is passed to the current event filter will"]
-    #[doc = "                 be stored here"]
-    #[doc = " \\returns SDL_TRUE on success or SDL_FALSE if there is no event filter set."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_SetEventFilter"]
+    #[doc = " Query the current event filter.\n\n This function can be used to \"chain\" filters, by saving the existing filter\n before replacing it with a function that will call that saved filter.\n\n \\param filter the current callback function will be stored here\n \\param userdata the pointer that is passed to the current event filter will\n                 be stored here\n \\returns SDL_TRUE on success or SDL_FALSE if there is no event filter set.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_SetEventFilter"]
     pub fn SDL_GetEventFilter(
         filter: *mut SDL_EventFilter,
         userdata: *mut *mut libc::c_void,
     ) -> SDL_bool;
 }
 extern "C" {
-    #[doc = " Add a callback to be triggered when an event is added to the event queue."]
-    #[doc = ""]
-    #[doc = " `filter` will be called when an event happens, and its return value is"]
-    #[doc = " ignored."]
-    #[doc = ""]
-    #[doc = " **WARNING**: Be very careful of what you do in the event filter function,"]
-    #[doc = " as it may run in a different thread!"]
-    #[doc = ""]
-    #[doc = " If the quit event is generated by a signal (e.g. SIGINT), it will bypass"]
-    #[doc = " the internal queue and be delivered to the watch callback immediately, and"]
-    #[doc = " arrive at the next event poll."]
-    #[doc = ""]
-    #[doc = " Note: the callback is called for events posted by the user through"]
-    #[doc = " SDL_PushEvent(), but not for disabled events, nor for events by a filter"]
-    #[doc = " callback set with SDL_SetEventFilter(), nor for events posted by the user"]
-    #[doc = " through SDL_PeepEvents()."]
-    #[doc = ""]
-    #[doc = " \\param filter an SDL_EventFilter function to call when an event happens."]
-    #[doc = " \\param userdata a pointer that is passed to `filter`"]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_DelEventWatch"]
-    #[doc = " \\sa SDL_SetEventFilter"]
+    #[doc = " Add a callback to be triggered when an event is added to the event queue.\n\n `filter` will be called when an event happens, and its return value is\n ignored.\n\n **WARNING**: Be very careful of what you do in the event filter function,\n as it may run in a different thread!\n\n If the quit event is generated by a signal (e.g. SIGINT), it will bypass\n the internal queue and be delivered to the watch callback immediately, and\n arrive at the next event poll.\n\n Note: the callback is called for events posted by the user through\n SDL_PushEvent(), but not for disabled events, nor for events by a filter\n callback set with SDL_SetEventFilter(), nor for events posted by the user\n through SDL_PeepEvents().\n\n \\param filter an SDL_EventFilter function to call when an event happens.\n \\param userdata a pointer that is passed to `filter`\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_DelEventWatch\n \\sa SDL_SetEventFilter"]
     pub fn SDL_AddEventWatch(filter: SDL_EventFilter, userdata: *mut libc::c_void);
 }
 extern "C" {
-    #[doc = " Remove an event watch callback added with SDL_AddEventWatch()."]
-    #[doc = ""]
-    #[doc = " This function takes the same input as SDL_AddEventWatch() to identify and"]
-    #[doc = " delete the corresponding callback."]
-    #[doc = ""]
-    #[doc = " \\param filter the function originally passed to SDL_AddEventWatch()"]
-    #[doc = " \\param userdata the pointer originally passed to SDL_AddEventWatch()"]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_AddEventWatch"]
+    #[doc = " Remove an event watch callback added with SDL_AddEventWatch().\n\n This function takes the same input as SDL_AddEventWatch() to identify and\n delete the corresponding callback.\n\n \\param filter the function originally passed to SDL_AddEventWatch()\n \\param userdata the pointer originally passed to SDL_AddEventWatch()\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_AddEventWatch"]
     pub fn SDL_DelEventWatch(filter: SDL_EventFilter, userdata: *mut libc::c_void);
 }
 extern "C" {
-    #[doc = " Run a specific filter function on the current event queue, removing any"]
-    #[doc = " events for which the filter returns 0."]
-    #[doc = ""]
-    #[doc = " See SDL_SetEventFilter() for more information. Unlike SDL_SetEventFilter(),"]
-    #[doc = " this function does not change the filter permanently, it only uses the"]
-    #[doc = " supplied filter until this function returns."]
-    #[doc = ""]
-    #[doc = " \\param filter the SDL_EventFilter function to call when an event happens"]
-    #[doc = " \\param userdata a pointer that is passed to `filter`"]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_GetEventFilter"]
-    #[doc = " \\sa SDL_SetEventFilter"]
+    #[doc = " Run a specific filter function on the current event queue, removing any\n events for which the filter returns 0.\n\n See SDL_SetEventFilter() for more information. Unlike SDL_SetEventFilter(),\n this function does not change the filter permanently, it only uses the\n supplied filter until this function returns.\n\n \\param filter the SDL_EventFilter function to call when an event happens\n \\param userdata a pointer that is passed to `filter`\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_GetEventFilter\n \\sa SDL_SetEventFilter"]
     pub fn SDL_FilterEvents(filter: SDL_EventFilter, userdata: *mut libc::c_void);
 }
 extern "C" {
-    #[doc = " Set the state of processing events by type."]
-    #[doc = ""]
-    #[doc = " `state` may be any of the following:"]
-    #[doc = ""]
-    #[doc = " - `SDL_QUERY`: returns the current processing state of the specified event"]
-    #[doc = " - `SDL_IGNORE` (aka `SDL_DISABLE`): the event will automatically be dropped"]
-    #[doc = "   from the event queue and will not be filtered"]
-    #[doc = " - `SDL_ENABLE`: the event will be processed normally"]
-    #[doc = ""]
-    #[doc = " \\param type the type of event; see SDL_EventType for details"]
-    #[doc = " \\param state how to process the event"]
-    #[doc = " \\returns `SDL_DISABLE` or `SDL_ENABLE`, representing the processing state"]
-    #[doc = "          of the event before this function makes any changes to it."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_GetEventState"]
+    #[doc = " Set the state of processing events by type.\n\n `state` may be any of the following:\n\n - `SDL_QUERY`: returns the current processing state of the specified event\n - `SDL_IGNORE` (aka `SDL_DISABLE`): the event will automatically be dropped\n   from the event queue and will not be filtered\n - `SDL_ENABLE`: the event will be processed normally\n\n \\param type the type of event; see SDL_EventType for details\n \\param state how to process the event\n \\returns `SDL_DISABLE` or `SDL_ENABLE`, representing the processing state\n          of the event before this function makes any changes to it.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_GetEventState"]
     pub fn SDL_EventState(type_: Uint32, state: libc::c_int) -> Uint8;
 }
 extern "C" {
-    #[doc = " Allocate a set of user-defined events, and return the beginning event"]
-    #[doc = " number for that set of events."]
-    #[doc = ""]
-    #[doc = " Calling this function with `numevents` <= 0 is an error and will return"]
-    #[doc = " (Uint32)-1."]
-    #[doc = ""]
-    #[doc = " Note, (Uint32)-1 means the maximum unsigned 32-bit integer value (or"]
-    #[doc = " 0xFFFFFFFF), but is clearer to write."]
-    #[doc = ""]
-    #[doc = " \\param numevents the number of events to be allocated"]
-    #[doc = " \\returns the beginning event number, or (Uint32)-1 if there are not enough"]
-    #[doc = "          user-defined events left."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_PushEvent"]
+    #[doc = " Allocate a set of user-defined events, and return the beginning event\n number for that set of events.\n\n Calling this function with `numevents` <= 0 is an error and will return\n (Uint32)-1.\n\n Note, (Uint32)-1 means the maximum unsigned 32-bit integer value (or\n 0xFFFFFFFF), but is clearer to write.\n\n \\param numevents the number of events to be allocated\n \\returns the beginning event number, or (Uint32)-1 if there are not enough\n          user-defined events left.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_PushEvent"]
     pub fn SDL_RegisterEvents(numevents: libc::c_int) -> Uint32;
 }
 extern "C" {
-    #[doc = " Get the directory where the application was run from."]
-    #[doc = ""]
-    #[doc = " This is not necessarily a fast call, so you should call this once near"]
-    #[doc = " startup and save the string if you need it."]
-    #[doc = ""]
-    #[doc = " **Mac OS X and iOS Specific Functionality**: If the application is in a"]
-    #[doc = " \".app\" bundle, this function returns the Resource directory (e.g."]
-    #[doc = " MyApp.app/Contents/Resources/). This behaviour can be overridden by adding"]
-    #[doc = " a property to the Info.plist file. Adding a string key with the name"]
-    #[doc = " SDL_FILESYSTEM_BASE_DIR_TYPE with a supported value will change the"]
-    #[doc = " behaviour."]
-    #[doc = ""]
-    #[doc = " Supported values for the SDL_FILESYSTEM_BASE_DIR_TYPE property (Given an"]
-    #[doc = " application in /Applications/SDLApp/MyApp.app):"]
-    #[doc = ""]
-    #[doc = " - `resource`: bundle resource directory (the default). For example:"]
-    #[doc = "   `/Applications/SDLApp/MyApp.app/Contents/Resources`"]
-    #[doc = " - `bundle`: the Bundle directory. For example:"]
-    #[doc = "   `/Applications/SDLApp/MyApp.app/`"]
-    #[doc = " - `parent`: the containing directory of the bundle. For example:"]
-    #[doc = "   `/Applications/SDLApp/`"]
-    #[doc = ""]
-    #[doc = " The returned path is guaranteed to end with a path separator ('\\' on"]
-    #[doc = " Windows, '/' on most other platforms)."]
-    #[doc = ""]
-    #[doc = " The pointer returned is owned by the caller. Please call SDL_free() on the"]
-    #[doc = " pointer when done with it."]
-    #[doc = ""]
-    #[doc = " \\returns an absolute path in UTF-8 encoding to the application data"]
-    #[doc = "          directory. NULL will be returned on error or when the platform"]
-    #[doc = "          doesn't implement this functionality, call SDL_GetError() for more"]
-    #[doc = "          information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.1."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_GetPrefPath"]
+    #[doc = " Get the directory where the application was run from.\n\n This is not necessarily a fast call, so you should call this once near\n startup and save the string if you need it.\n\n **Mac OS X and iOS Specific Functionality**: If the application is in a\n \".app\" bundle, this function returns the Resource directory (e.g.\n MyApp.app/Contents/Resources/). This behaviour can be overridden by adding\n a property to the Info.plist file. Adding a string key with the name\n SDL_FILESYSTEM_BASE_DIR_TYPE with a supported value will change the\n behaviour.\n\n Supported values for the SDL_FILESYSTEM_BASE_DIR_TYPE property (Given an\n application in /Applications/SDLApp/MyApp.app):\n\n - `resource`: bundle resource directory (the default). For example:\n   `/Applications/SDLApp/MyApp.app/Contents/Resources`\n - `bundle`: the Bundle directory. For example:\n   `/Applications/SDLApp/MyApp.app/`\n - `parent`: the containing directory of the bundle. For example:\n   `/Applications/SDLApp/`\n\n **Nintendo 3DS Specific Functionality**: This function returns \"romfs\"\n directory of the application as it is uncommon to store resources outside\n the executable. As such it is not a writable directory.\n\n The returned path is guaranteed to end with a path separator ('\\' on\n Windows, '/' on most other platforms).\n\n The pointer returned is owned by the caller. Please call SDL_free() on the\n pointer when done with it.\n\n \\returns an absolute path in UTF-8 encoding to the application data\n          directory. NULL will be returned on error or when the platform\n          doesn't implement this functionality, call SDL_GetError() for more\n          information.\n\n \\since This function is available since SDL 2.0.1.\n\n \\sa SDL_GetPrefPath"]
     pub fn SDL_GetBasePath() -> *mut libc::c_char;
 }
 extern "C" {
-    #[doc = " Get the user-and-app-specific path where files can be written."]
-    #[doc = ""]
-    #[doc = " Get the \"pref dir\". This is meant to be where users can write personal"]
-    #[doc = " files (preferences and save games, etc) that are specific to your"]
-    #[doc = " application. This directory is unique per user, per application."]
-    #[doc = ""]
-    #[doc = " This function will decide the appropriate location in the native"]
-    #[doc = " filesystem, create the directory if necessary, and return a string of the"]
-    #[doc = " absolute path to the directory in UTF-8 encoding."]
-    #[doc = ""]
-    #[doc = " On Windows, the string might look like:"]
-    #[doc = ""]
-    #[doc = " `C:\\\\Users\\\\bob\\\\AppData\\\\Roaming\\\\My Company\\\\My Program Name\\\\`"]
-    #[doc = ""]
-    #[doc = " On Linux, the string might look like\""]
-    #[doc = ""]
-    #[doc = " `/home/bob/.local/share/My Program Name/`"]
-    #[doc = ""]
-    #[doc = " On Mac OS X, the string might look like:"]
-    #[doc = ""]
-    #[doc = " `/Users/bob/Library/Application Support/My Program Name/`"]
-    #[doc = ""]
-    #[doc = " You should assume the path returned by this function is the only safe place"]
-    #[doc = " to write files (and that SDL_GetBasePath(), while it might be writable, or"]
-    #[doc = " even the parent of the returned path, isn't where you should be writing"]
-    #[doc = " things)."]
-    #[doc = ""]
-    #[doc = " Both the org and app strings may become part of a directory name, so please"]
-    #[doc = " follow these rules:"]
-    #[doc = ""]
-    #[doc = " - Try to use the same org string (_including case-sensitivity_) for all"]
-    #[doc = "   your applications that use this function."]
-    #[doc = " - Always use a unique app string for each one, and make sure it never"]
-    #[doc = "   changes for an app once you've decided on it."]
-    #[doc = " - Unicode characters are legal, as long as it's UTF-8 encoded, but..."]
-    #[doc = " - ...only use letters, numbers, and spaces. Avoid punctuation like \"Game"]
-    #[doc = "   Name 2: Bad Guy's Revenge!\" ... \"Game Name 2\" is sufficient."]
-    #[doc = ""]
-    #[doc = " The returned path is guaranteed to end with a path separator ('\\' on"]
-    #[doc = " Windows, '/' on most other platforms)."]
-    #[doc = ""]
-    #[doc = " The pointer returned is owned by the caller. Please call SDL_free() on the"]
-    #[doc = " pointer when done with it."]
-    #[doc = ""]
-    #[doc = " \\param org the name of your organization"]
-    #[doc = " \\param app the name of your application"]
-    #[doc = " \\returns a UTF-8 string of the user directory in platform-dependent"]
-    #[doc = "          notation. NULL if there's a problem (creating directory failed,"]
-    #[doc = "          etc.)."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.1."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_GetBasePath"]
+    #[doc = " Get the user-and-app-specific path where files can be written.\n\n Get the \"pref dir\". This is meant to be where users can write personal\n files (preferences and save games, etc) that are specific to your\n application. This directory is unique per user, per application.\n\n This function will decide the appropriate location in the native\n filesystem, create the directory if necessary, and return a string of the\n absolute path to the directory in UTF-8 encoding.\n\n On Windows, the string might look like:\n\n `C:\\\\Users\\\\bob\\\\AppData\\\\Roaming\\\\My Company\\\\My Program Name\\\\`\n\n On Linux, the string might look like:\n\n `/home/bob/.local/share/My Program Name/`\n\n On Mac OS X, the string might look like:\n\n `/Users/bob/Library/Application Support/My Program Name/`\n\n You should assume the path returned by this function is the only safe place\n to write files (and that SDL_GetBasePath(), while it might be writable, or\n even the parent of the returned path, isn't where you should be writing\n things).\n\n Both the org and app strings may become part of a directory name, so please\n follow these rules:\n\n - Try to use the same org string (_including case-sensitivity_) for all\n   your applications that use this function.\n - Always use a unique app string for each one, and make sure it never\n   changes for an app once you've decided on it.\n - Unicode characters are legal, as long as it's UTF-8 encoded, but...\n - ...only use letters, numbers, and spaces. Avoid punctuation like \"Game\n   Name 2: Bad Guy's Revenge!\" ... \"Game Name 2\" is sufficient.\n\n The returned path is guaranteed to end with a path separator ('\\' on\n Windows, '/' on most other platforms).\n\n The pointer returned is owned by the caller. Please call SDL_free() on the\n pointer when done with it.\n\n \\param org the name of your organization\n \\param app the name of your application\n \\returns a UTF-8 string of the user directory in platform-dependent\n          notation. NULL if there's a problem (creating directory failed,\n          etc.).\n\n \\since This function is available since SDL 2.0.1.\n\n \\sa SDL_GetBasePath"]
     pub fn SDL_GetPrefPath(org: *const libc::c_char, app: *const libc::c_char)
         -> *mut libc::c_char;
 }
-#[doc = "  \\typedef SDL_Haptic"]
-#[doc = ""]
-#[doc = "  \\brief The haptic structure used to identify an SDL haptic."]
-#[doc = ""]
-#[doc = "  \\sa SDL_HapticOpen"]
-#[doc = "  \\sa SDL_HapticOpenFromJoystick"]
-#[doc = "  \\sa SDL_HapticClose"]
+#[doc = "  \\typedef SDL_Haptic\n\n  \\brief The haptic structure used to identify an SDL haptic.\n\n  \\sa SDL_HapticOpen\n  \\sa SDL_HapticOpenFromJoystick\n  \\sa SDL_HapticClose"]
 #[repr(C)]
 #[derive(Copy, Clone)]
 pub struct _SDL_Haptic {
     _unused: [u8; 0],
 }
 pub type SDL_Haptic = _SDL_Haptic;
-#[doc = "  \\brief Structure that represents a haptic direction."]
-#[doc = ""]
-#[doc = "  This is the direction where the force comes from,"]
-#[doc = "  instead of the direction in which the force is exerted."]
-#[doc = ""]
-#[doc = "  Directions can be specified by:"]
-#[doc = "   - ::SDL_HAPTIC_POLAR : Specified by polar coordinates."]
-#[doc = "   - ::SDL_HAPTIC_CARTESIAN : Specified by cartesian coordinates."]
-#[doc = "   - ::SDL_HAPTIC_SPHERICAL : Specified by spherical coordinates."]
-#[doc = ""]
-#[doc = "  Cardinal directions of the haptic device are relative to the positioning"]
-#[doc = "  of the device.  North is considered to be away from the user."]
-#[doc = ""]
-#[doc = "  The following diagram represents the cardinal directions:"]
-#[doc = "  \\verbatim"]
-#[doc = ".--."]
-#[doc = "|__| .-------."]
-#[doc = "|=.| |.-----.|"]
-#[doc = "|--| ||     ||"]
-#[doc = "|  | |'-----'|"]
-#[doc = "|__|~')_____('"]
-#[doc = "[ COMPUTER ]"]
-#[doc = ""]
-#[doc = ""]
-#[doc = "North (0,-1)"]
-#[doc = "^"]
-#[doc = "|"]
-#[doc = "|"]
-#[doc = "(-1,0)  West <----[ HAPTIC ]----> East (1,0)"]
-#[doc = "|"]
-#[doc = "|"]
-#[doc = "v"]
-#[doc = "South (0,1)"]
-#[doc = ""]
-#[doc = ""]
-#[doc = "[ USER ]"]
-#[doc = "\\|||/"]
-#[doc = "(o o)"]
-#[doc = "---ooO-(_)-Ooo---"]
-#[doc = "\\endverbatim"]
-#[doc = ""]
-#[doc = "  If type is ::SDL_HAPTIC_POLAR, direction is encoded by hundredths of a"]
-#[doc = "  degree starting north and turning clockwise.  ::SDL_HAPTIC_POLAR only uses"]
-#[doc = "  the first \\c dir parameter.  The cardinal directions would be:"]
-#[doc = "   - North: 0 (0 degrees)"]
-#[doc = "   - East: 9000 (90 degrees)"]
-#[doc = "   - South: 18000 (180 degrees)"]
-#[doc = "   - West: 27000 (270 degrees)"]
-#[doc = ""]
-#[doc = "  If type is ::SDL_HAPTIC_CARTESIAN, direction is encoded by three positions"]
-#[doc = "  (X axis, Y axis and Z axis (with 3 axes)).  ::SDL_HAPTIC_CARTESIAN uses"]
-#[doc = "  the first three \\c dir parameters.  The cardinal directions would be:"]
-#[doc = "   - North:  0,-1, 0"]
-#[doc = "   - East:   1, 0, 0"]
-#[doc = "   - South:  0, 1, 0"]
-#[doc = "   - West:  -1, 0, 0"]
-#[doc = ""]
-#[doc = "  The Z axis represents the height of the effect if supported, otherwise"]
-#[doc = "  it's unused.  In cartesian encoding (1, 2) would be the same as (2, 4), you"]
-#[doc = "  can use any multiple you want, only the direction matters."]
-#[doc = ""]
-#[doc = "  If type is ::SDL_HAPTIC_SPHERICAL, direction is encoded by two rotations."]
-#[doc = "  The first two \\c dir parameters are used.  The \\c dir parameters are as"]
-#[doc = "  follows (all values are in hundredths of degrees):"]
-#[doc = "   - Degrees from (1, 0) rotated towards (0, 1)."]
-#[doc = "   - Degrees towards (0, 0, 1) (device needs at least 3 axes)."]
-#[doc = ""]
-#[doc = ""]
-#[doc = "  Example of force coming from the south with all encodings (force coming"]
-#[doc = "  from the south means the user will have to pull the stick to counteract):"]
-#[doc = "  \\code"]
-#[doc = "  SDL_HapticDirection direction;"]
-#[doc = ""]
-#[doc = "  // Cartesian directions"]
-#[doc = "  direction.type = SDL_HAPTIC_CARTESIAN; // Using cartesian direction encoding."]
-#[doc = "  direction.dir[0] = 0; // X position"]
-#[doc = "  direction.dir[1] = 1; // Y position"]
-#[doc = "  // Assuming the device has 2 axes, we don't need to specify third parameter."]
-#[doc = ""]
-#[doc = "  // Polar directions"]
-#[doc = "  direction.type = SDL_HAPTIC_POLAR; // We'll be using polar direction encoding."]
-#[doc = "  direction.dir[0] = 18000; // Polar only uses first parameter"]
-#[doc = ""]
-#[doc = "  // Spherical coordinates"]
-#[doc = "  direction.type = SDL_HAPTIC_SPHERICAL; // Spherical encoding"]
-#[doc = "  direction.dir[0] = 9000; // Since we only have two axes we don't need more parameters."]
-#[doc = "  \\endcode"]
-#[doc = ""]
-#[doc = "  \\sa SDL_HAPTIC_POLAR"]
-#[doc = "  \\sa SDL_HAPTIC_CARTESIAN"]
-#[doc = "  \\sa SDL_HAPTIC_SPHERICAL"]
-#[doc = "  \\sa SDL_HAPTIC_STEERING_AXIS"]
-#[doc = "  \\sa SDL_HapticEffect"]
-#[doc = "  \\sa SDL_HapticNumAxes"]
+#[doc = "  \\brief Structure that represents a haptic direction.\n\n  This is the direction where the force comes from,\n  instead of the direction in which the force is exerted.\n\n  Directions can be specified by:\n   - ::SDL_HAPTIC_POLAR : Specified by polar coordinates.\n   - ::SDL_HAPTIC_CARTESIAN : Specified by cartesian coordinates.\n   - ::SDL_HAPTIC_SPHERICAL : Specified by spherical coordinates.\n\n  Cardinal directions of the haptic device are relative to the positioning\n  of the device.  North is considered to be away from the user.\n\n  The following diagram represents the cardinal directions:\n  \\verbatim\n.--.\n|__| .-------.\n|=.| |.-----.|\n|--| ||     ||\n|  | |'-----'|\n|__|~')_____('\n[ COMPUTER ]\n\n\nNorth (0,-1)\n^\n|\n|\n(-1,0)  West <----[ HAPTIC ]----> East (1,0)\n|\n|\nv\nSouth (0,1)\n\n\n[ USER ]\n\\|||/\n(o o)\n---ooO-(_)-Ooo---\n\\endverbatim\n\n  If type is ::SDL_HAPTIC_POLAR, direction is encoded by hundredths of a\n  degree starting north and turning clockwise.  ::SDL_HAPTIC_POLAR only uses\n  the first \\c dir parameter.  The cardinal directions would be:\n   - North: 0 (0 degrees)\n   - East: 9000 (90 degrees)\n   - South: 18000 (180 degrees)\n   - West: 27000 (270 degrees)\n\n  If type is ::SDL_HAPTIC_CARTESIAN, direction is encoded by three positions\n  (X axis, Y axis and Z axis (with 3 axes)).  ::SDL_HAPTIC_CARTESIAN uses\n  the first three \\c dir parameters.  The cardinal directions would be:\n   - North:  0,-1, 0\n   - East:   1, 0, 0\n   - South:  0, 1, 0\n   - West:  -1, 0, 0\n\n  The Z axis represents the height of the effect if supported, otherwise\n  it's unused.  In cartesian encoding (1, 2) would be the same as (2, 4), you\n  can use any multiple you want, only the direction matters.\n\n  If type is ::SDL_HAPTIC_SPHERICAL, direction is encoded by two rotations.\n  The first two \\c dir parameters are used.  The \\c dir parameters are as\n  follows (all values are in hundredths of degrees):\n   - Degrees from (1, 0) rotated towards (0, 1).\n   - Degrees towards (0, 0, 1) (device needs at least 3 axes).\n\n\n  Example of force coming from the south with all encodings (force coming\n  from the south means the user will have to pull the stick to counteract):\n  \\code\n  SDL_HapticDirection direction;\n\n  // Cartesian directions\n  direction.type = SDL_HAPTIC_CARTESIAN; // Using cartesian direction encoding.\n  direction.dir[0] = 0; // X position\n  direction.dir[1] = 1; // Y position\n  // Assuming the device has 2 axes, we don't need to specify third parameter.\n\n  // Polar directions\n  direction.type = SDL_HAPTIC_POLAR; // We'll be using polar direction encoding.\n  direction.dir[0] = 18000; // Polar only uses first parameter\n\n  // Spherical coordinates\n  direction.type = SDL_HAPTIC_SPHERICAL; // Spherical encoding\n  direction.dir[0] = 9000; // Since we only have two axes we don't need more parameters.\n  \\endcode\n\n  \\sa SDL_HAPTIC_POLAR\n  \\sa SDL_HAPTIC_CARTESIAN\n  \\sa SDL_HAPTIC_SPHERICAL\n  \\sa SDL_HAPTIC_STEERING_AXIS\n  \\sa SDL_HapticEffect\n  \\sa SDL_HapticNumAxes"]
 #[repr(C)]
 #[derive(Copy, Clone)]
 pub struct SDL_HapticDirection {
@@ -19604,6 +13234,9 @@ pub struct SDL_HapticDirection {
 }
 #[test]
 fn bindgen_test_layout_SDL_HapticDirection() {
+    const UNINIT: ::core::mem::MaybeUninit<SDL_HapticDirection> =
+        ::core::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::core::mem::size_of::<SDL_HapticDirection>(),
         16usize,
@@ -19615,7 +13248,7 @@ fn bindgen_test_layout_SDL_HapticDirection() {
         concat!("Alignment of ", stringify!(SDL_HapticDirection))
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_HapticDirection>())).type_ as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -19625,7 +13258,7 @@ fn bindgen_test_layout_SDL_HapticDirection() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_HapticDirection>())).dir as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).dir) as usize - ptr as usize },
         4usize,
         concat!(
             "Offset of field: ",
@@ -19635,15 +13268,7 @@ fn bindgen_test_layout_SDL_HapticDirection() {
         )
     );
 }
-#[doc = "  \\brief A structure containing a template for a Constant effect."]
-#[doc = ""]
-#[doc = "  This struct is exclusively for the ::SDL_HAPTIC_CONSTANT effect."]
-#[doc = ""]
-#[doc = "  A constant effect applies a constant force in the specified direction"]
-#[doc = "  to the joystick."]
-#[doc = ""]
-#[doc = "  \\sa SDL_HAPTIC_CONSTANT"]
-#[doc = "  \\sa SDL_HapticEffect"]
+#[doc = "  \\brief A structure containing a template for a Constant effect.\n\n  This struct is exclusively for the ::SDL_HAPTIC_CONSTANT effect.\n\n  A constant effect applies a constant force in the specified direction\n  to the joystick.\n\n  \\sa SDL_HAPTIC_CONSTANT\n  \\sa SDL_HapticEffect"]
 #[repr(C)]
 #[derive(Copy, Clone)]
 pub struct SDL_HapticConstant {
@@ -19672,6 +13297,8 @@ pub struct SDL_HapticConstant {
 }
 #[test]
 fn bindgen_test_layout_SDL_HapticConstant() {
+    const UNINIT: ::core::mem::MaybeUninit<SDL_HapticConstant> = ::core::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::core::mem::size_of::<SDL_HapticConstant>(),
         40usize,
@@ -19683,7 +13310,7 @@ fn bindgen_test_layout_SDL_HapticConstant() {
         concat!("Alignment of ", stringify!(SDL_HapticConstant))
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_HapticConstant>())).type_ as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -19693,7 +13320,7 @@ fn bindgen_test_layout_SDL_HapticConstant() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_HapticConstant>())).direction as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).direction) as usize - ptr as usize },
         4usize,
         concat!(
             "Offset of field: ",
@@ -19703,7 +13330,7 @@ fn bindgen_test_layout_SDL_HapticConstant() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_HapticConstant>())).length as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).length) as usize - ptr as usize },
         20usize,
         concat!(
             "Offset of field: ",
@@ -19713,7 +13340,7 @@ fn bindgen_test_layout_SDL_HapticConstant() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_HapticConstant>())).delay as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).delay) as usize - ptr as usize },
         24usize,
         concat!(
             "Offset of field: ",
@@ -19723,7 +13350,7 @@ fn bindgen_test_layout_SDL_HapticConstant() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_HapticConstant>())).button as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).button) as usize - ptr as usize },
         26usize,
         concat!(
             "Offset of field: ",
@@ -19733,7 +13360,7 @@ fn bindgen_test_layout_SDL_HapticConstant() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_HapticConstant>())).interval as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).interval) as usize - ptr as usize },
         28usize,
         concat!(
             "Offset of field: ",
@@ -19743,7 +13370,7 @@ fn bindgen_test_layout_SDL_HapticConstant() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_HapticConstant>())).level as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).level) as usize - ptr as usize },
         30usize,
         concat!(
             "Offset of field: ",
@@ -19753,9 +13380,7 @@ fn bindgen_test_layout_SDL_HapticConstant() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::core::ptr::null::<SDL_HapticConstant>())).attack_length as *const _ as usize
-        },
+        unsafe { ::core::ptr::addr_of!((*ptr).attack_length) as usize - ptr as usize },
         32usize,
         concat!(
             "Offset of field: ",
@@ -19765,9 +13390,7 @@ fn bindgen_test_layout_SDL_HapticConstant() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::core::ptr::null::<SDL_HapticConstant>())).attack_level as *const _ as usize
-        },
+        unsafe { ::core::ptr::addr_of!((*ptr).attack_level) as usize - ptr as usize },
         34usize,
         concat!(
             "Offset of field: ",
@@ -19777,7 +13400,7 @@ fn bindgen_test_layout_SDL_HapticConstant() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_HapticConstant>())).fade_length as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).fade_length) as usize - ptr as usize },
         36usize,
         concat!(
             "Offset of field: ",
@@ -19787,7 +13410,7 @@ fn bindgen_test_layout_SDL_HapticConstant() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_HapticConstant>())).fade_level as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).fade_level) as usize - ptr as usize },
         38usize,
         concat!(
             "Offset of field: ",
@@ -19797,59 +13420,11 @@ fn bindgen_test_layout_SDL_HapticConstant() {
         )
     );
 }
-#[doc = "  \\brief A structure containing a template for a Periodic effect."]
-#[doc = ""]
-#[doc = "  The struct handles the following effects:"]
-#[doc = "   - ::SDL_HAPTIC_SINE"]
-#[doc = "   - ::SDL_HAPTIC_LEFTRIGHT"]
-#[doc = "   - ::SDL_HAPTIC_TRIANGLE"]
-#[doc = "   - ::SDL_HAPTIC_SAWTOOTHUP"]
-#[doc = "   - ::SDL_HAPTIC_SAWTOOTHDOWN"]
-#[doc = ""]
-#[doc = "  A periodic effect consists in a wave-shaped effect that repeats itself"]
-#[doc = "  over time.  The type determines the shape of the wave and the parameters"]
-#[doc = "  determine the dimensions of the wave."]
-#[doc = ""]
-#[doc = "  Phase is given by hundredth of a degree meaning that giving the phase a value"]
-#[doc = "  of 9000 will displace it 25% of its period.  Here are sample values:"]
-#[doc = "   -     0: No phase displacement."]
-#[doc = "   -  9000: Displaced 25% of its period."]
-#[doc = "   - 18000: Displaced 50% of its period."]
-#[doc = "   - 27000: Displaced 75% of its period."]
-#[doc = "   - 36000: Displaced 100% of its period, same as 0, but 0 is preferred."]
-#[doc = ""]
-#[doc = "  Examples:"]
-#[doc = "  \\verbatim"]
-#[doc = "SDL_HAPTIC_SINE"]
-#[doc = "__      __      __      __"]
-#[doc = ""]
-#[doc = "SDL_HAPTIC_SQUARE"]
-#[doc = "__    __    __    __    __"]
-#[doc = "|  |  |  |  |  |  |  |  |  |"]
-#[doc = "|  |__|  |__|  |__|  |__|  |"]
-#[doc = ""]
-#[doc = "SDL_HAPTIC_TRIANGLE"]
-#[doc = ""]
-#[doc = "SDL_HAPTIC_SAWTOOTHUP"]
-#[doc = ""]
-#[doc = "SDL_HAPTIC_SAWTOOTHDOWN"]
-#[doc = "\\  |\\  |\\  |\\  |\\  |\\  |\\  |"]
-#[doc = "\\ | \\ | \\ | \\ | \\ | \\ | \\ |"]
-#[doc = "\\|  \\|  \\|  \\|  \\|  \\|  \\|"]
-#[doc = "\\endverbatim"]
-#[doc = ""]
-#[doc = "  \\sa SDL_HAPTIC_SINE"]
-#[doc = "  \\sa SDL_HAPTIC_LEFTRIGHT"]
-#[doc = "  \\sa SDL_HAPTIC_TRIANGLE"]
-#[doc = "  \\sa SDL_HAPTIC_SAWTOOTHUP"]
-#[doc = "  \\sa SDL_HAPTIC_SAWTOOTHDOWN"]
-#[doc = "  \\sa SDL_HapticEffect"]
+#[doc = "  \\brief A structure containing a template for a Periodic effect.\n\n  The struct handles the following effects:\n   - ::SDL_HAPTIC_SINE\n   - ::SDL_HAPTIC_LEFTRIGHT\n   - ::SDL_HAPTIC_TRIANGLE\n   - ::SDL_HAPTIC_SAWTOOTHUP\n   - ::SDL_HAPTIC_SAWTOOTHDOWN\n\n  A periodic effect consists in a wave-shaped effect that repeats itself\n  over time.  The type determines the shape of the wave and the parameters\n  determine the dimensions of the wave.\n\n  Phase is given by hundredth of a degree meaning that giving the phase a value\n  of 9000 will displace it 25% of its period.  Here are sample values:\n   -     0: No phase displacement.\n   -  9000: Displaced 25% of its period.\n   - 18000: Displaced 50% of its period.\n   - 27000: Displaced 75% of its period.\n   - 36000: Displaced 100% of its period, same as 0, but 0 is preferred.\n\n  Examples:\n  \\verbatim\nSDL_HAPTIC_SINE\n__      __      __      __\n/  \\    /  \\    /  \\    /\n/    \\__/    \\__/    \\__/\n\nSDL_HAPTIC_SQUARE\n__    __    __    __    __\n|  |  |  |  |  |  |  |  |  |\n|  |__|  |__|  |__|  |__|  |\n\nSDL_HAPTIC_TRIANGLE\n/\\    /\\    /\\    /\\    /\\\n/  \\  /  \\  /  \\  /  \\  /\n/    \\/    \\/    \\/    \\/\n\nSDL_HAPTIC_SAWTOOTHUP\n/|  /|  /|  /|  /|  /|  /|\n/ | / | / | / | / | / | / |\n/  |/  |/  |/  |/  |/  |/  |\n\nSDL_HAPTIC_SAWTOOTHDOWN\n\\  |\\  |\\  |\\  |\\  |\\  |\\  |\n\\ | \\ | \\ | \\ | \\ | \\ | \\ |\n\\|  \\|  \\|  \\|  \\|  \\|  \\|\n\\endverbatim\n\n  \\sa SDL_HAPTIC_SINE\n  \\sa SDL_HAPTIC_LEFTRIGHT\n  \\sa SDL_HAPTIC_TRIANGLE\n  \\sa SDL_HAPTIC_SAWTOOTHUP\n  \\sa SDL_HAPTIC_SAWTOOTHDOWN\n  \\sa SDL_HapticEffect"]
 #[repr(C)]
 #[derive(Copy, Clone)]
 pub struct SDL_HapticPeriodic {
-    #[doc = "< ::SDL_HAPTIC_SINE, ::SDL_HAPTIC_LEFTRIGHT,"]
-    #[doc = "::SDL_HAPTIC_TRIANGLE, ::SDL_HAPTIC_SAWTOOTHUP or"]
-    #[doc = "::SDL_HAPTIC_SAWTOOTHDOWN"]
+    #[doc = "< ::SDL_HAPTIC_SINE, ::SDL_HAPTIC_LEFTRIGHT,\n::SDL_HAPTIC_TRIANGLE, ::SDL_HAPTIC_SAWTOOTHUP or\n::SDL_HAPTIC_SAWTOOTHDOWN"]
     pub type_: Uint16,
     #[doc = "< Direction of the effect."]
     pub direction: SDL_HapticDirection,
@@ -19880,6 +13455,8 @@ pub struct SDL_HapticPeriodic {
 }
 #[test]
 fn bindgen_test_layout_SDL_HapticPeriodic() {
+    const UNINIT: ::core::mem::MaybeUninit<SDL_HapticPeriodic> = ::core::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::core::mem::size_of::<SDL_HapticPeriodic>(),
         48usize,
@@ -19891,7 +13468,7 @@ fn bindgen_test_layout_SDL_HapticPeriodic() {
         concat!("Alignment of ", stringify!(SDL_HapticPeriodic))
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_HapticPeriodic>())).type_ as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -19901,7 +13478,7 @@ fn bindgen_test_layout_SDL_HapticPeriodic() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_HapticPeriodic>())).direction as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).direction) as usize - ptr as usize },
         4usize,
         concat!(
             "Offset of field: ",
@@ -19911,7 +13488,7 @@ fn bindgen_test_layout_SDL_HapticPeriodic() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_HapticPeriodic>())).length as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).length) as usize - ptr as usize },
         20usize,
         concat!(
             "Offset of field: ",
@@ -19921,7 +13498,7 @@ fn bindgen_test_layout_SDL_HapticPeriodic() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_HapticPeriodic>())).delay as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).delay) as usize - ptr as usize },
         24usize,
         concat!(
             "Offset of field: ",
@@ -19931,7 +13508,7 @@ fn bindgen_test_layout_SDL_HapticPeriodic() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_HapticPeriodic>())).button as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).button) as usize - ptr as usize },
         26usize,
         concat!(
             "Offset of field: ",
@@ -19941,7 +13518,7 @@ fn bindgen_test_layout_SDL_HapticPeriodic() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_HapticPeriodic>())).interval as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).interval) as usize - ptr as usize },
         28usize,
         concat!(
             "Offset of field: ",
@@ -19951,7 +13528,7 @@ fn bindgen_test_layout_SDL_HapticPeriodic() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_HapticPeriodic>())).period as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).period) as usize - ptr as usize },
         30usize,
         concat!(
             "Offset of field: ",
@@ -19961,7 +13538,7 @@ fn bindgen_test_layout_SDL_HapticPeriodic() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_HapticPeriodic>())).magnitude as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).magnitude) as usize - ptr as usize },
         32usize,
         concat!(
             "Offset of field: ",
@@ -19971,7 +13548,7 @@ fn bindgen_test_layout_SDL_HapticPeriodic() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_HapticPeriodic>())).offset as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).offset) as usize - ptr as usize },
         34usize,
         concat!(
             "Offset of field: ",
@@ -19981,7 +13558,7 @@ fn bindgen_test_layout_SDL_HapticPeriodic() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_HapticPeriodic>())).phase as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).phase) as usize - ptr as usize },
         36usize,
         concat!(
             "Offset of field: ",
@@ -19991,9 +13568,7 @@ fn bindgen_test_layout_SDL_HapticPeriodic() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::core::ptr::null::<SDL_HapticPeriodic>())).attack_length as *const _ as usize
-        },
+        unsafe { ::core::ptr::addr_of!((*ptr).attack_length) as usize - ptr as usize },
         38usize,
         concat!(
             "Offset of field: ",
@@ -20003,9 +13578,7 @@ fn bindgen_test_layout_SDL_HapticPeriodic() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::core::ptr::null::<SDL_HapticPeriodic>())).attack_level as *const _ as usize
-        },
+        unsafe { ::core::ptr::addr_of!((*ptr).attack_level) as usize - ptr as usize },
         40usize,
         concat!(
             "Offset of field: ",
@@ -20015,7 +13588,7 @@ fn bindgen_test_layout_SDL_HapticPeriodic() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_HapticPeriodic>())).fade_length as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).fade_length) as usize - ptr as usize },
         42usize,
         concat!(
             "Offset of field: ",
@@ -20025,7 +13598,7 @@ fn bindgen_test_layout_SDL_HapticPeriodic() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_HapticPeriodic>())).fade_level as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).fade_level) as usize - ptr as usize },
         44usize,
         concat!(
             "Offset of field: ",
@@ -20035,33 +13608,11 @@ fn bindgen_test_layout_SDL_HapticPeriodic() {
         )
     );
 }
-#[doc = "  \\brief A structure containing a template for a Condition effect."]
-#[doc = ""]
-#[doc = "  The struct handles the following effects:"]
-#[doc = "   - ::SDL_HAPTIC_SPRING: Effect based on axes position."]
-#[doc = "   - ::SDL_HAPTIC_DAMPER: Effect based on axes velocity."]
-#[doc = "   - ::SDL_HAPTIC_INERTIA: Effect based on axes acceleration."]
-#[doc = "   - ::SDL_HAPTIC_FRICTION: Effect based on axes movement."]
-#[doc = ""]
-#[doc = "  Direction is handled by condition internals instead of a direction member."]
-#[doc = "  The condition effect specific members have three parameters.  The first"]
-#[doc = "  refers to the X axis, the second refers to the Y axis and the third"]
-#[doc = "  refers to the Z axis.  The right terms refer to the positive side of the"]
-#[doc = "  axis and the left terms refer to the negative side of the axis.  Please"]
-#[doc = "  refer to the ::SDL_HapticDirection diagram for which side is positive and"]
-#[doc = "  which is negative."]
-#[doc = ""]
-#[doc = "  \\sa SDL_HapticDirection"]
-#[doc = "  \\sa SDL_HAPTIC_SPRING"]
-#[doc = "  \\sa SDL_HAPTIC_DAMPER"]
-#[doc = "  \\sa SDL_HAPTIC_INERTIA"]
-#[doc = "  \\sa SDL_HAPTIC_FRICTION"]
-#[doc = "  \\sa SDL_HapticEffect"]
+#[doc = "  \\brief A structure containing a template for a Condition effect.\n\n  The struct handles the following effects:\n   - ::SDL_HAPTIC_SPRING: Effect based on axes position.\n   - ::SDL_HAPTIC_DAMPER: Effect based on axes velocity.\n   - ::SDL_HAPTIC_INERTIA: Effect based on axes acceleration.\n   - ::SDL_HAPTIC_FRICTION: Effect based on axes movement.\n\n  Direction is handled by condition internals instead of a direction member.\n  The condition effect specific members have three parameters.  The first\n  refers to the X axis, the second refers to the Y axis and the third\n  refers to the Z axis.  The right terms refer to the positive side of the\n  axis and the left terms refer to the negative side of the axis.  Please\n  refer to the ::SDL_HapticDirection diagram for which side is positive and\n  which is negative.\n\n  \\sa SDL_HapticDirection\n  \\sa SDL_HAPTIC_SPRING\n  \\sa SDL_HAPTIC_DAMPER\n  \\sa SDL_HAPTIC_INERTIA\n  \\sa SDL_HAPTIC_FRICTION\n  \\sa SDL_HapticEffect"]
 #[repr(C)]
 #[derive(Copy, Clone)]
 pub struct SDL_HapticCondition {
-    #[doc = "< ::SDL_HAPTIC_SPRING, ::SDL_HAPTIC_DAMPER,"]
-    #[doc = "::SDL_HAPTIC_INERTIA or ::SDL_HAPTIC_FRICTION"]
+    #[doc = "< ::SDL_HAPTIC_SPRING, ::SDL_HAPTIC_DAMPER,\n::SDL_HAPTIC_INERTIA or ::SDL_HAPTIC_FRICTION"]
     pub type_: Uint16,
     #[doc = "< Direction of the effect - Not used ATM."]
     pub direction: SDL_HapticDirection,
@@ -20088,6 +13639,9 @@ pub struct SDL_HapticCondition {
 }
 #[test]
 fn bindgen_test_layout_SDL_HapticCondition() {
+    const UNINIT: ::core::mem::MaybeUninit<SDL_HapticCondition> =
+        ::core::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::core::mem::size_of::<SDL_HapticCondition>(),
         68usize,
@@ -20099,7 +13653,7 @@ fn bindgen_test_layout_SDL_HapticCondition() {
         concat!("Alignment of ", stringify!(SDL_HapticCondition))
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_HapticCondition>())).type_ as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -20109,7 +13663,7 @@ fn bindgen_test_layout_SDL_HapticCondition() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_HapticCondition>())).direction as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).direction) as usize - ptr as usize },
         4usize,
         concat!(
             "Offset of field: ",
@@ -20119,7 +13673,7 @@ fn bindgen_test_layout_SDL_HapticCondition() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_HapticCondition>())).length as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).length) as usize - ptr as usize },
         20usize,
         concat!(
             "Offset of field: ",
@@ -20129,7 +13683,7 @@ fn bindgen_test_layout_SDL_HapticCondition() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_HapticCondition>())).delay as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).delay) as usize - ptr as usize },
         24usize,
         concat!(
             "Offset of field: ",
@@ -20139,7 +13693,7 @@ fn bindgen_test_layout_SDL_HapticCondition() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_HapticCondition>())).button as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).button) as usize - ptr as usize },
         26usize,
         concat!(
             "Offset of field: ",
@@ -20149,7 +13703,7 @@ fn bindgen_test_layout_SDL_HapticCondition() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_HapticCondition>())).interval as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).interval) as usize - ptr as usize },
         28usize,
         concat!(
             "Offset of field: ",
@@ -20159,7 +13713,7 @@ fn bindgen_test_layout_SDL_HapticCondition() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_HapticCondition>())).right_sat as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).right_sat) as usize - ptr as usize },
         30usize,
         concat!(
             "Offset of field: ",
@@ -20169,7 +13723,7 @@ fn bindgen_test_layout_SDL_HapticCondition() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_HapticCondition>())).left_sat as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).left_sat) as usize - ptr as usize },
         36usize,
         concat!(
             "Offset of field: ",
@@ -20179,9 +13733,7 @@ fn bindgen_test_layout_SDL_HapticCondition() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::core::ptr::null::<SDL_HapticCondition>())).right_coeff as *const _ as usize
-        },
+        unsafe { ::core::ptr::addr_of!((*ptr).right_coeff) as usize - ptr as usize },
         42usize,
         concat!(
             "Offset of field: ",
@@ -20191,7 +13743,7 @@ fn bindgen_test_layout_SDL_HapticCondition() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_HapticCondition>())).left_coeff as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).left_coeff) as usize - ptr as usize },
         48usize,
         concat!(
             "Offset of field: ",
@@ -20201,7 +13753,7 @@ fn bindgen_test_layout_SDL_HapticCondition() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_HapticCondition>())).deadband as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).deadband) as usize - ptr as usize },
         54usize,
         concat!(
             "Offset of field: ",
@@ -20211,7 +13763,7 @@ fn bindgen_test_layout_SDL_HapticCondition() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_HapticCondition>())).center as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).center) as usize - ptr as usize },
         60usize,
         concat!(
             "Offset of field: ",
@@ -20221,17 +13773,7 @@ fn bindgen_test_layout_SDL_HapticCondition() {
         )
     );
 }
-#[doc = "  \\brief A structure containing a template for a Ramp effect."]
-#[doc = ""]
-#[doc = "  This struct is exclusively for the ::SDL_HAPTIC_RAMP effect."]
-#[doc = ""]
-#[doc = "  The ramp effect starts at start strength and ends at end strength."]
-#[doc = "  It augments in linear fashion.  If you use attack and fade with a ramp"]
-#[doc = "  the effects get added to the ramp effect making the effect become"]
-#[doc = "  quadratic instead of linear."]
-#[doc = ""]
-#[doc = "  \\sa SDL_HAPTIC_RAMP"]
-#[doc = "  \\sa SDL_HapticEffect"]
+#[doc = "  \\brief A structure containing a template for a Ramp effect.\n\n  This struct is exclusively for the ::SDL_HAPTIC_RAMP effect.\n\n  The ramp effect starts at start strength and ends at end strength.\n  It augments in linear fashion.  If you use attack and fade with a ramp\n  the effects get added to the ramp effect making the effect become\n  quadratic instead of linear.\n\n  \\sa SDL_HAPTIC_RAMP\n  \\sa SDL_HapticEffect"]
 #[repr(C)]
 #[derive(Copy, Clone)]
 pub struct SDL_HapticRamp {
@@ -20262,6 +13804,8 @@ pub struct SDL_HapticRamp {
 }
 #[test]
 fn bindgen_test_layout_SDL_HapticRamp() {
+    const UNINIT: ::core::mem::MaybeUninit<SDL_HapticRamp> = ::core::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::core::mem::size_of::<SDL_HapticRamp>(),
         44usize,
@@ -20273,7 +13817,7 @@ fn bindgen_test_layout_SDL_HapticRamp() {
         concat!("Alignment of ", stringify!(SDL_HapticRamp))
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_HapticRamp>())).type_ as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -20283,7 +13827,7 @@ fn bindgen_test_layout_SDL_HapticRamp() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_HapticRamp>())).direction as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).direction) as usize - ptr as usize },
         4usize,
         concat!(
             "Offset of field: ",
@@ -20293,7 +13837,7 @@ fn bindgen_test_layout_SDL_HapticRamp() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_HapticRamp>())).length as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).length) as usize - ptr as usize },
         20usize,
         concat!(
             "Offset of field: ",
@@ -20303,7 +13847,7 @@ fn bindgen_test_layout_SDL_HapticRamp() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_HapticRamp>())).delay as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).delay) as usize - ptr as usize },
         24usize,
         concat!(
             "Offset of field: ",
@@ -20313,7 +13857,7 @@ fn bindgen_test_layout_SDL_HapticRamp() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_HapticRamp>())).button as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).button) as usize - ptr as usize },
         26usize,
         concat!(
             "Offset of field: ",
@@ -20323,7 +13867,7 @@ fn bindgen_test_layout_SDL_HapticRamp() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_HapticRamp>())).interval as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).interval) as usize - ptr as usize },
         28usize,
         concat!(
             "Offset of field: ",
@@ -20333,7 +13877,7 @@ fn bindgen_test_layout_SDL_HapticRamp() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_HapticRamp>())).start as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).start) as usize - ptr as usize },
         30usize,
         concat!(
             "Offset of field: ",
@@ -20343,7 +13887,7 @@ fn bindgen_test_layout_SDL_HapticRamp() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_HapticRamp>())).end as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).end) as usize - ptr as usize },
         32usize,
         concat!(
             "Offset of field: ",
@@ -20353,7 +13897,7 @@ fn bindgen_test_layout_SDL_HapticRamp() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_HapticRamp>())).attack_length as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).attack_length) as usize - ptr as usize },
         34usize,
         concat!(
             "Offset of field: ",
@@ -20363,7 +13907,7 @@ fn bindgen_test_layout_SDL_HapticRamp() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_HapticRamp>())).attack_level as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).attack_level) as usize - ptr as usize },
         36usize,
         concat!(
             "Offset of field: ",
@@ -20373,7 +13917,7 @@ fn bindgen_test_layout_SDL_HapticRamp() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_HapticRamp>())).fade_length as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).fade_length) as usize - ptr as usize },
         38usize,
         concat!(
             "Offset of field: ",
@@ -20383,7 +13927,7 @@ fn bindgen_test_layout_SDL_HapticRamp() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_HapticRamp>())).fade_level as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).fade_level) as usize - ptr as usize },
         40usize,
         concat!(
             "Offset of field: ",
@@ -20393,16 +13937,7 @@ fn bindgen_test_layout_SDL_HapticRamp() {
         )
     );
 }
-#[doc = " \\brief A structure containing a template for a Left/Right effect."]
-#[doc = ""]
-#[doc = " This struct is exclusively for the ::SDL_HAPTIC_LEFTRIGHT effect."]
-#[doc = ""]
-#[doc = " The Left/Right effect is used to explicitly control the large and small"]
-#[doc = " motors, commonly found in modern game controllers. The small (right) motor"]
-#[doc = " is high frequency, and the large (left) motor is low frequency."]
-#[doc = ""]
-#[doc = " \\sa SDL_HAPTIC_LEFTRIGHT"]
-#[doc = " \\sa SDL_HapticEffect"]
+#[doc = " \\brief A structure containing a template for a Left/Right effect.\n\n This struct is exclusively for the ::SDL_HAPTIC_LEFTRIGHT effect.\n\n The Left/Right effect is used to explicitly control the large and small\n motors, commonly found in modern game controllers. The small (right) motor\n is high frequency, and the large (left) motor is low frequency.\n\n \\sa SDL_HAPTIC_LEFTRIGHT\n \\sa SDL_HapticEffect"]
 #[repr(C)]
 #[derive(Copy, Clone)]
 pub struct SDL_HapticLeftRight {
@@ -20417,6 +13952,9 @@ pub struct SDL_HapticLeftRight {
 }
 #[test]
 fn bindgen_test_layout_SDL_HapticLeftRight() {
+    const UNINIT: ::core::mem::MaybeUninit<SDL_HapticLeftRight> =
+        ::core::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::core::mem::size_of::<SDL_HapticLeftRight>(),
         12usize,
@@ -20428,7 +13966,7 @@ fn bindgen_test_layout_SDL_HapticLeftRight() {
         concat!("Alignment of ", stringify!(SDL_HapticLeftRight))
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_HapticLeftRight>())).type_ as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -20438,7 +13976,7 @@ fn bindgen_test_layout_SDL_HapticLeftRight() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_HapticLeftRight>())).length as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).length) as usize - ptr as usize },
         4usize,
         concat!(
             "Offset of field: ",
@@ -20448,9 +13986,7 @@ fn bindgen_test_layout_SDL_HapticLeftRight() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::core::ptr::null::<SDL_HapticLeftRight>())).large_magnitude as *const _ as usize
-        },
+        unsafe { ::core::ptr::addr_of!((*ptr).large_magnitude) as usize - ptr as usize },
         8usize,
         concat!(
             "Offset of field: ",
@@ -20460,9 +13996,7 @@ fn bindgen_test_layout_SDL_HapticLeftRight() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::core::ptr::null::<SDL_HapticLeftRight>())).small_magnitude as *const _ as usize
-        },
+        unsafe { ::core::ptr::addr_of!((*ptr).small_magnitude) as usize - ptr as usize },
         10usize,
         concat!(
             "Offset of field: ",
@@ -20472,19 +14006,7 @@ fn bindgen_test_layout_SDL_HapticLeftRight() {
         )
     );
 }
-#[doc = "  \\brief A structure containing a template for the ::SDL_HAPTIC_CUSTOM effect."]
-#[doc = ""]
-#[doc = "  This struct is exclusively for the ::SDL_HAPTIC_CUSTOM effect."]
-#[doc = ""]
-#[doc = "  A custom force feedback effect is much like a periodic effect, where the"]
-#[doc = "  application can define its exact shape.  You will have to allocate the"]
-#[doc = "  data yourself.  Data should consist of channels * samples Uint16 samples."]
-#[doc = ""]
-#[doc = "  If channels is one, the effect is rotated using the defined direction."]
-#[doc = "  Otherwise it uses the samples in data for the different axes."]
-#[doc = ""]
-#[doc = "  \\sa SDL_HAPTIC_CUSTOM"]
-#[doc = "  \\sa SDL_HapticEffect"]
+#[doc = "  \\brief A structure containing a template for the ::SDL_HAPTIC_CUSTOM effect.\n\n  This struct is exclusively for the ::SDL_HAPTIC_CUSTOM effect.\n\n  A custom force feedback effect is much like a periodic effect, where the\n  application can define its exact shape.  You will have to allocate the\n  data yourself.  Data should consist of channels * samples Uint16 samples.\n\n  If channels is one, the effect is rotated using the defined direction.\n  Otherwise it uses the samples in data for the different axes.\n\n  \\sa SDL_HAPTIC_CUSTOM\n  \\sa SDL_HapticEffect"]
 #[repr(C)]
 #[derive(Copy, Clone)]
 pub struct SDL_HapticCustom {
@@ -20519,6 +14041,8 @@ pub struct SDL_HapticCustom {
 }
 #[test]
 fn bindgen_test_layout_SDL_HapticCustom() {
+    const UNINIT: ::core::mem::MaybeUninit<SDL_HapticCustom> = ::core::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::core::mem::size_of::<SDL_HapticCustom>(),
         56usize,
@@ -20530,7 +14054,7 @@ fn bindgen_test_layout_SDL_HapticCustom() {
         concat!("Alignment of ", stringify!(SDL_HapticCustom))
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_HapticCustom>())).type_ as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -20540,7 +14064,7 @@ fn bindgen_test_layout_SDL_HapticCustom() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_HapticCustom>())).direction as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).direction) as usize - ptr as usize },
         4usize,
         concat!(
             "Offset of field: ",
@@ -20550,7 +14074,7 @@ fn bindgen_test_layout_SDL_HapticCustom() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_HapticCustom>())).length as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).length) as usize - ptr as usize },
         20usize,
         concat!(
             "Offset of field: ",
@@ -20560,7 +14084,7 @@ fn bindgen_test_layout_SDL_HapticCustom() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_HapticCustom>())).delay as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).delay) as usize - ptr as usize },
         24usize,
         concat!(
             "Offset of field: ",
@@ -20570,7 +14094,7 @@ fn bindgen_test_layout_SDL_HapticCustom() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_HapticCustom>())).button as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).button) as usize - ptr as usize },
         26usize,
         concat!(
             "Offset of field: ",
@@ -20580,7 +14104,7 @@ fn bindgen_test_layout_SDL_HapticCustom() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_HapticCustom>())).interval as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).interval) as usize - ptr as usize },
         28usize,
         concat!(
             "Offset of field: ",
@@ -20590,7 +14114,7 @@ fn bindgen_test_layout_SDL_HapticCustom() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_HapticCustom>())).channels as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).channels) as usize - ptr as usize },
         30usize,
         concat!(
             "Offset of field: ",
@@ -20600,7 +14124,7 @@ fn bindgen_test_layout_SDL_HapticCustom() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_HapticCustom>())).period as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).period) as usize - ptr as usize },
         32usize,
         concat!(
             "Offset of field: ",
@@ -20610,7 +14134,7 @@ fn bindgen_test_layout_SDL_HapticCustom() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_HapticCustom>())).samples as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).samples) as usize - ptr as usize },
         34usize,
         concat!(
             "Offset of field: ",
@@ -20620,7 +14144,7 @@ fn bindgen_test_layout_SDL_HapticCustom() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_HapticCustom>())).data as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
         40usize,
         concat!(
             "Offset of field: ",
@@ -20630,7 +14154,7 @@ fn bindgen_test_layout_SDL_HapticCustom() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_HapticCustom>())).attack_length as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).attack_length) as usize - ptr as usize },
         48usize,
         concat!(
             "Offset of field: ",
@@ -20640,7 +14164,7 @@ fn bindgen_test_layout_SDL_HapticCustom() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_HapticCustom>())).attack_level as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).attack_level) as usize - ptr as usize },
         50usize,
         concat!(
             "Offset of field: ",
@@ -20650,7 +14174,7 @@ fn bindgen_test_layout_SDL_HapticCustom() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_HapticCustom>())).fade_length as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).fade_length) as usize - ptr as usize },
         52usize,
         concat!(
             "Offset of field: ",
@@ -20660,7 +14184,7 @@ fn bindgen_test_layout_SDL_HapticCustom() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_HapticCustom>())).fade_level as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).fade_level) as usize - ptr as usize },
         54usize,
         concat!(
             "Offset of field: ",
@@ -20670,73 +14194,7 @@ fn bindgen_test_layout_SDL_HapticCustom() {
         )
     );
 }
-#[doc = "  \\brief The generic template for any haptic effect."]
-#[doc = ""]
-#[doc = "  All values max at 32767 (0x7FFF).  Signed values also can be negative."]
-#[doc = "  Time values unless specified otherwise are in milliseconds."]
-#[doc = ""]
-#[doc = "  You can also pass ::SDL_HAPTIC_INFINITY to length instead of a 0-32767"]
-#[doc = "  value.  Neither delay, interval, attack_length nor fade_length support"]
-#[doc = "  ::SDL_HAPTIC_INFINITY.  Fade will also not be used since effect never ends."]
-#[doc = ""]
-#[doc = "  Additionally, the ::SDL_HAPTIC_RAMP effect does not support a duration of"]
-#[doc = "  ::SDL_HAPTIC_INFINITY."]
-#[doc = ""]
-#[doc = "  Button triggers may not be supported on all devices, it is advised to not"]
-#[doc = "  use them if possible.  Buttons start at index 1 instead of index 0 like"]
-#[doc = "  the joystick."]
-#[doc = ""]
-#[doc = "  If both attack_length and fade_level are 0, the envelope is not used,"]
-#[doc = "  otherwise both values are used."]
-#[doc = ""]
-#[doc = "  Common parts:"]
-#[doc = "  \\code"]
-#[doc = "  // Replay - All effects have this"]
-#[doc = "  Uint32 length;        // Duration of effect (ms)."]
-#[doc = "  Uint16 delay;         // Delay before starting effect."]
-#[doc = ""]
-#[doc = "  // Trigger - All effects have this"]
-#[doc = "  Uint16 button;        // Button that triggers effect."]
-#[doc = "  Uint16 interval;      // How soon before effect can be triggered again."]
-#[doc = ""]
-#[doc = "  // Envelope - All effects except condition effects have this"]
-#[doc = "  Uint16 attack_length; // Duration of the attack (ms)."]
-#[doc = "  Uint16 attack_level;  // Level at the start of the attack."]
-#[doc = "  Uint16 fade_length;   // Duration of the fade out (ms)."]
-#[doc = "  Uint16 fade_level;    // Level at the end of the fade."]
-#[doc = "  \\endcode"]
-#[doc = ""]
-#[doc = ""]
-#[doc = "  Here we have an example of a constant effect evolution in time:"]
-#[doc = "  \\verbatim"]
-#[doc = "Strength"]
-#[doc = "^"]
-#[doc = "|"]
-#[doc = "|    effect level -->  _________________"]
-#[doc = "|                     /                 \\"]
-#[doc = "|                    /                   \\"]
-#[doc = "|                   /                     \\"]
-#[doc = "|                  /                       \\"]
-#[doc = "| attack_level --> |                        \\"]
-#[doc = "|                  |                        |  <---  fade_level"]
-#[doc = "|"]
-#[doc = "+--------------------------------------------------> Time"]
-#[doc = "[--]                 [---]"]
-#[doc = "attack_length        fade_length"]
-#[doc = ""]
-#[doc = "[------------------][-----------------------]"]
-#[doc = "delay               length"]
-#[doc = "\\endverbatim"]
-#[doc = ""]
-#[doc = "  Note either the attack_level or the fade_level may be above the actual"]
-#[doc = "  effect level."]
-#[doc = ""]
-#[doc = "  \\sa SDL_HapticConstant"]
-#[doc = "  \\sa SDL_HapticPeriodic"]
-#[doc = "  \\sa SDL_HapticCondition"]
-#[doc = "  \\sa SDL_HapticRamp"]
-#[doc = "  \\sa SDL_HapticLeftRight"]
-#[doc = "  \\sa SDL_HapticCustom"]
+#[doc = "  \\brief The generic template for any haptic effect.\n\n  All values max at 32767 (0x7FFF).  Signed values also can be negative.\n  Time values unless specified otherwise are in milliseconds.\n\n  You can also pass ::SDL_HAPTIC_INFINITY to length instead of a 0-32767\n  value.  Neither delay, interval, attack_length nor fade_length support\n  ::SDL_HAPTIC_INFINITY.  Fade will also not be used since effect never ends.\n\n  Additionally, the ::SDL_HAPTIC_RAMP effect does not support a duration of\n  ::SDL_HAPTIC_INFINITY.\n\n  Button triggers may not be supported on all devices, it is advised to not\n  use them if possible.  Buttons start at index 1 instead of index 0 like\n  the joystick.\n\n  If both attack_length and fade_level are 0, the envelope is not used,\n  otherwise both values are used.\n\n  Common parts:\n  \\code\n  // Replay - All effects have this\n  Uint32 length;        // Duration of effect (ms).\n  Uint16 delay;         // Delay before starting effect.\n\n  // Trigger - All effects have this\n  Uint16 button;        // Button that triggers effect.\n  Uint16 interval;      // How soon before effect can be triggered again.\n\n  // Envelope - All effects except condition effects have this\n  Uint16 attack_length; // Duration of the attack (ms).\n  Uint16 attack_level;  // Level at the start of the attack.\n  Uint16 fade_length;   // Duration of the fade out (ms).\n  Uint16 fade_level;    // Level at the end of the fade.\n  \\endcode\n\n\n  Here we have an example of a constant effect evolution in time:\n  \\verbatim\nStrength\n^\n|\n|    effect level -->  _________________\n|                     /                 \\\n|                    /                   \\\n|                   /                     \\\n|                  /                       \\\n| attack_level --> |                        \\\n|                  |                        |  <---  fade_level\n|\n+--------------------------------------------------> Time\n[--]                 [---]\nattack_length        fade_length\n\n[------------------][-----------------------]\ndelay               length\n\\endverbatim\n\n  Note either the attack_level or the fade_level may be above the actual\n  effect level.\n\n  \\sa SDL_HapticConstant\n  \\sa SDL_HapticPeriodic\n  \\sa SDL_HapticCondition\n  \\sa SDL_HapticRamp\n  \\sa SDL_HapticLeftRight\n  \\sa SDL_HapticCustom"]
 #[repr(C)]
 #[derive(Copy, Clone)]
 pub union SDL_HapticEffect {
@@ -20754,10 +14212,11 @@ pub union SDL_HapticEffect {
     pub leftright: SDL_HapticLeftRight,
     #[doc = "< Custom effect."]
     pub custom: SDL_HapticCustom,
-    _bindgen_union_align: [u64; 9usize],
 }
 #[test]
 fn bindgen_test_layout_SDL_HapticEffect() {
+    const UNINIT: ::core::mem::MaybeUninit<SDL_HapticEffect> = ::core::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::core::mem::size_of::<SDL_HapticEffect>(),
         72usize,
@@ -20769,7 +14228,7 @@ fn bindgen_test_layout_SDL_HapticEffect() {
         concat!("Alignment of ", stringify!(SDL_HapticEffect))
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_HapticEffect>())).type_ as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -20779,7 +14238,7 @@ fn bindgen_test_layout_SDL_HapticEffect() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_HapticEffect>())).constant as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).constant) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -20789,7 +14248,7 @@ fn bindgen_test_layout_SDL_HapticEffect() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_HapticEffect>())).periodic as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).periodic) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -20799,7 +14258,7 @@ fn bindgen_test_layout_SDL_HapticEffect() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_HapticEffect>())).condition as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).condition) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -20809,7 +14268,7 @@ fn bindgen_test_layout_SDL_HapticEffect() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_HapticEffect>())).ramp as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).ramp) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -20819,7 +14278,7 @@ fn bindgen_test_layout_SDL_HapticEffect() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_HapticEffect>())).leftright as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).leftright) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -20829,7 +14288,7 @@ fn bindgen_test_layout_SDL_HapticEffect() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_HapticEffect>())).custom as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).custom) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -20840,266 +14299,77 @@ fn bindgen_test_layout_SDL_HapticEffect() {
     );
 }
 extern "C" {
-    #[doc = " Count the number of haptic devices attached to the system."]
-    #[doc = ""]
-    #[doc = " \\returns the number of haptic devices detected on the system or a negative"]
-    #[doc = "          error code on failure; call SDL_GetError() for more information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_HapticName"]
+    #[doc = " Count the number of haptic devices attached to the system.\n\n \\returns the number of haptic devices detected on the system or a negative\n          error code on failure; call SDL_GetError() for more information.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_HapticName"]
     pub fn SDL_NumHaptics() -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Get the implementation dependent name of a haptic device."]
-    #[doc = ""]
-    #[doc = " This can be called before any joysticks are opened. If no name can be"]
-    #[doc = " found, this function returns NULL."]
-    #[doc = ""]
-    #[doc = " \\param device_index index of the device to query."]
-    #[doc = " \\returns the name of the device or NULL on failure; call SDL_GetError() for"]
-    #[doc = "          more information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_NumHaptics"]
+    #[doc = " Get the implementation dependent name of a haptic device.\n\n This can be called before any joysticks are opened. If no name can be\n found, this function returns NULL.\n\n \\param device_index index of the device to query.\n \\returns the name of the device or NULL on failure; call SDL_GetError() for\n          more information.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_NumHaptics"]
     pub fn SDL_HapticName(device_index: libc::c_int) -> *const libc::c_char;
 }
 extern "C" {
-    #[doc = " Open a haptic device for use."]
-    #[doc = ""]
-    #[doc = " The index passed as an argument refers to the N'th haptic device on this"]
-    #[doc = " system."]
-    #[doc = ""]
-    #[doc = " When opening a haptic device, its gain will be set to maximum and"]
-    #[doc = " autocenter will be disabled. To modify these values use SDL_HapticSetGain()"]
-    #[doc = " and SDL_HapticSetAutocenter()."]
-    #[doc = ""]
-    #[doc = " \\param device_index index of the device to open"]
-    #[doc = " \\returns the device identifier or NULL on failure; call SDL_GetError() for"]
-    #[doc = "          more information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_HapticClose"]
-    #[doc = " \\sa SDL_HapticIndex"]
-    #[doc = " \\sa SDL_HapticOpenFromJoystick"]
-    #[doc = " \\sa SDL_HapticOpenFromMouse"]
-    #[doc = " \\sa SDL_HapticPause"]
-    #[doc = " \\sa SDL_HapticSetAutocenter"]
-    #[doc = " \\sa SDL_HapticSetGain"]
-    #[doc = " \\sa SDL_HapticStopAll"]
+    #[doc = " Open a haptic device for use.\n\n The index passed as an argument refers to the N'th haptic device on this\n system.\n\n When opening a haptic device, its gain will be set to maximum and\n autocenter will be disabled. To modify these values use SDL_HapticSetGain()\n and SDL_HapticSetAutocenter().\n\n \\param device_index index of the device to open\n \\returns the device identifier or NULL on failure; call SDL_GetError() for\n          more information.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_HapticClose\n \\sa SDL_HapticIndex\n \\sa SDL_HapticOpenFromJoystick\n \\sa SDL_HapticOpenFromMouse\n \\sa SDL_HapticPause\n \\sa SDL_HapticSetAutocenter\n \\sa SDL_HapticSetGain\n \\sa SDL_HapticStopAll"]
     pub fn SDL_HapticOpen(device_index: libc::c_int) -> *mut SDL_Haptic;
 }
 extern "C" {
-    #[doc = " Check if the haptic device at the designated index has been opened."]
-    #[doc = ""]
-    #[doc = " \\param device_index the index of the device to query"]
-    #[doc = " \\returns 1 if it has been opened, 0 if it hasn't or on failure; call"]
-    #[doc = "          SDL_GetError() for more information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_HapticIndex"]
-    #[doc = " \\sa SDL_HapticOpen"]
+    #[doc = " Check if the haptic device at the designated index has been opened.\n\n \\param device_index the index of the device to query\n \\returns 1 if it has been opened, 0 if it hasn't or on failure; call\n          SDL_GetError() for more information.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_HapticIndex\n \\sa SDL_HapticOpen"]
     pub fn SDL_HapticOpened(device_index: libc::c_int) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Get the index of a haptic device."]
-    #[doc = ""]
-    #[doc = " \\param haptic the SDL_Haptic device to query"]
-    #[doc = " \\returns the index of the specified haptic device or a negative error code"]
-    #[doc = "          on failure; call SDL_GetError() for more information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_HapticOpen"]
-    #[doc = " \\sa SDL_HapticOpened"]
+    #[doc = " Get the index of a haptic device.\n\n \\param haptic the SDL_Haptic device to query\n \\returns the index of the specified haptic device or a negative error code\n          on failure; call SDL_GetError() for more information.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_HapticOpen\n \\sa SDL_HapticOpened"]
     pub fn SDL_HapticIndex(haptic: *mut SDL_Haptic) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Query whether or not the current mouse has haptic capabilities."]
-    #[doc = ""]
-    #[doc = " \\returns SDL_TRUE if the mouse is haptic or SDL_FALSE if it isn't."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_HapticOpenFromMouse"]
+    #[doc = " Query whether or not the current mouse has haptic capabilities.\n\n \\returns SDL_TRUE if the mouse is haptic or SDL_FALSE if it isn't.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_HapticOpenFromMouse"]
     pub fn SDL_MouseIsHaptic() -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Try to open a haptic device from the current mouse."]
-    #[doc = ""]
-    #[doc = " \\returns the haptic device identifier or NULL on failure; call"]
-    #[doc = "          SDL_GetError() for more information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_HapticOpen"]
-    #[doc = " \\sa SDL_MouseIsHaptic"]
+    #[doc = " Try to open a haptic device from the current mouse.\n\n \\returns the haptic device identifier or NULL on failure; call\n          SDL_GetError() for more information.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_HapticOpen\n \\sa SDL_MouseIsHaptic"]
     pub fn SDL_HapticOpenFromMouse() -> *mut SDL_Haptic;
 }
 extern "C" {
-    #[doc = " Query if a joystick has haptic features."]
-    #[doc = ""]
-    #[doc = " \\param joystick the SDL_Joystick to test for haptic capabilities"]
-    #[doc = " \\returns SDL_TRUE if the joystick is haptic, SDL_FALSE if it isn't, or a"]
-    #[doc = "          negative error code on failure; call SDL_GetError() for more"]
-    #[doc = "          information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_HapticOpenFromJoystick"]
+    #[doc = " Query if a joystick has haptic features.\n\n \\param joystick the SDL_Joystick to test for haptic capabilities\n \\returns SDL_TRUE if the joystick is haptic, SDL_FALSE if it isn't, or a\n          negative error code on failure; call SDL_GetError() for more\n          information.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_HapticOpenFromJoystick"]
     pub fn SDL_JoystickIsHaptic(joystick: *mut SDL_Joystick) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Open a haptic device for use from a joystick device."]
-    #[doc = ""]
-    #[doc = " You must still close the haptic device separately. It will not be closed"]
-    #[doc = " with the joystick."]
-    #[doc = ""]
-    #[doc = " When opened from a joystick you should first close the haptic device before"]
-    #[doc = " closing the joystick device. If not, on some implementations the haptic"]
-    #[doc = " device will also get unallocated and you'll be unable to use force feedback"]
-    #[doc = " on that device."]
-    #[doc = ""]
-    #[doc = " \\param joystick the SDL_Joystick to create a haptic device from"]
-    #[doc = " \\returns a valid haptic device identifier on success or NULL on failure;"]
-    #[doc = "          call SDL_GetError() for more information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_HapticClose"]
-    #[doc = " \\sa SDL_HapticOpen"]
-    #[doc = " \\sa SDL_JoystickIsHaptic"]
+    #[doc = " Open a haptic device for use from a joystick device.\n\n You must still close the haptic device separately. It will not be closed\n with the joystick.\n\n When opened from a joystick you should first close the haptic device before\n closing the joystick device. If not, on some implementations the haptic\n device will also get unallocated and you'll be unable to use force feedback\n on that device.\n\n \\param joystick the SDL_Joystick to create a haptic device from\n \\returns a valid haptic device identifier on success or NULL on failure;\n          call SDL_GetError() for more information.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_HapticClose\n \\sa SDL_HapticOpen\n \\sa SDL_JoystickIsHaptic"]
     pub fn SDL_HapticOpenFromJoystick(joystick: *mut SDL_Joystick) -> *mut SDL_Haptic;
 }
 extern "C" {
-    #[doc = " Close a haptic device previously opened with SDL_HapticOpen()."]
-    #[doc = ""]
-    #[doc = " \\param haptic the SDL_Haptic device to close"]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_HapticOpen"]
+    #[doc = " Close a haptic device previously opened with SDL_HapticOpen().\n\n \\param haptic the SDL_Haptic device to close\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_HapticOpen"]
     pub fn SDL_HapticClose(haptic: *mut SDL_Haptic);
 }
 extern "C" {
-    #[doc = " Get the number of effects a haptic device can store."]
-    #[doc = ""]
-    #[doc = " On some platforms this isn't fully supported, and therefore is an"]
-    #[doc = " approximation. Always check to see if your created effect was actually"]
-    #[doc = " created and do not rely solely on SDL_HapticNumEffects()."]
-    #[doc = ""]
-    #[doc = " \\param haptic the SDL_Haptic device to query"]
-    #[doc = " \\returns the number of effects the haptic device can store or a negative"]
-    #[doc = "          error code on failure; call SDL_GetError() for more information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_HapticNumEffectsPlaying"]
-    #[doc = " \\sa SDL_HapticQuery"]
+    #[doc = " Get the number of effects a haptic device can store.\n\n On some platforms this isn't fully supported, and therefore is an\n approximation. Always check to see if your created effect was actually\n created and do not rely solely on SDL_HapticNumEffects().\n\n \\param haptic the SDL_Haptic device to query\n \\returns the number of effects the haptic device can store or a negative\n          error code on failure; call SDL_GetError() for more information.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_HapticNumEffectsPlaying\n \\sa SDL_HapticQuery"]
     pub fn SDL_HapticNumEffects(haptic: *mut SDL_Haptic) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Get the number of effects a haptic device can play at the same time."]
-    #[doc = ""]
-    #[doc = " This is not supported on all platforms, but will always return a value."]
-    #[doc = ""]
-    #[doc = " \\param haptic the SDL_Haptic device to query maximum playing effects"]
-    #[doc = " \\returns the number of effects the haptic device can play at the same time"]
-    #[doc = "          or a negative error code on failure; call SDL_GetError() for more"]
-    #[doc = "          information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_HapticNumEffects"]
-    #[doc = " \\sa SDL_HapticQuery"]
+    #[doc = " Get the number of effects a haptic device can play at the same time.\n\n This is not supported on all platforms, but will always return a value.\n\n \\param haptic the SDL_Haptic device to query maximum playing effects\n \\returns the number of effects the haptic device can play at the same time\n          or a negative error code on failure; call SDL_GetError() for more\n          information.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_HapticNumEffects\n \\sa SDL_HapticQuery"]
     pub fn SDL_HapticNumEffectsPlaying(haptic: *mut SDL_Haptic) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Get the haptic device's supported features in bitwise manner."]
-    #[doc = ""]
-    #[doc = " \\param haptic the SDL_Haptic device to query"]
-    #[doc = " \\returns a list of supported haptic features in bitwise manner (OR'd), or 0"]
-    #[doc = "          on failure; call SDL_GetError() for more information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_HapticEffectSupported"]
-    #[doc = " \\sa SDL_HapticNumEffects"]
+    #[doc = " Get the haptic device's supported features in bitwise manner.\n\n \\param haptic the SDL_Haptic device to query\n \\returns a list of supported haptic features in bitwise manner (OR'd), or 0\n          on failure; call SDL_GetError() for more information.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_HapticEffectSupported\n \\sa SDL_HapticNumEffects"]
     pub fn SDL_HapticQuery(haptic: *mut SDL_Haptic) -> libc::c_uint;
 }
 extern "C" {
-    #[doc = " Get the number of haptic axes the device has."]
-    #[doc = ""]
-    #[doc = " The number of haptic axes might be useful if working with the"]
-    #[doc = " SDL_HapticDirection effect."]
-    #[doc = ""]
-    #[doc = " \\param haptic the SDL_Haptic device to query"]
-    #[doc = " \\returns the number of axes on success or a negative error code on failure;"]
-    #[doc = "          call SDL_GetError() for more information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
+    #[doc = " Get the number of haptic axes the device has.\n\n The number of haptic axes might be useful if working with the\n SDL_HapticDirection effect.\n\n \\param haptic the SDL_Haptic device to query\n \\returns the number of axes on success or a negative error code on failure;\n          call SDL_GetError() for more information.\n\n \\since This function is available since SDL 2.0.0."]
     pub fn SDL_HapticNumAxes(haptic: *mut SDL_Haptic) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Check to see if an effect is supported by a haptic device."]
-    #[doc = ""]
-    #[doc = " \\param haptic the SDL_Haptic device to query"]
-    #[doc = " \\param effect the desired effect to query"]
-    #[doc = " \\returns SDL_TRUE if effect is supported, SDL_FALSE if it isn't, or a"]
-    #[doc = "          negative error code on failure; call SDL_GetError() for more"]
-    #[doc = "          information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_HapticNewEffect"]
-    #[doc = " \\sa SDL_HapticQuery"]
+    #[doc = " Check to see if an effect is supported by a haptic device.\n\n \\param haptic the SDL_Haptic device to query\n \\param effect the desired effect to query\n \\returns SDL_TRUE if effect is supported, SDL_FALSE if it isn't, or a\n          negative error code on failure; call SDL_GetError() for more\n          information.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_HapticNewEffect\n \\sa SDL_HapticQuery"]
     pub fn SDL_HapticEffectSupported(
         haptic: *mut SDL_Haptic,
         effect: *mut SDL_HapticEffect,
     ) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Create a new haptic effect on a specified device."]
-    #[doc = ""]
-    #[doc = " \\param haptic an SDL_Haptic device to create the effect on"]
-    #[doc = " \\param effect an SDL_HapticEffect structure containing the properties of"]
-    #[doc = "               the effect to create"]
-    #[doc = " \\returns the ID of the effect on success or a negative error code on"]
-    #[doc = "          failure; call SDL_GetError() for more information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_HapticDestroyEffect"]
-    #[doc = " \\sa SDL_HapticRunEffect"]
-    #[doc = " \\sa SDL_HapticUpdateEffect"]
+    #[doc = " Create a new haptic effect on a specified device.\n\n \\param haptic an SDL_Haptic device to create the effect on\n \\param effect an SDL_HapticEffect structure containing the properties of\n               the effect to create\n \\returns the ID of the effect on success or a negative error code on\n          failure; call SDL_GetError() for more information.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_HapticDestroyEffect\n \\sa SDL_HapticRunEffect\n \\sa SDL_HapticUpdateEffect"]
     pub fn SDL_HapticNewEffect(
         haptic: *mut SDL_Haptic,
         effect: *mut SDL_HapticEffect,
     ) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Update the properties of an effect."]
-    #[doc = ""]
-    #[doc = " Can be used dynamically, although behavior when dynamically changing"]
-    #[doc = " direction may be strange. Specifically the effect may re-upload itself and"]
-    #[doc = " start playing from the start. You also cannot change the type either when"]
-    #[doc = " running SDL_HapticUpdateEffect()."]
-    #[doc = ""]
-    #[doc = " \\param haptic the SDL_Haptic device that has the effect"]
-    #[doc = " \\param effect the identifier of the effect to update"]
-    #[doc = " \\param data an SDL_HapticEffect structure containing the new effect"]
-    #[doc = "             properties to use"]
-    #[doc = " \\returns 0 on success or a negative error code on failure; call"]
-    #[doc = "          SDL_GetError() for more information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_HapticDestroyEffect"]
-    #[doc = " \\sa SDL_HapticNewEffect"]
-    #[doc = " \\sa SDL_HapticRunEffect"]
+    #[doc = " Update the properties of an effect.\n\n Can be used dynamically, although behavior when dynamically changing\n direction may be strange. Specifically the effect may re-upload itself and\n start playing from the start. You also cannot change the type either when\n running SDL_HapticUpdateEffect().\n\n \\param haptic the SDL_Haptic device that has the effect\n \\param effect the identifier of the effect to update\n \\param data an SDL_HapticEffect structure containing the new effect\n             properties to use\n \\returns 0 on success or a negative error code on failure; call\n          SDL_GetError() for more information.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_HapticDestroyEffect\n \\sa SDL_HapticNewEffect\n \\sa SDL_HapticRunEffect"]
     pub fn SDL_HapticUpdateEffect(
         haptic: *mut SDL_Haptic,
         effect: libc::c_int,
@@ -21107,26 +14377,7 @@ extern "C" {
     ) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Run the haptic effect on its associated haptic device."]
-    #[doc = ""]
-    #[doc = " To repeat the effect over and over indefinitely, set `iterations` to"]
-    #[doc = " `SDL_HAPTIC_INFINITY`. (Repeats the envelope - attack and fade.) To make"]
-    #[doc = " one instance of the effect last indefinitely (so the effect does not fade),"]
-    #[doc = " set the effect's `length` in its structure/union to `SDL_HAPTIC_INFINITY`"]
-    #[doc = " instead."]
-    #[doc = ""]
-    #[doc = " \\param haptic the SDL_Haptic device to run the effect on"]
-    #[doc = " \\param effect the ID of the haptic effect to run"]
-    #[doc = " \\param iterations the number of iterations to run the effect; use"]
-    #[doc = "                   `SDL_HAPTIC_INFINITY` to repeat forever"]
-    #[doc = " \\returns 0 on success or a negative error code on failure; call"]
-    #[doc = "          SDL_GetError() for more information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_HapticDestroyEffect"]
-    #[doc = " \\sa SDL_HapticGetEffectStatus"]
-    #[doc = " \\sa SDL_HapticStopEffect"]
+    #[doc = " Run the haptic effect on its associated haptic device.\n\n To repeat the effect over and over indefinitely, set `iterations` to\n `SDL_HAPTIC_INFINITY`. (Repeats the envelope - attack and fade.) To make\n one instance of the effect last indefinitely (so the effect does not fade),\n set the effect's `length` in its structure/union to `SDL_HAPTIC_INFINITY`\n instead.\n\n \\param haptic the SDL_Haptic device to run the effect on\n \\param effect the ID of the haptic effect to run\n \\param iterations the number of iterations to run the effect; use\n                   `SDL_HAPTIC_INFINITY` to repeat forever\n \\returns 0 on success or a negative error code on failure; call\n          SDL_GetError() for more information.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_HapticDestroyEffect\n \\sa SDL_HapticGetEffectStatus\n \\sa SDL_HapticStopEffect"]
     pub fn SDL_HapticRunEffect(
         haptic: *mut SDL_Haptic,
         effect: libc::c_int,
@@ -21134,176 +14385,48 @@ extern "C" {
     ) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Stop the haptic effect on its associated haptic device."]
-    #[doc = ""]
-    #[doc = " *"]
-    #[doc = ""]
-    #[doc = " \\param haptic the SDL_Haptic device to stop the effect on"]
-    #[doc = " \\param effect the ID of the haptic effect to stop"]
-    #[doc = " \\returns 0 on success or a negative error code on failure; call"]
-    #[doc = "          SDL_GetError() for more information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_HapticDestroyEffect"]
-    #[doc = " \\sa SDL_HapticRunEffect"]
+    #[doc = " Stop the haptic effect on its associated haptic device.\n\n *\n\n \\param haptic the SDL_Haptic device to stop the effect on\n \\param effect the ID of the haptic effect to stop\n \\returns 0 on success or a negative error code on failure; call\n          SDL_GetError() for more information.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_HapticDestroyEffect\n \\sa SDL_HapticRunEffect"]
     pub fn SDL_HapticStopEffect(haptic: *mut SDL_Haptic, effect: libc::c_int) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Destroy a haptic effect on the device."]
-    #[doc = ""]
-    #[doc = " This will stop the effect if it's running. Effects are automatically"]
-    #[doc = " destroyed when the device is closed."]
-    #[doc = ""]
-    #[doc = " \\param haptic the SDL_Haptic device to destroy the effect on"]
-    #[doc = " \\param effect the ID of the haptic effect to destroy"]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_HapticNewEffect"]
+    #[doc = " Destroy a haptic effect on the device.\n\n This will stop the effect if it's running. Effects are automatically\n destroyed when the device is closed.\n\n \\param haptic the SDL_Haptic device to destroy the effect on\n \\param effect the ID of the haptic effect to destroy\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_HapticNewEffect"]
     pub fn SDL_HapticDestroyEffect(haptic: *mut SDL_Haptic, effect: libc::c_int);
 }
 extern "C" {
-    #[doc = " Get the status of the current effect on the specified haptic device."]
-    #[doc = ""]
-    #[doc = " Device must support the SDL_HAPTIC_STATUS feature."]
-    #[doc = ""]
-    #[doc = " \\param haptic the SDL_Haptic device to query for the effect status on"]
-    #[doc = " \\param effect the ID of the haptic effect to query its status"]
-    #[doc = " \\returns 0 if it isn't playing, 1 if it is playing, or a negative error"]
-    #[doc = "          code on failure; call SDL_GetError() for more information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_HapticRunEffect"]
-    #[doc = " \\sa SDL_HapticStopEffect"]
+    #[doc = " Get the status of the current effect on the specified haptic device.\n\n Device must support the SDL_HAPTIC_STATUS feature.\n\n \\param haptic the SDL_Haptic device to query for the effect status on\n \\param effect the ID of the haptic effect to query its status\n \\returns 0 if it isn't playing, 1 if it is playing, or a negative error\n          code on failure; call SDL_GetError() for more information.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_HapticRunEffect\n \\sa SDL_HapticStopEffect"]
     pub fn SDL_HapticGetEffectStatus(haptic: *mut SDL_Haptic, effect: libc::c_int) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Set the global gain of the specified haptic device."]
-    #[doc = ""]
-    #[doc = " Device must support the SDL_HAPTIC_GAIN feature."]
-    #[doc = ""]
-    #[doc = " The user may specify the maximum gain by setting the environment variable"]
-    #[doc = " `SDL_HAPTIC_GAIN_MAX` which should be between 0 and 100. All calls to"]
-    #[doc = " SDL_HapticSetGain() will scale linearly using `SDL_HAPTIC_GAIN_MAX` as the"]
-    #[doc = " maximum."]
-    #[doc = ""]
-    #[doc = " \\param haptic the SDL_Haptic device to set the gain on"]
-    #[doc = " \\param gain value to set the gain to, should be between 0 and 100 (0 - 100)"]
-    #[doc = " \\returns 0 on success or a negative error code on failure; call"]
-    #[doc = "          SDL_GetError() for more information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_HapticQuery"]
+    #[doc = " Set the global gain of the specified haptic device.\n\n Device must support the SDL_HAPTIC_GAIN feature.\n\n The user may specify the maximum gain by setting the environment variable\n `SDL_HAPTIC_GAIN_MAX` which should be between 0 and 100. All calls to\n SDL_HapticSetGain() will scale linearly using `SDL_HAPTIC_GAIN_MAX` as the\n maximum.\n\n \\param haptic the SDL_Haptic device to set the gain on\n \\param gain value to set the gain to, should be between 0 and 100 (0 - 100)\n \\returns 0 on success or a negative error code on failure; call\n          SDL_GetError() for more information.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_HapticQuery"]
     pub fn SDL_HapticSetGain(haptic: *mut SDL_Haptic, gain: libc::c_int) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Set the global autocenter of the device."]
-    #[doc = ""]
-    #[doc = " Autocenter should be between 0 and 100. Setting it to 0 will disable"]
-    #[doc = " autocentering."]
-    #[doc = ""]
-    #[doc = " Device must support the SDL_HAPTIC_AUTOCENTER feature."]
-    #[doc = ""]
-    #[doc = " \\param haptic the SDL_Haptic device to set autocentering on"]
-    #[doc = " \\param autocenter value to set autocenter to (0-100)"]
-    #[doc = " \\returns 0 on success or a negative error code on failure; call"]
-    #[doc = "          SDL_GetError() for more information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_HapticQuery"]
+    #[doc = " Set the global autocenter of the device.\n\n Autocenter should be between 0 and 100. Setting it to 0 will disable\n autocentering.\n\n Device must support the SDL_HAPTIC_AUTOCENTER feature.\n\n \\param haptic the SDL_Haptic device to set autocentering on\n \\param autocenter value to set autocenter to (0-100)\n \\returns 0 on success or a negative error code on failure; call\n          SDL_GetError() for more information.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_HapticQuery"]
     pub fn SDL_HapticSetAutocenter(haptic: *mut SDL_Haptic, autocenter: libc::c_int)
         -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Pause a haptic device."]
-    #[doc = ""]
-    #[doc = " Device must support the `SDL_HAPTIC_PAUSE` feature. Call"]
-    #[doc = " SDL_HapticUnpause() to resume playback."]
-    #[doc = ""]
-    #[doc = " Do not modify the effects nor add new ones while the device is paused. That"]
-    #[doc = " can cause all sorts of weird errors."]
-    #[doc = ""]
-    #[doc = " \\param haptic the SDL_Haptic device to pause"]
-    #[doc = " \\returns 0 on success or a negative error code on failure; call"]
-    #[doc = "          SDL_GetError() for more information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_HapticUnpause"]
+    #[doc = " Pause a haptic device.\n\n Device must support the `SDL_HAPTIC_PAUSE` feature. Call\n SDL_HapticUnpause() to resume playback.\n\n Do not modify the effects nor add new ones while the device is paused. That\n can cause all sorts of weird errors.\n\n \\param haptic the SDL_Haptic device to pause\n \\returns 0 on success or a negative error code on failure; call\n          SDL_GetError() for more information.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_HapticUnpause"]
     pub fn SDL_HapticPause(haptic: *mut SDL_Haptic) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Unpause a haptic device."]
-    #[doc = ""]
-    #[doc = " Call to unpause after SDL_HapticPause()."]
-    #[doc = ""]
-    #[doc = " \\param haptic the SDL_Haptic device to unpause"]
-    #[doc = " \\returns 0 on success or a negative error code on failure; call"]
-    #[doc = "          SDL_GetError() for more information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_HapticPause"]
+    #[doc = " Unpause a haptic device.\n\n Call to unpause after SDL_HapticPause().\n\n \\param haptic the SDL_Haptic device to unpause\n \\returns 0 on success or a negative error code on failure; call\n          SDL_GetError() for more information.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_HapticPause"]
     pub fn SDL_HapticUnpause(haptic: *mut SDL_Haptic) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Stop all the currently playing effects on a haptic device."]
-    #[doc = ""]
-    #[doc = " \\param haptic the SDL_Haptic device to stop"]
-    #[doc = " \\returns 0 on success or a negative error code on failure; call"]
-    #[doc = "          SDL_GetError() for more information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
+    #[doc = " Stop all the currently playing effects on a haptic device.\n\n \\param haptic the SDL_Haptic device to stop\n \\returns 0 on success or a negative error code on failure; call\n          SDL_GetError() for more information.\n\n \\since This function is available since SDL 2.0.0."]
     pub fn SDL_HapticStopAll(haptic: *mut SDL_Haptic) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Check whether rumble is supported on a haptic device."]
-    #[doc = ""]
-    #[doc = " \\param haptic haptic device to check for rumble support"]
-    #[doc = " \\returns SDL_TRUE if effect is supported, SDL_FALSE if it isn't, or a"]
-    #[doc = "          negative error code on failure; call SDL_GetError() for more"]
-    #[doc = "          information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_HapticRumbleInit"]
-    #[doc = " \\sa SDL_HapticRumblePlay"]
-    #[doc = " \\sa SDL_HapticRumbleStop"]
+    #[doc = " Check whether rumble is supported on a haptic device.\n\n \\param haptic haptic device to check for rumble support\n \\returns SDL_TRUE if effect is supported, SDL_FALSE if it isn't, or a\n          negative error code on failure; call SDL_GetError() for more\n          information.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_HapticRumbleInit\n \\sa SDL_HapticRumblePlay\n \\sa SDL_HapticRumbleStop"]
     pub fn SDL_HapticRumbleSupported(haptic: *mut SDL_Haptic) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Initialize a haptic device for simple rumble playback."]
-    #[doc = ""]
-    #[doc = " \\param haptic the haptic device to initialize for simple rumble playback"]
-    #[doc = " \\returns 0 on success or a negative error code on failure; call"]
-    #[doc = "          SDL_GetError() for more information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_HapticOpen"]
-    #[doc = " \\sa SDL_HapticRumblePlay"]
-    #[doc = " \\sa SDL_HapticRumbleStop"]
-    #[doc = " \\sa SDL_HapticRumbleSupported"]
+    #[doc = " Initialize a haptic device for simple rumble playback.\n\n \\param haptic the haptic device to initialize for simple rumble playback\n \\returns 0 on success or a negative error code on failure; call\n          SDL_GetError() for more information.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_HapticOpen\n \\sa SDL_HapticRumblePlay\n \\sa SDL_HapticRumbleStop\n \\sa SDL_HapticRumbleSupported"]
     pub fn SDL_HapticRumbleInit(haptic: *mut SDL_Haptic) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Run a simple rumble effect on a haptic device."]
-    #[doc = ""]
-    #[doc = " \\param haptic the haptic device to play the rumble effect on"]
-    #[doc = " \\param strength strength of the rumble to play as a 0-1 float value"]
-    #[doc = " \\param length length of the rumble to play in milliseconds"]
-    #[doc = " \\returns 0 on success or a negative error code on failure; call"]
-    #[doc = "          SDL_GetError() for more information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_HapticRumbleInit"]
-    #[doc = " \\sa SDL_HapticRumbleStop"]
-    #[doc = " \\sa SDL_HapticRumbleSupported"]
+    #[doc = " Run a simple rumble effect on a haptic device.\n\n \\param haptic the haptic device to play the rumble effect on\n \\param strength strength of the rumble to play as a 0-1 float value\n \\param length length of the rumble to play in milliseconds\n \\returns 0 on success or a negative error code on failure; call\n          SDL_GetError() for more information.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_HapticRumbleInit\n \\sa SDL_HapticRumbleStop\n \\sa SDL_HapticRumbleSupported"]
     pub fn SDL_HapticRumblePlay(
         haptic: *mut SDL_Haptic,
         strength: f32,
@@ -21311,17 +14434,7 @@ extern "C" {
     ) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Stop the simple rumble on a haptic device."]
-    #[doc = ""]
-    #[doc = " \\param haptic the haptic device to stop the rumble effect on"]
-    #[doc = " \\returns 0 on success or a negative error code on failure; call"]
-    #[doc = "          SDL_GetError() for more information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_HapticRumbleInit"]
-    #[doc = " \\sa SDL_HapticRumblePlay"]
-    #[doc = " \\sa SDL_HapticRumbleSupported"]
+    #[doc = " Stop the simple rumble on a haptic device.\n\n \\param haptic the haptic device to stop the rumble effect on\n \\returns 0 on success or a negative error code on failure; call\n          SDL_GetError() for more information.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_HapticRumbleInit\n \\sa SDL_HapticRumblePlay\n \\sa SDL_HapticRumbleSupported"]
     pub fn SDL_HapticRumbleStop(haptic: *mut SDL_Haptic) -> libc::c_int;
 }
 #[doc = "  \\brief  A handle representing an open HID device"]
@@ -21331,8 +14444,7 @@ pub struct SDL_hid_device_ {
     _unused: [u8; 0],
 }
 pub type SDL_hid_device = SDL_hid_device_;
-#[doc = " hidapi info structure */"]
-#[doc = "  \\brief  Information about a connected HID device"]
+#[doc = " hidapi info structure */\n/**\n  \\brief  Information about a connected HID device"]
 #[repr(C)]
 #[derive(Copy, Clone)]
 pub struct SDL_hid_device_info {
@@ -21344,28 +14456,19 @@ pub struct SDL_hid_device_info {
     pub product_id: libc::c_ushort,
     #[doc = " Serial Number"]
     pub serial_number: *mut wchar_t,
-    #[doc = " Device Release Number in binary-coded decimal,"]
-    #[doc = "also known as Device Version Number"]
+    #[doc = " Device Release Number in binary-coded decimal,\nalso known as Device Version Number"]
     pub release_number: libc::c_ushort,
     #[doc = " Manufacturer String"]
     pub manufacturer_string: *mut wchar_t,
     #[doc = " Product string"]
     pub product_string: *mut wchar_t,
-    #[doc = " Usage Page for this Device/Interface"]
-    #[doc = "(Windows/Mac only)."]
+    #[doc = " Usage Page for this Device/Interface\n(Windows/Mac only)."]
     pub usage_page: libc::c_ushort,
-    #[doc = " Usage for this Device/Interface"]
-    #[doc = "(Windows/Mac only)."]
+    #[doc = " Usage for this Device/Interface\n(Windows/Mac only)."]
     pub usage: libc::c_ushort,
-    #[doc = " The USB interface which this logical device"]
-    #[doc = "represents."]
-    #[doc = ""]
-    #[doc = " Valid on both Linux implementations in all cases."]
-    #[doc = " Valid on the Windows implementation only if the device"]
-    #[doc = "contains more than one interface."]
+    #[doc = " The USB interface which this logical device\nrepresents.\n\n Valid on both Linux implementations in all cases.\n Valid on the Windows implementation only if the device\ncontains more than one interface."]
     pub interface_number: libc::c_int,
-    #[doc = " Additional information about the USB interface."]
-    #[doc = "Valid on libusb and Android implementations."]
+    #[doc = " Additional information about the USB interface.\nValid on libusb and Android implementations."]
     pub interface_class: libc::c_int,
     pub interface_subclass: libc::c_int,
     pub interface_protocol: libc::c_int,
@@ -21374,6 +14477,9 @@ pub struct SDL_hid_device_info {
 }
 #[test]
 fn bindgen_test_layout_SDL_hid_device_info() {
+    const UNINIT: ::core::mem::MaybeUninit<SDL_hid_device_info> =
+        ::core::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::core::mem::size_of::<SDL_hid_device_info>(),
         80usize,
@@ -21385,7 +14491,7 @@ fn bindgen_test_layout_SDL_hid_device_info() {
         concat!("Alignment of ", stringify!(SDL_hid_device_info))
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_hid_device_info>())).path as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).path) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -21395,7 +14501,7 @@ fn bindgen_test_layout_SDL_hid_device_info() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_hid_device_info>())).vendor_id as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).vendor_id) as usize - ptr as usize },
         8usize,
         concat!(
             "Offset of field: ",
@@ -21405,7 +14511,7 @@ fn bindgen_test_layout_SDL_hid_device_info() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_hid_device_info>())).product_id as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).product_id) as usize - ptr as usize },
         10usize,
         concat!(
             "Offset of field: ",
@@ -21415,9 +14521,7 @@ fn bindgen_test_layout_SDL_hid_device_info() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::core::ptr::null::<SDL_hid_device_info>())).serial_number as *const _ as usize
-        },
+        unsafe { ::core::ptr::addr_of!((*ptr).serial_number) as usize - ptr as usize },
         16usize,
         concat!(
             "Offset of field: ",
@@ -21427,9 +14531,7 @@ fn bindgen_test_layout_SDL_hid_device_info() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::core::ptr::null::<SDL_hid_device_info>())).release_number as *const _ as usize
-        },
+        unsafe { ::core::ptr::addr_of!((*ptr).release_number) as usize - ptr as usize },
         24usize,
         concat!(
             "Offset of field: ",
@@ -21439,10 +14541,7 @@ fn bindgen_test_layout_SDL_hid_device_info() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::core::ptr::null::<SDL_hid_device_info>())).manufacturer_string as *const _
-                as usize
-        },
+        unsafe { ::core::ptr::addr_of!((*ptr).manufacturer_string) as usize - ptr as usize },
         32usize,
         concat!(
             "Offset of field: ",
@@ -21452,9 +14551,7 @@ fn bindgen_test_layout_SDL_hid_device_info() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::core::ptr::null::<SDL_hid_device_info>())).product_string as *const _ as usize
-        },
+        unsafe { ::core::ptr::addr_of!((*ptr).product_string) as usize - ptr as usize },
         40usize,
         concat!(
             "Offset of field: ",
@@ -21464,7 +14561,7 @@ fn bindgen_test_layout_SDL_hid_device_info() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_hid_device_info>())).usage_page as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).usage_page) as usize - ptr as usize },
         48usize,
         concat!(
             "Offset of field: ",
@@ -21474,7 +14571,7 @@ fn bindgen_test_layout_SDL_hid_device_info() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_hid_device_info>())).usage as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).usage) as usize - ptr as usize },
         50usize,
         concat!(
             "Offset of field: ",
@@ -21484,9 +14581,7 @@ fn bindgen_test_layout_SDL_hid_device_info() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::core::ptr::null::<SDL_hid_device_info>())).interface_number as *const _ as usize
-        },
+        unsafe { ::core::ptr::addr_of!((*ptr).interface_number) as usize - ptr as usize },
         52usize,
         concat!(
             "Offset of field: ",
@@ -21496,9 +14591,7 @@ fn bindgen_test_layout_SDL_hid_device_info() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::core::ptr::null::<SDL_hid_device_info>())).interface_class as *const _ as usize
-        },
+        unsafe { ::core::ptr::addr_of!((*ptr).interface_class) as usize - ptr as usize },
         56usize,
         concat!(
             "Offset of field: ",
@@ -21508,9 +14601,7 @@ fn bindgen_test_layout_SDL_hid_device_info() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::core::ptr::null::<SDL_hid_device_info>())).interface_subclass as *const _ as usize
-        },
+        unsafe { ::core::ptr::addr_of!((*ptr).interface_subclass) as usize - ptr as usize },
         60usize,
         concat!(
             "Offset of field: ",
@@ -21520,9 +14611,7 @@ fn bindgen_test_layout_SDL_hid_device_info() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::core::ptr::null::<SDL_hid_device_info>())).interface_protocol as *const _ as usize
-        },
+        unsafe { ::core::ptr::addr_of!((*ptr).interface_protocol) as usize - ptr as usize },
         64usize,
         concat!(
             "Offset of field: ",
@@ -21532,7 +14621,7 @@ fn bindgen_test_layout_SDL_hid_device_info() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_hid_device_info>())).next as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).next) as usize - ptr as usize },
         72usize,
         concat!(
             "Offset of field: ",
@@ -21543,106 +14632,30 @@ fn bindgen_test_layout_SDL_hid_device_info() {
     );
 }
 extern "C" {
-    #[doc = " Initialize the HIDAPI library."]
-    #[doc = ""]
-    #[doc = " This function initializes the HIDAPI library. Calling it is not strictly"]
-    #[doc = " necessary, as it will be called automatically by SDL_hid_enumerate() and"]
-    #[doc = " any of the SDL_hid_open_*() functions if it is needed. This function should"]
-    #[doc = " be called at the beginning of execution however, if there is a chance of"]
-    #[doc = " HIDAPI handles being opened by different threads simultaneously."]
-    #[doc = ""]
-    #[doc = " Each call to this function should have a matching call to SDL_hid_exit()"]
-    #[doc = ""]
-    #[doc = " \\returns 0 on success and -1 on error."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.18."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_hid_exit"]
+    #[doc = " Initialize the HIDAPI library.\n\n This function initializes the HIDAPI library. Calling it is not strictly\n necessary, as it will be called automatically by SDL_hid_enumerate() and\n any of the SDL_hid_open_*() functions if it is needed. This function should\n be called at the beginning of execution however, if there is a chance of\n HIDAPI handles being opened by different threads simultaneously.\n\n Each call to this function should have a matching call to SDL_hid_exit()\n\n \\returns 0 on success and -1 on error.\n\n \\since This function is available since SDL 2.0.18.\n\n \\sa SDL_hid_exit"]
     pub fn SDL_hid_init() -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Finalize the HIDAPI library."]
-    #[doc = ""]
-    #[doc = " This function frees all of the static data associated with HIDAPI. It"]
-    #[doc = " should be called at the end of execution to avoid memory leaks."]
-    #[doc = ""]
-    #[doc = " \\returns 0 on success and -1 on error."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.18."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_hid_init"]
+    #[doc = " Finalize the HIDAPI library.\n\n This function frees all of the static data associated with HIDAPI. It\n should be called at the end of execution to avoid memory leaks.\n\n \\returns 0 on success and -1 on error.\n\n \\since This function is available since SDL 2.0.18.\n\n \\sa SDL_hid_init"]
     pub fn SDL_hid_exit() -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Check to see if devices may have been added or removed."]
-    #[doc = ""]
-    #[doc = " Enumerating the HID devices is an expensive operation, so you can call this"]
-    #[doc = " to see if there have been any system device changes since the last call to"]
-    #[doc = " this function. A change in the counter returned doesn't necessarily mean"]
-    #[doc = " that anything has changed, but you can call SDL_hid_enumerate() to get an"]
-    #[doc = " updated device list."]
-    #[doc = ""]
-    #[doc = " Calling this function for the first time may cause a thread or other system"]
-    #[doc = " resource to be allocated to track device change notifications."]
-    #[doc = ""]
-    #[doc = " \\returns a change counter that is incremented with each potential device"]
-    #[doc = "          change, or 0 if device change detection isn't available."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.18."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_hid_enumerate"]
+    #[doc = " Check to see if devices may have been added or removed.\n\n Enumerating the HID devices is an expensive operation, so you can call this\n to see if there have been any system device changes since the last call to\n this function. A change in the counter returned doesn't necessarily mean\n that anything has changed, but you can call SDL_hid_enumerate() to get an\n updated device list.\n\n Calling this function for the first time may cause a thread or other system\n resource to be allocated to track device change notifications.\n\n \\returns a change counter that is incremented with each potential device\n          change, or 0 if device change detection isn't available.\n\n \\since This function is available since SDL 2.0.18.\n\n \\sa SDL_hid_enumerate"]
     pub fn SDL_hid_device_change_count() -> Uint32;
 }
 extern "C" {
-    #[doc = " Enumerate the HID Devices."]
-    #[doc = ""]
-    #[doc = " This function returns a linked list of all the HID devices attached to the"]
-    #[doc = " system which match vendor_id and product_id. If `vendor_id` is set to 0"]
-    #[doc = " then any vendor matches. If `product_id` is set to 0 then any product"]
-    #[doc = " matches. If `vendor_id` and `product_id` are both set to 0, then all HID"]
-    #[doc = " devices will be returned."]
-    #[doc = ""]
-    #[doc = " \\param vendor_id The Vendor ID (VID) of the types of device to open."]
-    #[doc = " \\param product_id The Product ID (PID) of the types of device to open."]
-    #[doc = " \\returns a pointer to a linked list of type SDL_hid_device_info, containing"]
-    #[doc = "          information about the HID devices attached to the system, or NULL"]
-    #[doc = "          in the case of failure. Free this linked list by calling"]
-    #[doc = "          SDL_hid_free_enumeration()."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.18."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_hid_device_change_count"]
+    #[doc = " Enumerate the HID Devices.\n\n This function returns a linked list of all the HID devices attached to the\n system which match vendor_id and product_id. If `vendor_id` is set to 0\n then any vendor matches. If `product_id` is set to 0 then any product\n matches. If `vendor_id` and `product_id` are both set to 0, then all HID\n devices will be returned.\n\n \\param vendor_id The Vendor ID (VID) of the types of device to open.\n \\param product_id The Product ID (PID) of the types of device to open.\n \\returns a pointer to a linked list of type SDL_hid_device_info, containing\n          information about the HID devices attached to the system, or NULL\n          in the case of failure. Free this linked list by calling\n          SDL_hid_free_enumeration().\n\n \\since This function is available since SDL 2.0.18.\n\n \\sa SDL_hid_device_change_count"]
     pub fn SDL_hid_enumerate(
         vendor_id: libc::c_ushort,
         product_id: libc::c_ushort,
     ) -> *mut SDL_hid_device_info;
 }
 extern "C" {
-    #[doc = " Free an enumeration Linked List"]
-    #[doc = ""]
-    #[doc = " This function frees a linked list created by SDL_hid_enumerate()."]
-    #[doc = ""]
-    #[doc = " \\param devs Pointer to a list of struct_device returned from"]
-    #[doc = "             SDL_hid_enumerate()."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.18."]
+    #[doc = " Free an enumeration Linked List\n\n This function frees a linked list created by SDL_hid_enumerate().\n\n \\param devs Pointer to a list of struct_device returned from\n             SDL_hid_enumerate().\n\n \\since This function is available since SDL 2.0.18."]
     pub fn SDL_hid_free_enumeration(devs: *mut SDL_hid_device_info);
 }
 extern "C" {
-    #[doc = " Open a HID device using a Vendor ID (VID), Product ID (PID) and optionally"]
-    #[doc = " a serial number."]
-    #[doc = ""]
-    #[doc = " If `serial_number` is NULL, the first device with the specified VID and PID"]
-    #[doc = " is opened."]
-    #[doc = ""]
-    #[doc = " \\param vendor_id The Vendor ID (VID) of the device to open."]
-    #[doc = " \\param product_id The Product ID (PID) of the device to open."]
-    #[doc = " \\param serial_number The Serial Number of the device to open (Optionally"]
-    #[doc = "                      NULL)."]
-    #[doc = " \\returns a pointer to a SDL_hid_device object on success or NULL on"]
-    #[doc = "          failure."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.18."]
+    #[doc = " Open a HID device using a Vendor ID (VID), Product ID (PID) and optionally\n a serial number.\n\n If `serial_number` is NULL, the first device with the specified VID and PID\n is opened.\n\n \\param vendor_id The Vendor ID (VID) of the device to open.\n \\param product_id The Product ID (PID) of the device to open.\n \\param serial_number The Serial Number of the device to open (Optionally\n                      NULL).\n \\returns a pointer to a SDL_hid_device object on success or NULL on\n          failure.\n\n \\since This function is available since SDL 2.0.18."]
     pub fn SDL_hid_open(
         vendor_id: libc::c_ushort,
         product_id: libc::c_ushort,
@@ -21650,269 +14663,108 @@ extern "C" {
     ) -> *mut SDL_hid_device;
 }
 extern "C" {
-    #[doc = " Open a HID device by its path name."]
-    #[doc = ""]
-    #[doc = " The path name be determined by calling SDL_hid_enumerate(), or a"]
-    #[doc = " platform-specific path name can be used (eg: /dev/hidraw0 on Linux)."]
-    #[doc = ""]
-    #[doc = " \\param path The path name of the device to open"]
-    #[doc = " \\returns a pointer to a SDL_hid_device object on success or NULL on"]
-    #[doc = "          failure."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.18."]
+    #[doc = " Open a HID device by its path name.\n\n The path name be determined by calling SDL_hid_enumerate(), or a\n platform-specific path name can be used (eg: /dev/hidraw0 on Linux).\n\n \\param path The path name of the device to open\n \\returns a pointer to a SDL_hid_device object on success or NULL on\n          failure.\n\n \\since This function is available since SDL 2.0.18."]
     pub fn SDL_hid_open_path(
         path: *const libc::c_char,
         bExclusive: libc::c_int,
     ) -> *mut SDL_hid_device;
 }
 extern "C" {
-    #[doc = " Write an Output report to a HID device."]
-    #[doc = ""]
-    #[doc = " The first byte of `data` must contain the Report ID. For devices which only"]
-    #[doc = " support a single report, this must be set to 0x0. The remaining bytes"]
-    #[doc = " contain the report data. Since the Report ID is mandatory, calls to"]
-    #[doc = " SDL_hid_write() will always contain one more byte than the report contains."]
-    #[doc = " For example, if a hid report is 16 bytes long, 17 bytes must be passed to"]
-    #[doc = " SDL_hid_write(), the Report ID (or 0x0, for devices with a single report),"]
-    #[doc = " followed by the report data (16 bytes). In this example, the length passed"]
-    #[doc = " in would be 17."]
-    #[doc = ""]
-    #[doc = " SDL_hid_write() will send the data on the first OUT endpoint, if one"]
-    #[doc = " exists. If it does not, it will send the data through the Control Endpoint"]
-    #[doc = " (Endpoint 0)."]
-    #[doc = ""]
-    #[doc = " \\param dev A device handle returned from SDL_hid_open()."]
-    #[doc = " \\param data The data to send, including the report number as the first"]
-    #[doc = "             byte."]
-    #[doc = " \\param length The length in bytes of the data to send."]
-    #[doc = " \\returns the actual number of bytes written and -1 on error."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.18."]
+    #[doc = " Write an Output report to a HID device.\n\n The first byte of `data` must contain the Report ID. For devices which only\n support a single report, this must be set to 0x0. The remaining bytes\n contain the report data. Since the Report ID is mandatory, calls to\n SDL_hid_write() will always contain one more byte than the report contains.\n For example, if a hid report is 16 bytes long, 17 bytes must be passed to\n SDL_hid_write(), the Report ID (or 0x0, for devices with a single report),\n followed by the report data (16 bytes). In this example, the length passed\n in would be 17.\n\n SDL_hid_write() will send the data on the first OUT endpoint, if one\n exists. If it does not, it will send the data through the Control Endpoint\n (Endpoint 0).\n\n \\param dev A device handle returned from SDL_hid_open().\n \\param data The data to send, including the report number as the first\n             byte.\n \\param length The length in bytes of the data to send.\n \\returns the actual number of bytes written and -1 on error.\n\n \\since This function is available since SDL 2.0.18."]
     pub fn SDL_hid_write(
         dev: *mut SDL_hid_device,
         data: *const libc::c_uchar,
-        length: size_t,
-    ) -> libc::c_int;
-}
-extern "C" {
-    #[doc = " Read an Input report from a HID device with timeout."]
-    #[doc = ""]
-    #[doc = " Input reports are returned to the host through the INTERRUPT IN endpoint."]
-    #[doc = " The first byte will contain the Report number if the device uses numbered"]
-    #[doc = " reports."]
-    #[doc = ""]
-    #[doc = " \\param dev A device handle returned from SDL_hid_open()."]
-    #[doc = " \\param data A buffer to put the read data into."]
-    #[doc = " \\param length The number of bytes to read. For devices with multiple"]
-    #[doc = "               reports, make sure to read an extra byte for the report"]
-    #[doc = "               number."]
-    #[doc = " \\param milliseconds timeout in milliseconds or -1 for blocking wait."]
-    #[doc = " \\returns the actual number of bytes read and -1 on error. If no packet was"]
-    #[doc = "          available to be read within the timeout period, this function"]
-    #[doc = "          returns 0."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.18."]
+        length: usize,
+    ) -> libc::c_int;
+}
+extern "C" {
+    #[doc = " Read an Input report from a HID device with timeout.\n\n Input reports are returned to the host through the INTERRUPT IN endpoint.\n The first byte will contain the Report number if the device uses numbered\n reports.\n\n \\param dev A device handle returned from SDL_hid_open().\n \\param data A buffer to put the read data into.\n \\param length The number of bytes to read. For devices with multiple\n               reports, make sure to read an extra byte for the report\n               number.\n \\param milliseconds timeout in milliseconds or -1 for blocking wait.\n \\returns the actual number of bytes read and -1 on error. If no packet was\n          available to be read within the timeout period, this function\n          returns 0.\n\n \\since This function is available since SDL 2.0.18."]
     pub fn SDL_hid_read_timeout(
         dev: *mut SDL_hid_device,
         data: *mut libc::c_uchar,
-        length: size_t,
+        length: usize,
         milliseconds: libc::c_int,
     ) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Read an Input report from a HID device."]
-    #[doc = ""]
-    #[doc = " Input reports are returned to the host through the INTERRUPT IN endpoint."]
-    #[doc = " The first byte will contain the Report number if the device uses numbered"]
-    #[doc = " reports."]
-    #[doc = ""]
-    #[doc = " \\param dev A device handle returned from SDL_hid_open()."]
-    #[doc = " \\param data A buffer to put the read data into."]
-    #[doc = " \\param length The number of bytes to read. For devices with multiple"]
-    #[doc = "               reports, make sure to read an extra byte for the report"]
-    #[doc = "               number."]
-    #[doc = " \\returns the actual number of bytes read and -1 on error. If no packet was"]
-    #[doc = "          available to be read and the handle is in non-blocking mode, this"]
-    #[doc = "          function returns 0."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.18."]
+    #[doc = " Read an Input report from a HID device.\n\n Input reports are returned to the host through the INTERRUPT IN endpoint.\n The first byte will contain the Report number if the device uses numbered\n reports.\n\n \\param dev A device handle returned from SDL_hid_open().\n \\param data A buffer to put the read data into.\n \\param length The number of bytes to read. For devices with multiple\n               reports, make sure to read an extra byte for the report\n               number.\n \\returns the actual number of bytes read and -1 on error. If no packet was\n          available to be read and the handle is in non-blocking mode, this\n          function returns 0.\n\n \\since This function is available since SDL 2.0.18."]
     pub fn SDL_hid_read(
         dev: *mut SDL_hid_device,
         data: *mut libc::c_uchar,
-        length: size_t,
-    ) -> libc::c_int;
-}
-extern "C" {
-    #[doc = " Set the device handle to be non-blocking."]
-    #[doc = ""]
-    #[doc = " In non-blocking mode calls to SDL_hid_read() will return immediately with a"]
-    #[doc = " value of 0 if there is no data to be read. In blocking mode, SDL_hid_read()"]
-    #[doc = " will wait (block) until there is data to read before returning."]
-    #[doc = ""]
-    #[doc = " Nonblocking can be turned on and off at any time."]
-    #[doc = ""]
-    #[doc = " \\param dev A device handle returned from SDL_hid_open()."]
-    #[doc = " \\param nonblock enable or not the nonblocking reads - 1 to enable"]
-    #[doc = "                 nonblocking - 0 to disable nonblocking."]
-    #[doc = " \\returns 0 on success and -1 on error."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.18."]
+        length: usize,
+    ) -> libc::c_int;
+}
+extern "C" {
+    #[doc = " Set the device handle to be non-blocking.\n\n In non-blocking mode calls to SDL_hid_read() will return immediately with a\n value of 0 if there is no data to be read. In blocking mode, SDL_hid_read()\n will wait (block) until there is data to read before returning.\n\n Nonblocking can be turned on and off at any time.\n\n \\param dev A device handle returned from SDL_hid_open().\n \\param nonblock enable or not the nonblocking reads - 1 to enable\n                 nonblocking - 0 to disable nonblocking.\n \\returns 0 on success and -1 on error.\n\n \\since This function is available since SDL 2.0.18."]
     pub fn SDL_hid_set_nonblocking(dev: *mut SDL_hid_device, nonblock: libc::c_int) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Send a Feature report to the device."]
-    #[doc = ""]
-    #[doc = " Feature reports are sent over the Control endpoint as a Set_Report"]
-    #[doc = " transfer. The first byte of `data` must contain the Report ID. For devices"]
-    #[doc = " which only support a single report, this must be set to 0x0. The remaining"]
-    #[doc = " bytes contain the report data. Since the Report ID is mandatory, calls to"]
-    #[doc = " SDL_hid_send_feature_report() will always contain one more byte than the"]
-    #[doc = " report contains. For example, if a hid report is 16 bytes long, 17 bytes"]
-    #[doc = " must be passed to SDL_hid_send_feature_report(): the Report ID (or 0x0, for"]
-    #[doc = " devices which do not use numbered reports), followed by the report data (16"]
-    #[doc = " bytes). In this example, the length passed in would be 17."]
-    #[doc = ""]
-    #[doc = " \\param dev A device handle returned from SDL_hid_open()."]
-    #[doc = " \\param data The data to send, including the report number as the first"]
-    #[doc = "             byte."]
-    #[doc = " \\param length The length in bytes of the data to send, including the report"]
-    #[doc = "               number."]
-    #[doc = " \\returns the actual number of bytes written and -1 on error."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.18."]
+    #[doc = " Send a Feature report to the device.\n\n Feature reports are sent over the Control endpoint as a Set_Report\n transfer. The first byte of `data` must contain the Report ID. For devices\n which only support a single report, this must be set to 0x0. The remaining\n bytes contain the report data. Since the Report ID is mandatory, calls to\n SDL_hid_send_feature_report() will always contain one more byte than the\n report contains. For example, if a hid report is 16 bytes long, 17 bytes\n must be passed to SDL_hid_send_feature_report(): the Report ID (or 0x0, for\n devices which do not use numbered reports), followed by the report data (16\n bytes). In this example, the length passed in would be 17.\n\n \\param dev A device handle returned from SDL_hid_open().\n \\param data The data to send, including the report number as the first\n             byte.\n \\param length The length in bytes of the data to send, including the report\n               number.\n \\returns the actual number of bytes written and -1 on error.\n\n \\since This function is available since SDL 2.0.18."]
     pub fn SDL_hid_send_feature_report(
         dev: *mut SDL_hid_device,
         data: *const libc::c_uchar,
-        length: size_t,
-    ) -> libc::c_int;
-}
-extern "C" {
-    #[doc = " Get a feature report from a HID device."]
-    #[doc = ""]
-    #[doc = " Set the first byte of `data` to the Report ID of the report to be read."]
-    #[doc = " Make sure to allow space for this extra byte in `data`. Upon return, the"]
-    #[doc = " first byte will still contain the Report ID, and the report data will start"]
-    #[doc = " in data[1]."]
-    #[doc = ""]
-    #[doc = " \\param dev A device handle returned from SDL_hid_open()."]
-    #[doc = " \\param data A buffer to put the read data into, including the Report ID."]
-    #[doc = "             Set the first byte of `data` to the Report ID of the report to"]
-    #[doc = "             be read, or set it to zero if your device does not use numbered"]
-    #[doc = "             reports."]
-    #[doc = " \\param length The number of bytes to read, including an extra byte for the"]
-    #[doc = "               report ID. The buffer can be longer than the actual report."]
-    #[doc = " \\returns the number of bytes read plus one for the report ID (which is"]
-    #[doc = "          still in the first byte), or -1 on error."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.18."]
+        length: usize,
+    ) -> libc::c_int;
+}
+extern "C" {
+    #[doc = " Get a feature report from a HID device.\n\n Set the first byte of `data` to the Report ID of the report to be read.\n Make sure to allow space for this extra byte in `data`. Upon return, the\n first byte will still contain the Report ID, and the report data will start\n in data[1].\n\n \\param dev A device handle returned from SDL_hid_open().\n \\param data A buffer to put the read data into, including the Report ID.\n             Set the first byte of `data` to the Report ID of the report to\n             be read, or set it to zero if your device does not use numbered\n             reports.\n \\param length The number of bytes to read, including an extra byte for the\n               report ID. The buffer can be longer than the actual report.\n \\returns the number of bytes read plus one for the report ID (which is\n          still in the first byte), or -1 on error.\n\n \\since This function is available since SDL 2.0.18."]
     pub fn SDL_hid_get_feature_report(
         dev: *mut SDL_hid_device,
         data: *mut libc::c_uchar,
-        length: size_t,
+        length: usize,
     ) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Close a HID device."]
-    #[doc = ""]
-    #[doc = " \\param dev A device handle returned from SDL_hid_open()."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.18."]
+    #[doc = " Close a HID device.\n\n \\param dev A device handle returned from SDL_hid_open().\n\n \\since This function is available since SDL 2.0.18."]
     pub fn SDL_hid_close(dev: *mut SDL_hid_device);
 }
 extern "C" {
-    #[doc = " Get The Manufacturer String from a HID device."]
-    #[doc = ""]
-    #[doc = " \\param dev A device handle returned from SDL_hid_open()."]
-    #[doc = " \\param string A wide string buffer to put the data into."]
-    #[doc = " \\param maxlen The length of the buffer in multiples of wchar_t."]
-    #[doc = " \\returns 0 on success and -1 on error."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.18."]
+    #[doc = " Get The Manufacturer String from a HID device.\n\n \\param dev A device handle returned from SDL_hid_open().\n \\param string A wide string buffer to put the data into.\n \\param maxlen The length of the buffer in multiples of wchar_t.\n \\returns 0 on success and -1 on error.\n\n \\since This function is available since SDL 2.0.18."]
     pub fn SDL_hid_get_manufacturer_string(
         dev: *mut SDL_hid_device,
         string: *mut wchar_t,
-        maxlen: size_t,
+        maxlen: usize,
     ) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Get The Product String from a HID device."]
-    #[doc = ""]
-    #[doc = " \\param dev A device handle returned from SDL_hid_open()."]
-    #[doc = " \\param string A wide string buffer to put the data into."]
-    #[doc = " \\param maxlen The length of the buffer in multiples of wchar_t."]
-    #[doc = " \\returns 0 on success and -1 on error."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.18."]
+    #[doc = " Get The Product String from a HID device.\n\n \\param dev A device handle returned from SDL_hid_open().\n \\param string A wide string buffer to put the data into.\n \\param maxlen The length of the buffer in multiples of wchar_t.\n \\returns 0 on success and -1 on error.\n\n \\since This function is available since SDL 2.0.18."]
     pub fn SDL_hid_get_product_string(
         dev: *mut SDL_hid_device,
         string: *mut wchar_t,
-        maxlen: size_t,
+        maxlen: usize,
     ) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Get The Serial Number String from a HID device."]
-    #[doc = ""]
-    #[doc = " \\param dev A device handle returned from SDL_hid_open()."]
-    #[doc = " \\param string A wide string buffer to put the data into."]
-    #[doc = " \\param maxlen The length of the buffer in multiples of wchar_t."]
-    #[doc = " \\returns 0 on success and -1 on error."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.18."]
+    #[doc = " Get The Serial Number String from a HID device.\n\n \\param dev A device handle returned from SDL_hid_open().\n \\param string A wide string buffer to put the data into.\n \\param maxlen The length of the buffer in multiples of wchar_t.\n \\returns 0 on success and -1 on error.\n\n \\since This function is available since SDL 2.0.18."]
     pub fn SDL_hid_get_serial_number_string(
         dev: *mut SDL_hid_device,
         string: *mut wchar_t,
-        maxlen: size_t,
+        maxlen: usize,
     ) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Get a string from a HID device, based on its string index."]
-    #[doc = ""]
-    #[doc = " \\param dev A device handle returned from SDL_hid_open()."]
-    #[doc = " \\param string_index The index of the string to get."]
-    #[doc = " \\param string A wide string buffer to put the data into."]
-    #[doc = " \\param maxlen The length of the buffer in multiples of wchar_t."]
-    #[doc = " \\returns 0 on success and -1 on error."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.18."]
+    #[doc = " Get a string from a HID device, based on its string index.\n\n \\param dev A device handle returned from SDL_hid_open().\n \\param string_index The index of the string to get.\n \\param string A wide string buffer to put the data into.\n \\param maxlen The length of the buffer in multiples of wchar_t.\n \\returns 0 on success and -1 on error.\n\n \\since This function is available since SDL 2.0.18."]
     pub fn SDL_hid_get_indexed_string(
         dev: *mut SDL_hid_device,
         string_index: libc::c_int,
         string: *mut wchar_t,
-        maxlen: size_t,
+        maxlen: usize,
     ) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Start or stop a BLE scan on iOS and tvOS to pair Steam Controllers"]
-    #[doc = ""]
-    #[doc = " \\param active SDL_TRUE to start the scan, SDL_FALSE to stop the scan"]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.18."]
+    #[doc = " Start or stop a BLE scan on iOS and tvOS to pair Steam Controllers\n\n \\param active SDL_TRUE to start the scan, SDL_FALSE to stop the scan\n\n \\since This function is available since SDL 2.0.18."]
     pub fn SDL_hid_ble_scan(active: SDL_bool);
 }
 #[repr(u32)]
 #[doc = "  \\brief  An enumeration of hint priorities"]
-#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
+#[derive(Copy, Clone, Hash, PartialEq, Eq)]
 pub enum SDL_HintPriority {
     SDL_HINT_DEFAULT = 0,
     SDL_HINT_NORMAL = 1,
     SDL_HINT_OVERRIDE = 2,
 }
 extern "C" {
-    #[doc = " Set a hint with a specific priority."]
-    #[doc = ""]
-    #[doc = " The priority controls the behavior when setting a hint that already has a"]
-    #[doc = " value. Hints will replace existing hints of their priority and lower."]
-    #[doc = " Environment variables are considered to have override priority."]
-    #[doc = ""]
-    #[doc = " \\param name the hint to set"]
-    #[doc = " \\param value the value of the hint variable"]
-    #[doc = " \\param priority the SDL_HintPriority level for the hint"]
-    #[doc = " \\returns SDL_TRUE if the hint was set, SDL_FALSE otherwise."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_GetHint"]
-    #[doc = " \\sa SDL_SetHint"]
+    #[doc = " Set a hint with a specific priority.\n\n The priority controls the behavior when setting a hint that already has a\n value. Hints will replace existing hints of their priority and lower.\n Environment variables are considered to have override priority.\n\n \\param name the hint to set\n \\param value the value of the hint variable\n \\param priority the SDL_HintPriority level for the hint\n \\returns SDL_TRUE if the hint was set, SDL_FALSE otherwise.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_GetHint\n \\sa SDL_SetHint"]
     pub fn SDL_SetHintWithPriority(
         name: *const libc::c_char,
         value: *const libc::c_char,
@@ -21920,54 +14772,26 @@ extern "C" {
     ) -> SDL_bool;
 }
 extern "C" {
-    #[doc = " Set a hint with normal priority."]
-    #[doc = ""]
-    #[doc = " Hints will not be set if there is an existing override hint or environment"]
-    #[doc = " variable that takes precedence. You can use SDL_SetHintWithPriority() to"]
-    #[doc = " set the hint with override priority instead."]
-    #[doc = ""]
-    #[doc = " \\param name the hint to set"]
-    #[doc = " \\param value the value of the hint variable"]
-    #[doc = " \\returns SDL_TRUE if the hint was set, SDL_FALSE otherwise."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_GetHint"]
-    #[doc = " \\sa SDL_SetHintWithPriority"]
+    #[doc = " Set a hint with normal priority.\n\n Hints will not be set if there is an existing override hint or environment\n variable that takes precedence. You can use SDL_SetHintWithPriority() to\n set the hint with override priority instead.\n\n \\param name the hint to set\n \\param value the value of the hint variable\n \\returns SDL_TRUE if the hint was set, SDL_FALSE otherwise.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_GetHint\n \\sa SDL_SetHintWithPriority"]
     pub fn SDL_SetHint(name: *const libc::c_char, value: *const libc::c_char) -> SDL_bool;
 }
 extern "C" {
-    #[doc = " Get the value of a hint."]
-    #[doc = ""]
-    #[doc = " \\param name the hint to query"]
-    #[doc = " \\returns the string value of a hint or NULL if the hint isn't set."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_SetHint"]
-    #[doc = " \\sa SDL_SetHintWithPriority"]
+    #[doc = " Reset a hint to the default value.\n\n This will reset a hint to the value of the environment variable, or NULL if\n the environment isn't set. Callbacks will be called normally with this\n change.\n\n \\param name the hint to set\n \\returns SDL_TRUE if the hint was set, SDL_FALSE otherwise.\n\n \\since This function is available since SDL 2.24.0.\n\n \\sa SDL_GetHint\n \\sa SDL_SetHint"]
+    pub fn SDL_ResetHint(name: *const libc::c_char) -> SDL_bool;
+}
+extern "C" {
+    #[doc = " Reset all hints to the default values.\n\n This will reset all hints to the value of the associated environment\n variable, or NULL if the environment isn't set. Callbacks will be called\n normally with this change.\n\n \\since This function is available since SDL 2.26.0.\n\n \\sa SDL_GetHint\n \\sa SDL_SetHint\n \\sa SDL_ResetHint"]
+    pub fn SDL_ResetHints();
+}
+extern "C" {
+    #[doc = " Get the value of a hint.\n\n \\param name the hint to query\n \\returns the string value of a hint or NULL if the hint isn't set.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_SetHint\n \\sa SDL_SetHintWithPriority"]
     pub fn SDL_GetHint(name: *const libc::c_char) -> *const libc::c_char;
 }
 extern "C" {
-    #[doc = " Get the boolean value of a hint variable."]
-    #[doc = ""]
-    #[doc = " \\param name the name of the hint to get the boolean value from"]
-    #[doc = " \\param default_value the value to return if the hint does not exist"]
-    #[doc = " \\returns the boolean value of a hint or the provided default value if the"]
-    #[doc = "          hint does not exist."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.5."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_GetHint"]
-    #[doc = " \\sa SDL_SetHint"]
+    #[doc = " Get the boolean value of a hint variable.\n\n \\param name the name of the hint to get the boolean value from\n \\param default_value the value to return if the hint does not exist\n \\returns the boolean value of a hint or the provided default value if the\n          hint does not exist.\n\n \\since This function is available since SDL 2.0.5.\n\n \\sa SDL_GetHint\n \\sa SDL_SetHint"]
     pub fn SDL_GetHintBoolean(name: *const libc::c_char, default_value: SDL_bool) -> SDL_bool;
 }
-#[doc = " Type definition of the hint callback function."]
-#[doc = ""]
-#[doc = " \\param userdata what was passed as `userdata` to SDL_AddHintCallback()"]
-#[doc = " \\param name what was passed as `name` to SDL_AddHintCallback()"]
-#[doc = " \\param oldValue the previous hint value"]
-#[doc = " \\param newValue the new value hint is to be set to"]
+#[doc = " Type definition of the hint callback function.\n\n \\param userdata what was passed as `userdata` to SDL_AddHintCallback()\n \\param name what was passed as `name` to SDL_AddHintCallback()\n \\param oldValue the previous hint value\n \\param newValue the new value hint is to be set to"]
 pub type SDL_HintCallback = ::core::option::Option<
     unsafe extern "C" fn(
         userdata: *mut libc::c_void,
@@ -21977,16 +14801,7 @@ pub type SDL_HintCallback = ::core::option::Option<
     ),
 >;
 extern "C" {
-    #[doc = " Add a function to watch a particular hint."]
-    #[doc = ""]
-    #[doc = " \\param name the hint to watch"]
-    #[doc = " \\param callback An SDL_HintCallback function that will be called when the"]
-    #[doc = "                 hint value changes"]
-    #[doc = " \\param userdata a pointer to pass to the callback function"]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_DelHintCallback"]
+    #[doc = " Add a function to watch a particular hint.\n\n \\param name the hint to watch\n \\param callback An SDL_HintCallback function that will be called when the\n                 hint value changes\n \\param userdata a pointer to pass to the callback function\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_DelHintCallback"]
     pub fn SDL_AddHintCallback(
         name: *const libc::c_char,
         callback: SDL_HintCallback,
@@ -21994,16 +14809,7 @@ extern "C" {
     );
 }
 extern "C" {
-    #[doc = " Remove a function watching a particular hint."]
-    #[doc = ""]
-    #[doc = " \\param name the hint being watched"]
-    #[doc = " \\param callback An SDL_HintCallback function that will be called when the"]
-    #[doc = "                 hint value changes"]
-    #[doc = " \\param userdata a pointer being passed to the callback function"]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_AddHintCallback"]
+    #[doc = " Remove a function watching a particular hint.\n\n \\param name the hint being watched\n \\param callback An SDL_HintCallback function that will be called when the\n                 hint value changes\n \\param userdata a pointer being passed to the callback function\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_AddHintCallback"]
     pub fn SDL_DelHintCallback(
         name: *const libc::c_char,
         callback: SDL_HintCallback,
@@ -22011,74 +14817,27 @@ extern "C" {
     );
 }
 extern "C" {
-    #[doc = " Clear all hints."]
-    #[doc = ""]
-    #[doc = " This function is automatically called during SDL_Quit()."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
+    #[doc = " Clear all hints.\n\n This function is automatically called during SDL_Quit(), and deletes all\n callbacks without calling them and frees all memory associated with hints.\n If you're calling this from application code you probably want to call\n SDL_ResetHints() instead.\n\n This function will be removed from the API the next time we rev the ABI.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_ResetHints"]
     pub fn SDL_ClearHints();
 }
 extern "C" {
-    #[doc = " Dynamically load a shared object."]
-    #[doc = ""]
-    #[doc = " \\param sofile a system-dependent name of the object file"]
-    #[doc = " \\returns an opaque pointer to the object handle or NULL if there was an"]
-    #[doc = "          error; call SDL_GetError() for more information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_LoadFunction"]
-    #[doc = " \\sa SDL_UnloadObject"]
+    #[doc = " Dynamically load a shared object.\n\n \\param sofile a system-dependent name of the object file\n \\returns an opaque pointer to the object handle or NULL if there was an\n          error; call SDL_GetError() for more information.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_LoadFunction\n \\sa SDL_UnloadObject"]
     pub fn SDL_LoadObject(sofile: *const libc::c_char) -> *mut libc::c_void;
 }
 extern "C" {
-    #[doc = " Look up the address of the named function in a shared object."]
-    #[doc = ""]
-    #[doc = " This function pointer is no longer valid after calling SDL_UnloadObject()."]
-    #[doc = ""]
-    #[doc = " This function can only look up C function names. Other languages may have"]
-    #[doc = " name mangling and intrinsic language support that varies from compiler to"]
-    #[doc = " compiler."]
-    #[doc = ""]
-    #[doc = " Make sure you declare your function pointers with the same calling"]
-    #[doc = " convention as the actual library function. Your code will crash"]
-    #[doc = " mysteriously if you do not do this."]
-    #[doc = ""]
-    #[doc = " If the requested function doesn't exist, NULL is returned."]
-    #[doc = ""]
-    #[doc = " \\param handle a valid shared object handle returned by SDL_LoadObject()"]
-    #[doc = " \\param name the name of the function to look up"]
-    #[doc = " \\returns a pointer to the function or NULL if there was an error; call"]
-    #[doc = "          SDL_GetError() for more information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_LoadObject"]
-    #[doc = " \\sa SDL_UnloadObject"]
+    #[doc = " Look up the address of the named function in a shared object.\n\n This function pointer is no longer valid after calling SDL_UnloadObject().\n\n This function can only look up C function names. Other languages may have\n name mangling and intrinsic language support that varies from compiler to\n compiler.\n\n Make sure you declare your function pointers with the same calling\n convention as the actual library function. Your code will crash\n mysteriously if you do not do this.\n\n If the requested function doesn't exist, NULL is returned.\n\n \\param handle a valid shared object handle returned by SDL_LoadObject()\n \\param name the name of the function to look up\n \\returns a pointer to the function or NULL if there was an error; call\n          SDL_GetError() for more information.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_LoadObject\n \\sa SDL_UnloadObject"]
     pub fn SDL_LoadFunction(
         handle: *mut libc::c_void,
         name: *const libc::c_char,
     ) -> *mut libc::c_void;
 }
 extern "C" {
-    #[doc = " Unload a shared object from memory."]
-    #[doc = ""]
-    #[doc = " \\param handle a valid shared object handle returned by SDL_LoadObject()"]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_LoadFunction"]
-    #[doc = " \\sa SDL_LoadObject"]
+    #[doc = " Unload a shared object from memory.\n\n \\param handle a valid shared object handle returned by SDL_LoadObject()\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_LoadFunction\n \\sa SDL_LoadObject"]
     pub fn SDL_UnloadObject(handle: *mut libc::c_void);
 }
 #[repr(u32)]
-#[doc = "  \\brief The predefined log categories"]
-#[doc = ""]
-#[doc = "  By default the application category is enabled at the INFO level,"]
-#[doc = "  the assert category is enabled at the WARN level, test is enabled"]
-#[doc = "  at the VERBOSE level and all other categories are enabled at the"]
-#[doc = "  CRITICAL level."]
-#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
+#[doc = "  \\brief The predefined log categories\n\n  By default the application category is enabled at the INFO level,\n  the assert category is enabled at the WARN level, test is enabled\n  at the VERBOSE level and all other categories are enabled at the\n  CRITICAL level."]
+#[derive(Copy, Clone, Hash, PartialEq, Eq)]
 pub enum SDL_LogCategory {
     SDL_LOG_CATEGORY_APPLICATION = 0,
     SDL_LOG_CATEGORY_ERROR = 1,
@@ -22103,7 +14862,7 @@ pub enum SDL_LogCategory {
 }
 #[repr(u32)]
 #[doc = "  \\brief The predefined log priorities"]
-#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
+#[derive(Copy, Clone, Hash, PartialEq, Eq)]
 pub enum SDL_LogPriority {
     SDL_LOG_PRIORITY_VERBOSE = 1,
     SDL_LOG_PRIORITY_DEBUG = 2,
@@ -22114,208 +14873,51 @@ pub enum SDL_LogPriority {
     SDL_NUM_LOG_PRIORITIES = 7,
 }
 extern "C" {
-    #[doc = " Set the priority of all log categories."]
-    #[doc = ""]
-    #[doc = " \\param priority the SDL_LogPriority to assign"]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_LogSetPriority"]
+    #[doc = " Set the priority of all log categories.\n\n \\param priority the SDL_LogPriority to assign\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_LogSetPriority"]
     pub fn SDL_LogSetAllPriority(priority: SDL_LogPriority);
 }
 extern "C" {
-    #[doc = " Set the priority of a particular log category."]
-    #[doc = ""]
-    #[doc = " \\param category the category to assign a priority to"]
-    #[doc = " \\param priority the SDL_LogPriority to assign"]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_LogGetPriority"]
-    #[doc = " \\sa SDL_LogSetAllPriority"]
+    #[doc = " Set the priority of a particular log category.\n\n \\param category the category to assign a priority to\n \\param priority the SDL_LogPriority to assign\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_LogGetPriority\n \\sa SDL_LogSetAllPriority"]
     pub fn SDL_LogSetPriority(category: libc::c_int, priority: SDL_LogPriority);
 }
 extern "C" {
-    #[doc = " Get the priority of a particular log category."]
-    #[doc = ""]
-    #[doc = " \\param category the category to query"]
-    #[doc = " \\returns the SDL_LogPriority for the requested category"]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_LogSetPriority"]
+    #[doc = " Get the priority of a particular log category.\n\n \\param category the category to query\n \\returns the SDL_LogPriority for the requested category\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_LogSetPriority"]
     pub fn SDL_LogGetPriority(category: libc::c_int) -> SDL_LogPriority;
 }
 extern "C" {
-    #[doc = " Reset all priorities to default."]
-    #[doc = ""]
-    #[doc = " This is called by SDL_Quit()."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_LogSetAllPriority"]
-    #[doc = " \\sa SDL_LogSetPriority"]
+    #[doc = " Reset all priorities to default.\n\n This is called by SDL_Quit().\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_LogSetAllPriority\n \\sa SDL_LogSetPriority"]
     pub fn SDL_LogResetPriorities();
 }
 extern "C" {
-    #[doc = " Log a message with SDL_LOG_CATEGORY_APPLICATION and SDL_LOG_PRIORITY_INFO."]
-    #[doc = ""]
-    #[doc = " = * \\param fmt a printf() style message format string"]
-    #[doc = ""]
-    #[doc = " \\param ... additional parameters matching % tokens in the `fmt` string, if"]
-    #[doc = "            any"]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_LogCritical"]
-    #[doc = " \\sa SDL_LogDebug"]
-    #[doc = " \\sa SDL_LogError"]
-    #[doc = " \\sa SDL_LogInfo"]
-    #[doc = " \\sa SDL_LogMessage"]
-    #[doc = " \\sa SDL_LogMessageV"]
-    #[doc = " \\sa SDL_LogVerbose"]
-    #[doc = " \\sa SDL_LogWarn"]
+    #[doc = " Log a message with SDL_LOG_CATEGORY_APPLICATION and SDL_LOG_PRIORITY_INFO.\n\n = * \\param fmt a printf() style message format string\n\n \\param ... additional parameters matching % tokens in the `fmt` string, if\n            any\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_LogCritical\n \\sa SDL_LogDebug\n \\sa SDL_LogError\n \\sa SDL_LogInfo\n \\sa SDL_LogMessage\n \\sa SDL_LogMessageV\n \\sa SDL_LogVerbose\n \\sa SDL_LogWarn"]
     pub fn SDL_Log(fmt: *const libc::c_char, ...);
 }
 extern "C" {
-    #[doc = " Log a message with SDL_LOG_PRIORITY_VERBOSE."]
-    #[doc = ""]
-    #[doc = " \\param category the category of the message"]
-    #[doc = " \\param fmt a printf() style message format string"]
-    #[doc = " \\param ... additional parameters matching % tokens in the **fmt** string,"]
-    #[doc = "            if any"]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_Log"]
-    #[doc = " \\sa SDL_LogCritical"]
-    #[doc = " \\sa SDL_LogDebug"]
-    #[doc = " \\sa SDL_LogError"]
-    #[doc = " \\sa SDL_LogInfo"]
-    #[doc = " \\sa SDL_LogMessage"]
-    #[doc = " \\sa SDL_LogMessageV"]
-    #[doc = " \\sa SDL_LogWarn"]
+    #[doc = " Log a message with SDL_LOG_PRIORITY_VERBOSE.\n\n \\param category the category of the message\n \\param fmt a printf() style message format string\n \\param ... additional parameters matching % tokens in the **fmt** string,\n            if any\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_Log\n \\sa SDL_LogCritical\n \\sa SDL_LogDebug\n \\sa SDL_LogError\n \\sa SDL_LogInfo\n \\sa SDL_LogMessage\n \\sa SDL_LogMessageV\n \\sa SDL_LogWarn"]
     pub fn SDL_LogVerbose(category: libc::c_int, fmt: *const libc::c_char, ...);
 }
 extern "C" {
-    #[doc = " Log a message with SDL_LOG_PRIORITY_DEBUG."]
-    #[doc = ""]
-    #[doc = " \\param category the category of the message"]
-    #[doc = " \\param fmt a printf() style message format string"]
-    #[doc = " \\param ... additional parameters matching % tokens in the **fmt** string,"]
-    #[doc = "            if any"]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_Log"]
-    #[doc = " \\sa SDL_LogCritical"]
-    #[doc = " \\sa SDL_LogError"]
-    #[doc = " \\sa SDL_LogInfo"]
-    #[doc = " \\sa SDL_LogMessage"]
-    #[doc = " \\sa SDL_LogMessageV"]
-    #[doc = " \\sa SDL_LogVerbose"]
-    #[doc = " \\sa SDL_LogWarn"]
+    #[doc = " Log a message with SDL_LOG_PRIORITY_DEBUG.\n\n \\param category the category of the message\n \\param fmt a printf() style message format string\n \\param ... additional parameters matching % tokens in the **fmt** string,\n            if any\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_Log\n \\sa SDL_LogCritical\n \\sa SDL_LogError\n \\sa SDL_LogInfo\n \\sa SDL_LogMessage\n \\sa SDL_LogMessageV\n \\sa SDL_LogVerbose\n \\sa SDL_LogWarn"]
     pub fn SDL_LogDebug(category: libc::c_int, fmt: *const libc::c_char, ...);
 }
 extern "C" {
-    #[doc = " Log a message with SDL_LOG_PRIORITY_INFO."]
-    #[doc = ""]
-    #[doc = " \\param category the category of the message"]
-    #[doc = " \\param fmt a printf() style message format string"]
-    #[doc = " \\param ... additional parameters matching % tokens in the **fmt** string,"]
-    #[doc = "            if any"]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_Log"]
-    #[doc = " \\sa SDL_LogCritical"]
-    #[doc = " \\sa SDL_LogDebug"]
-    #[doc = " \\sa SDL_LogError"]
-    #[doc = " \\sa SDL_LogMessage"]
-    #[doc = " \\sa SDL_LogMessageV"]
-    #[doc = " \\sa SDL_LogVerbose"]
-    #[doc = " \\sa SDL_LogWarn"]
+    #[doc = " Log a message with SDL_LOG_PRIORITY_INFO.\n\n \\param category the category of the message\n \\param fmt a printf() style message format string\n \\param ... additional parameters matching % tokens in the **fmt** string,\n            if any\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_Log\n \\sa SDL_LogCritical\n \\sa SDL_LogDebug\n \\sa SDL_LogError\n \\sa SDL_LogMessage\n \\sa SDL_LogMessageV\n \\sa SDL_LogVerbose\n \\sa SDL_LogWarn"]
     pub fn SDL_LogInfo(category: libc::c_int, fmt: *const libc::c_char, ...);
 }
 extern "C" {
-    #[doc = " Log a message with SDL_LOG_PRIORITY_WARN."]
-    #[doc = ""]
-    #[doc = " \\param category the category of the message"]
-    #[doc = " \\param fmt a printf() style message format string"]
-    #[doc = " \\param ... additional parameters matching % tokens in the **fmt** string,"]
-    #[doc = "            if any"]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_Log"]
-    #[doc = " \\sa SDL_LogCritical"]
-    #[doc = " \\sa SDL_LogDebug"]
-    #[doc = " \\sa SDL_LogError"]
-    #[doc = " \\sa SDL_LogInfo"]
-    #[doc = " \\sa SDL_LogMessage"]
-    #[doc = " \\sa SDL_LogMessageV"]
-    #[doc = " \\sa SDL_LogVerbose"]
+    #[doc = " Log a message with SDL_LOG_PRIORITY_WARN.\n\n \\param category the category of the message\n \\param fmt a printf() style message format string\n \\param ... additional parameters matching % tokens in the **fmt** string,\n            if any\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_Log\n \\sa SDL_LogCritical\n \\sa SDL_LogDebug\n \\sa SDL_LogError\n \\sa SDL_LogInfo\n \\sa SDL_LogMessage\n \\sa SDL_LogMessageV\n \\sa SDL_LogVerbose"]
     pub fn SDL_LogWarn(category: libc::c_int, fmt: *const libc::c_char, ...);
 }
 extern "C" {
-    #[doc = " Log a message with SDL_LOG_PRIORITY_ERROR."]
-    #[doc = ""]
-    #[doc = " \\param category the category of the message"]
-    #[doc = " \\param fmt a printf() style message format string"]
-    #[doc = " \\param ... additional parameters matching % tokens in the **fmt** string,"]
-    #[doc = "            if any"]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_Log"]
-    #[doc = " \\sa SDL_LogCritical"]
-    #[doc = " \\sa SDL_LogDebug"]
-    #[doc = " \\sa SDL_LogInfo"]
-    #[doc = " \\sa SDL_LogMessage"]
-    #[doc = " \\sa SDL_LogMessageV"]
-    #[doc = " \\sa SDL_LogVerbose"]
-    #[doc = " \\sa SDL_LogWarn"]
+    #[doc = " Log a message with SDL_LOG_PRIORITY_ERROR.\n\n \\param category the category of the message\n \\param fmt a printf() style message format string\n \\param ... additional parameters matching % tokens in the **fmt** string,\n            if any\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_Log\n \\sa SDL_LogCritical\n \\sa SDL_LogDebug\n \\sa SDL_LogInfo\n \\sa SDL_LogMessage\n \\sa SDL_LogMessageV\n \\sa SDL_LogVerbose\n \\sa SDL_LogWarn"]
     pub fn SDL_LogError(category: libc::c_int, fmt: *const libc::c_char, ...);
 }
 extern "C" {
-    #[doc = " Log a message with SDL_LOG_PRIORITY_CRITICAL."]
-    #[doc = ""]
-    #[doc = " \\param category the category of the message"]
-    #[doc = " \\param fmt a printf() style message format string"]
-    #[doc = " \\param ... additional parameters matching % tokens in the **fmt** string,"]
-    #[doc = "            if any"]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_Log"]
-    #[doc = " \\sa SDL_LogDebug"]
-    #[doc = " \\sa SDL_LogError"]
-    #[doc = " \\sa SDL_LogInfo"]
-    #[doc = " \\sa SDL_LogMessage"]
-    #[doc = " \\sa SDL_LogMessageV"]
-    #[doc = " \\sa SDL_LogVerbose"]
-    #[doc = " \\sa SDL_LogWarn"]
+    #[doc = " Log a message with SDL_LOG_PRIORITY_CRITICAL.\n\n \\param category the category of the message\n \\param fmt a printf() style message format string\n \\param ... additional parameters matching % tokens in the **fmt** string,\n            if any\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_Log\n \\sa SDL_LogDebug\n \\sa SDL_LogError\n \\sa SDL_LogInfo\n \\sa SDL_LogMessage\n \\sa SDL_LogMessageV\n \\sa SDL_LogVerbose\n \\sa SDL_LogWarn"]
     pub fn SDL_LogCritical(category: libc::c_int, fmt: *const libc::c_char, ...);
 }
 extern "C" {
-    #[doc = " Log a message with the specified category and priority."]
-    #[doc = ""]
-    #[doc = " \\param category the category of the message"]
-    #[doc = " \\param priority the priority of the message"]
-    #[doc = " \\param fmt a printf() style message format string"]
-    #[doc = " \\param ... additional parameters matching % tokens in the **fmt** string,"]
-    #[doc = "            if any"]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_Log"]
-    #[doc = " \\sa SDL_LogCritical"]
-    #[doc = " \\sa SDL_LogDebug"]
-    #[doc = " \\sa SDL_LogError"]
-    #[doc = " \\sa SDL_LogInfo"]
-    #[doc = " \\sa SDL_LogMessageV"]
-    #[doc = " \\sa SDL_LogVerbose"]
-    #[doc = " \\sa SDL_LogWarn"]
+    #[doc = " Log a message with the specified category and priority.\n\n \\param category the category of the message\n \\param priority the priority of the message\n \\param fmt a printf() style message format string\n \\param ... additional parameters matching % tokens in the **fmt** string,\n            if any\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_Log\n \\sa SDL_LogCritical\n \\sa SDL_LogDebug\n \\sa SDL_LogError\n \\sa SDL_LogInfo\n \\sa SDL_LogMessageV\n \\sa SDL_LogVerbose\n \\sa SDL_LogWarn"]
     pub fn SDL_LogMessage(
         category: libc::c_int,
         priority: SDL_LogPriority,
@@ -22324,23 +14926,7 @@ extern "C" {
     );
 }
 extern "C" {
-    #[doc = " Log a message with the specified category and priority."]
-    #[doc = ""]
-    #[doc = " \\param category the category of the message"]
-    #[doc = " \\param priority the priority of the message"]
-    #[doc = " \\param fmt a printf() style message format string"]
-    #[doc = " \\param ap a variable argument list"]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_Log"]
-    #[doc = " \\sa SDL_LogCritical"]
-    #[doc = " \\sa SDL_LogDebug"]
-    #[doc = " \\sa SDL_LogError"]
-    #[doc = " \\sa SDL_LogInfo"]
-    #[doc = " \\sa SDL_LogMessage"]
-    #[doc = " \\sa SDL_LogVerbose"]
-    #[doc = " \\sa SDL_LogWarn"]
+    #[doc = " Log a message with the specified category and priority.\n\n \\param category the category of the message\n \\param priority the priority of the message\n \\param fmt a printf() style message format string\n \\param ap a variable argument list\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_Log\n \\sa SDL_LogCritical\n \\sa SDL_LogDebug\n \\sa SDL_LogError\n \\sa SDL_LogInfo\n \\sa SDL_LogMessage\n \\sa SDL_LogVerbose\n \\sa SDL_LogWarn"]
     pub fn SDL_LogMessageV(
         category: libc::c_int,
         priority: SDL_LogPriority,
@@ -22348,14 +14934,7 @@ extern "C" {
         ap: *mut __va_list_tag,
     );
 }
-#[doc = " The prototype for the log output callback function."]
-#[doc = ""]
-#[doc = " This function is called by SDL when there is new text to be logged."]
-#[doc = ""]
-#[doc = " \\param userdata what was passed as `userdata` to SDL_LogSetOutputFunction()"]
-#[doc = " \\param category the category of the message"]
-#[doc = " \\param priority the priority of the message"]
-#[doc = " \\param message the message being output"]
+#[doc = " The prototype for the log output callback function.\n\n This function is called by SDL when there is new text to be logged.\n\n \\param userdata what was passed as `userdata` to SDL_LogSetOutputFunction()\n \\param category the category of the message\n \\param priority the priority of the message\n \\param message the message being output"]
 pub type SDL_LogOutputFunction = ::core::option::Option<
     unsafe extern "C" fn(
         userdata: *mut libc::c_void,
@@ -22365,35 +14944,19 @@ pub type SDL_LogOutputFunction = ::core::option::Option<
     ),
 >;
 extern "C" {
-    #[doc = " Get the current log output function."]
-    #[doc = ""]
-    #[doc = " \\param callback an SDL_LogOutputFunction filled in with the current log"]
-    #[doc = "                 callback"]
-    #[doc = " \\param userdata a pointer filled in with the pointer that is passed to"]
-    #[doc = "                 `callback`"]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_LogSetOutputFunction"]
+    #[doc = " Get the current log output function.\n\n \\param callback an SDL_LogOutputFunction filled in with the current log\n                 callback\n \\param userdata a pointer filled in with the pointer that is passed to\n                 `callback`\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_LogSetOutputFunction"]
     pub fn SDL_LogGetOutputFunction(
         callback: *mut SDL_LogOutputFunction,
         userdata: *mut *mut libc::c_void,
     );
 }
 extern "C" {
-    #[doc = " Replace the default log output function with one of your own."]
-    #[doc = ""]
-    #[doc = " \\param callback an SDL_LogOutputFunction to call instead of the default"]
-    #[doc = " \\param userdata a pointer that is passed to `callback`"]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_LogGetOutputFunction"]
+    #[doc = " Replace the default log output function with one of your own.\n\n \\param callback an SDL_LogOutputFunction to call instead of the default\n \\param userdata a pointer that is passed to `callback`\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_LogGetOutputFunction"]
     pub fn SDL_LogSetOutputFunction(callback: SDL_LogOutputFunction, userdata: *mut libc::c_void);
 }
 #[repr(u32)]
 #[doc = " SDL_MessageBox flags. If supported will display warning icon, etc."]
-#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
+#[derive(Copy, Clone, Hash, PartialEq, Eq)]
 pub enum SDL_MessageBoxFlags {
     #[doc = "< error dialog"]
     SDL_MESSAGEBOX_ERROR = 16,
@@ -22408,7 +14971,7 @@ pub enum SDL_MessageBoxFlags {
 }
 #[repr(u32)]
 #[doc = " Flags for SDL_MessageBoxButtonData."]
-#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
+#[derive(Copy, Clone, Hash, PartialEq, Eq)]
 pub enum SDL_MessageBoxButtonFlags {
     #[doc = "< Marks the default button when return is hit"]
     SDL_MESSAGEBOX_BUTTON_RETURNKEY_DEFAULT = 1,
@@ -22428,6 +14991,9 @@ pub struct SDL_MessageBoxButtonData {
 }
 #[test]
 fn bindgen_test_layout_SDL_MessageBoxButtonData() {
+    const UNINIT: ::core::mem::MaybeUninit<SDL_MessageBoxButtonData> =
+        ::core::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::core::mem::size_of::<SDL_MessageBoxButtonData>(),
         16usize,
@@ -22439,7 +15005,7 @@ fn bindgen_test_layout_SDL_MessageBoxButtonData() {
         concat!("Alignment of ", stringify!(SDL_MessageBoxButtonData))
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_MessageBoxButtonData>())).flags as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -22449,9 +15015,7 @@ fn bindgen_test_layout_SDL_MessageBoxButtonData() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::core::ptr::null::<SDL_MessageBoxButtonData>())).buttonid as *const _ as usize
-        },
+        unsafe { ::core::ptr::addr_of!((*ptr).buttonid) as usize - ptr as usize },
         4usize,
         concat!(
             "Offset of field: ",
@@ -22461,7 +15025,7 @@ fn bindgen_test_layout_SDL_MessageBoxButtonData() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_MessageBoxButtonData>())).text as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).text) as usize - ptr as usize },
         8usize,
         concat!(
             "Offset of field: ",
@@ -22481,6 +15045,9 @@ pub struct SDL_MessageBoxColor {
 }
 #[test]
 fn bindgen_test_layout_SDL_MessageBoxColor() {
+    const UNINIT: ::core::mem::MaybeUninit<SDL_MessageBoxColor> =
+        ::core::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::core::mem::size_of::<SDL_MessageBoxColor>(),
         3usize,
@@ -22492,7 +15059,7 @@ fn bindgen_test_layout_SDL_MessageBoxColor() {
         concat!("Alignment of ", stringify!(SDL_MessageBoxColor))
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_MessageBoxColor>())).r as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).r) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -22502,7 +15069,7 @@ fn bindgen_test_layout_SDL_MessageBoxColor() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_MessageBoxColor>())).g as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).g) as usize - ptr as usize },
         1usize,
         concat!(
             "Offset of field: ",
@@ -22512,7 +15079,7 @@ fn bindgen_test_layout_SDL_MessageBoxColor() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_MessageBoxColor>())).b as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).b) as usize - ptr as usize },
         2usize,
         concat!(
             "Offset of field: ",
@@ -22523,7 +15090,7 @@ fn bindgen_test_layout_SDL_MessageBoxColor() {
     );
 }
 #[repr(u32)]
-#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
+#[derive(Copy, Clone, Hash, PartialEq, Eq)]
 pub enum SDL_MessageBoxColorType {
     SDL_MESSAGEBOX_COLOR_BACKGROUND = 0,
     SDL_MESSAGEBOX_COLOR_TEXT = 1,
@@ -22540,6 +15107,9 @@ pub struct SDL_MessageBoxColorScheme {
 }
 #[test]
 fn bindgen_test_layout_SDL_MessageBoxColorScheme() {
+    const UNINIT: ::core::mem::MaybeUninit<SDL_MessageBoxColorScheme> =
+        ::core::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::core::mem::size_of::<SDL_MessageBoxColorScheme>(),
         15usize,
@@ -22551,9 +15121,7 @@ fn bindgen_test_layout_SDL_MessageBoxColorScheme() {
         concat!("Alignment of ", stringify!(SDL_MessageBoxColorScheme))
     );
     assert_eq!(
-        unsafe {
-            &(*(::core::ptr::null::<SDL_MessageBoxColorScheme>())).colors as *const _ as usize
-        },
+        unsafe { ::core::ptr::addr_of!((*ptr).colors) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -22582,6 +15150,8 @@ pub struct SDL_MessageBoxData {
 }
 #[test]
 fn bindgen_test_layout_SDL_MessageBoxData() {
+    const UNINIT: ::core::mem::MaybeUninit<SDL_MessageBoxData> = ::core::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::core::mem::size_of::<SDL_MessageBoxData>(),
         56usize,
@@ -22593,7 +15163,7 @@ fn bindgen_test_layout_SDL_MessageBoxData() {
         concat!("Alignment of ", stringify!(SDL_MessageBoxData))
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_MessageBoxData>())).flags as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -22603,7 +15173,7 @@ fn bindgen_test_layout_SDL_MessageBoxData() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_MessageBoxData>())).window as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).window) as usize - ptr as usize },
         8usize,
         concat!(
             "Offset of field: ",
@@ -22613,7 +15183,7 @@ fn bindgen_test_layout_SDL_MessageBoxData() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_MessageBoxData>())).title as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).title) as usize - ptr as usize },
         16usize,
         concat!(
             "Offset of field: ",
@@ -22623,7 +15193,7 @@ fn bindgen_test_layout_SDL_MessageBoxData() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_MessageBoxData>())).message as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).message) as usize - ptr as usize },
         24usize,
         concat!(
             "Offset of field: ",
@@ -22633,7 +15203,7 @@ fn bindgen_test_layout_SDL_MessageBoxData() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_MessageBoxData>())).numbuttons as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).numbuttons) as usize - ptr as usize },
         32usize,
         concat!(
             "Offset of field: ",
@@ -22643,7 +15213,7 @@ fn bindgen_test_layout_SDL_MessageBoxData() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_MessageBoxData>())).buttons as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).buttons) as usize - ptr as usize },
         40usize,
         concat!(
             "Offset of field: ",
@@ -22653,7 +15223,7 @@ fn bindgen_test_layout_SDL_MessageBoxData() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_MessageBoxData>())).colorScheme as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).colorScheme) as usize - ptr as usize },
         48usize,
         concat!(
             "Offset of field: ",
@@ -22664,81 +15234,14 @@ fn bindgen_test_layout_SDL_MessageBoxData() {
     );
 }
 extern "C" {
-    #[doc = " Create a modal message box."]
-    #[doc = ""]
-    #[doc = " If your needs aren't complex, it might be easier to use"]
-    #[doc = " SDL_ShowSimpleMessageBox."]
-    #[doc = ""]
-    #[doc = " This function should be called on the thread that created the parent"]
-    #[doc = " window, or on the main thread if the messagebox has no parent. It will"]
-    #[doc = " block execution of that thread until the user clicks a button or closes the"]
-    #[doc = " messagebox."]
-    #[doc = ""]
-    #[doc = " This function may be called at any time, even before SDL_Init(). This makes"]
-    #[doc = " it useful for reporting errors like a failure to create a renderer or"]
-    #[doc = " OpenGL context."]
-    #[doc = ""]
-    #[doc = " On X11, SDL rolls its own dialog box with X11 primitives instead of a"]
-    #[doc = " formal toolkit like GTK+ or Qt."]
-    #[doc = ""]
-    #[doc = " Note that if SDL_Init() would fail because there isn't any available video"]
-    #[doc = " target, this function is likely to fail for the same reasons. If this is a"]
-    #[doc = " concern, check the return value from this function and fall back to writing"]
-    #[doc = " to stderr if you can."]
-    #[doc = ""]
-    #[doc = " \\param messageboxdata the SDL_MessageBoxData structure with title, text and"]
-    #[doc = "                       other options"]
-    #[doc = " \\param buttonid the pointer to which user id of hit button should be copied"]
-    #[doc = " \\returns 0 on success or a negative error code on failure; call"]
-    #[doc = "          SDL_GetError() for more information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_ShowSimpleMessageBox"]
+    #[doc = " Create a modal message box.\n\n If your needs aren't complex, it might be easier to use\n SDL_ShowSimpleMessageBox.\n\n This function should be called on the thread that created the parent\n window, or on the main thread if the messagebox has no parent. It will\n block execution of that thread until the user clicks a button or closes the\n messagebox.\n\n This function may be called at any time, even before SDL_Init(). This makes\n it useful for reporting errors like a failure to create a renderer or\n OpenGL context.\n\n On X11, SDL rolls its own dialog box with X11 primitives instead of a\n formal toolkit like GTK+ or Qt.\n\n Note that if SDL_Init() would fail because there isn't any available video\n target, this function is likely to fail for the same reasons. If this is a\n concern, check the return value from this function and fall back to writing\n to stderr if you can.\n\n \\param messageboxdata the SDL_MessageBoxData structure with title, text and\n                       other options\n \\param buttonid the pointer to which user id of hit button should be copied\n \\returns 0 on success or a negative error code on failure; call\n          SDL_GetError() for more information.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_ShowSimpleMessageBox"]
     pub fn SDL_ShowMessageBox(
         messageboxdata: *const SDL_MessageBoxData,
         buttonid: *mut libc::c_int,
     ) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Display a simple modal message box."]
-    #[doc = ""]
-    #[doc = " If your needs aren't complex, this function is preferred over"]
-    #[doc = " SDL_ShowMessageBox."]
-    #[doc = ""]
-    #[doc = " `flags` may be any of the following:"]
-    #[doc = ""]
-    #[doc = " - `SDL_MESSAGEBOX_ERROR`: error dialog"]
-    #[doc = " - `SDL_MESSAGEBOX_WARNING`: warning dialog"]
-    #[doc = " - `SDL_MESSAGEBOX_INFORMATION`: informational dialog"]
-    #[doc = ""]
-    #[doc = " This function should be called on the thread that created the parent"]
-    #[doc = " window, or on the main thread if the messagebox has no parent. It will"]
-    #[doc = " block execution of that thread until the user clicks a button or closes the"]
-    #[doc = " messagebox."]
-    #[doc = ""]
-    #[doc = " This function may be called at any time, even before SDL_Init(). This makes"]
-    #[doc = " it useful for reporting errors like a failure to create a renderer or"]
-    #[doc = " OpenGL context."]
-    #[doc = ""]
-    #[doc = " On X11, SDL rolls its own dialog box with X11 primitives instead of a"]
-    #[doc = " formal toolkit like GTK+ or Qt."]
-    #[doc = ""]
-    #[doc = " Note that if SDL_Init() would fail because there isn't any available video"]
-    #[doc = " target, this function is likely to fail for the same reasons. If this is a"]
-    #[doc = " concern, check the return value from this function and fall back to writing"]
-    #[doc = " to stderr if you can."]
-    #[doc = ""]
-    #[doc = " \\param flags an SDL_MessageBoxFlags value"]
-    #[doc = " \\param title UTF-8 title text"]
-    #[doc = " \\param message UTF-8 message text"]
-    #[doc = " \\param window the parent window, or NULL for no parent"]
-    #[doc = " \\returns 0 on success or a negative error code on failure; call"]
-    #[doc = "          SDL_GetError() for more information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_ShowMessageBox"]
+    #[doc = " Display a simple modal message box.\n\n If your needs aren't complex, this function is preferred over\n SDL_ShowMessageBox.\n\n `flags` may be any of the following:\n\n - `SDL_MESSAGEBOX_ERROR`: error dialog\n - `SDL_MESSAGEBOX_WARNING`: warning dialog\n - `SDL_MESSAGEBOX_INFORMATION`: informational dialog\n\n This function should be called on the thread that created the parent\n window, or on the main thread if the messagebox has no parent. It will\n block execution of that thread until the user clicks a button or closes the\n messagebox.\n\n This function may be called at any time, even before SDL_Init(). This makes\n it useful for reporting errors like a failure to create a renderer or\n OpenGL context.\n\n On X11, SDL rolls its own dialog box with X11 primitives instead of a\n formal toolkit like GTK+ or Qt.\n\n Note that if SDL_Init() would fail because there isn't any available video\n target, this function is likely to fail for the same reasons. If this is a\n concern, check the return value from this function and fall back to writing\n to stderr if you can.\n\n \\param flags an SDL_MessageBoxFlags value\n \\param title UTF-8 title text\n \\param message UTF-8 message text\n \\param window the parent window, or NULL for no parent\n \\returns 0 on success or a negative error code on failure; call\n          SDL_GetError() for more information.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_ShowMessageBox"]
     pub fn SDL_ShowSimpleMessageBox(
         flags: Uint32,
         title: *const libc::c_char,
@@ -22746,56 +15249,22 @@ extern "C" {
         window: *mut SDL_Window,
     ) -> libc::c_int;
 }
-#[doc = "  \\brief A handle to a CAMetalLayer-backed NSView (macOS) or UIView (iOS/tvOS)."]
-#[doc = ""]
-#[doc = "  \\note This can be cast directly to an NSView or UIView."]
+#[doc = "  \\brief A handle to a CAMetalLayer-backed NSView (macOS) or UIView (iOS/tvOS).\n\n  \\note This can be cast directly to an NSView or UIView."]
 pub type SDL_MetalView = *mut libc::c_void;
 extern "C" {
-    #[doc = " Create a CAMetalLayer-backed NSView/UIView and attach it to the specified"]
-    #[doc = " window."]
-    #[doc = ""]
-    #[doc = " On macOS, this does *not* associate a MTLDevice with the CAMetalLayer on"]
-    #[doc = " its own. It is up to user code to do that."]
-    #[doc = ""]
-    #[doc = " The returned handle can be casted directly to a NSView or UIView. To access"]
-    #[doc = " the backing CAMetalLayer, call SDL_Metal_GetLayer()."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.12."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_Metal_DestroyView"]
-    #[doc = " \\sa SDL_Metal_GetLayer"]
+    #[doc = " Create a CAMetalLayer-backed NSView/UIView and attach it to the specified\n window.\n\n On macOS, this does *not* associate a MTLDevice with the CAMetalLayer on\n its own. It is up to user code to do that.\n\n The returned handle can be casted directly to a NSView or UIView. To access\n the backing CAMetalLayer, call SDL_Metal_GetLayer().\n\n \\since This function is available since SDL 2.0.12.\n\n \\sa SDL_Metal_DestroyView\n \\sa SDL_Metal_GetLayer"]
     pub fn SDL_Metal_CreateView(window: *mut SDL_Window) -> SDL_MetalView;
 }
 extern "C" {
-    #[doc = " Destroy an existing SDL_MetalView object."]
-    #[doc = ""]
-    #[doc = " This should be called before SDL_DestroyWindow, if SDL_Metal_CreateView was"]
-    #[doc = " called after SDL_CreateWindow."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.12."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_Metal_CreateView"]
+    #[doc = " Destroy an existing SDL_MetalView object.\n\n This should be called before SDL_DestroyWindow, if SDL_Metal_CreateView was\n called after SDL_CreateWindow.\n\n \\since This function is available since SDL 2.0.12.\n\n \\sa SDL_Metal_CreateView"]
     pub fn SDL_Metal_DestroyView(view: SDL_MetalView);
 }
 extern "C" {
-    #[doc = " Get a pointer to the backing CAMetalLayer for the given view."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.14."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_MetalCreateView"]
+    #[doc = " Get a pointer to the backing CAMetalLayer for the given view.\n\n \\since This function is available since SDL 2.0.14.\n\n \\sa SDL_Metal_CreateView"]
     pub fn SDL_Metal_GetLayer(view: SDL_MetalView) -> *mut libc::c_void;
 }
 extern "C" {
-    #[doc = " Get the size of a window's underlying drawable in pixels (for use with"]
-    #[doc = " setting viewport, scissor & etc)."]
-    #[doc = ""]
-    #[doc = " \\param window SDL_Window from which the drawable size should be queried"]
-    #[doc = " \\param w Pointer to variable for storing the width in pixels, may be NULL"]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.14."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_GetWindowSize"]
-    #[doc = " \\sa SDL_CreateWindow"]
+    #[doc = " Get the size of a window's underlying drawable in pixels (for use with\n setting viewport, scissor & etc).\n\n \\param window SDL_Window from which the drawable size should be queried\n \\param w Pointer to variable for storing the width in pixels, may be NULL\n \\param h Pointer to variable for storing the height in pixels, may be NULL\n\n \\since This function is available since SDL 2.0.14.\n\n \\sa SDL_GetWindowSize\n \\sa SDL_CreateWindow"]
     pub fn SDL_Metal_GetDrawableSize(
         window: *mut SDL_Window,
         w: *mut libc::c_int,
@@ -22804,7 +15273,7 @@ extern "C" {
 }
 #[repr(u32)]
 #[doc = "  The basic state for the system's power supply."]
-#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
+#[derive(Copy, Clone, Hash, PartialEq, Eq)]
 pub enum SDL_PowerState {
     #[doc = "< cannot determine power status"]
     SDL_POWERSTATE_UNKNOWN = 0,
@@ -22818,46 +15287,20 @@ pub enum SDL_PowerState {
     SDL_POWERSTATE_CHARGED = 4,
 }
 extern "C" {
-    #[doc = " Get the current power supply details."]
-    #[doc = ""]
-    #[doc = " You should never take a battery status as absolute truth. Batteries"]
-    #[doc = " (especially failing batteries) are delicate hardware, and the values"]
-    #[doc = " reported here are best estimates based on what that hardware reports. It's"]
-    #[doc = " not uncommon for older batteries to lose stored power much faster than it"]
-    #[doc = " reports, or completely drain when reporting it has 20 percent left, etc."]
-    #[doc = ""]
-    #[doc = " Battery status can change at any time; if you are concerned with power"]
-    #[doc = " state, you should call this function frequently, and perhaps ignore changes"]
-    #[doc = " until they seem to be stable for a few seconds."]
-    #[doc = ""]
-    #[doc = " It's possible a platform can only report battery percentage or time left"]
-    #[doc = " but not both."]
-    #[doc = ""]
-    #[doc = " \\param secs seconds of battery life left, you can pass a NULL here if you"]
-    #[doc = "             don't care, will return -1 if we can't determine a value, or"]
-    #[doc = "             we're not running on a battery"]
-    #[doc = " \\param pct percentage of battery life left, between 0 and 100, you can pass"]
-    #[doc = "            a NULL here if you don't care, will return -1 if we can't"]
-    #[doc = "            determine a value, or we're not running on a battery"]
-    #[doc = " \\returns an SDL_PowerState enum representing the current battery state."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
+    #[doc = " Get the current power supply details.\n\n You should never take a battery status as absolute truth. Batteries\n (especially failing batteries) are delicate hardware, and the values\n reported here are best estimates based on what that hardware reports. It's\n not uncommon for older batteries to lose stored power much faster than it\n reports, or completely drain when reporting it has 20 percent left, etc.\n\n Battery status can change at any time; if you are concerned with power\n state, you should call this function frequently, and perhaps ignore changes\n until they seem to be stable for a few seconds.\n\n It's possible a platform can only report battery percentage or time left\n but not both.\n\n \\param secs seconds of battery life left, you can pass a NULL here if you\n             don't care, will return -1 if we can't determine a value, or\n             we're not running on a battery\n \\param pct percentage of battery life left, between 0 and 100, you can pass\n            a NULL here if you don't care, will return -1 if we can't\n            determine a value, or we're not running on a battery\n \\returns an SDL_PowerState enum representing the current battery state.\n\n \\since This function is available since SDL 2.0.0."]
     pub fn SDL_GetPowerInfo(secs: *mut libc::c_int, pct: *mut libc::c_int) -> SDL_PowerState;
 }
 #[repr(u32)]
 #[doc = " Flags used when creating a rendering context"]
-#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
+#[derive(Copy, Clone, Hash, PartialEq, Eq)]
 pub enum SDL_RendererFlags {
     #[doc = "< The renderer is a software fallback"]
     SDL_RENDERER_SOFTWARE = 1,
-    #[doc = "< The renderer uses hardware"]
-    #[doc = "acceleration"]
+    #[doc = "< The renderer uses hardware\nacceleration"]
     SDL_RENDERER_ACCELERATED = 2,
-    #[doc = "< Present is synchronized"]
-    #[doc = "with the refresh rate"]
+    #[doc = "< Present is synchronized\nwith the refresh rate"]
     SDL_RENDERER_PRESENTVSYNC = 4,
-    #[doc = "< The renderer supports"]
-    #[doc = "rendering to texture"]
+    #[doc = "< The renderer supports\nrendering to texture"]
     SDL_RENDERER_TARGETTEXTURE = 8,
 }
 #[doc = " Information on the capabilities of a render driver or context."]
@@ -22879,6 +15322,8 @@ pub struct SDL_RendererInfo {
 }
 #[test]
 fn bindgen_test_layout_SDL_RendererInfo() {
+    const UNINIT: ::core::mem::MaybeUninit<SDL_RendererInfo> = ::core::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::core::mem::size_of::<SDL_RendererInfo>(),
         88usize,
@@ -22890,7 +15335,7 @@ fn bindgen_test_layout_SDL_RendererInfo() {
         concat!("Alignment of ", stringify!(SDL_RendererInfo))
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_RendererInfo>())).name as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).name) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -22900,7 +15345,7 @@ fn bindgen_test_layout_SDL_RendererInfo() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_RendererInfo>())).flags as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
         8usize,
         concat!(
             "Offset of field: ",
@@ -22910,9 +15355,7 @@ fn bindgen_test_layout_SDL_RendererInfo() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::core::ptr::null::<SDL_RendererInfo>())).num_texture_formats as *const _ as usize
-        },
+        unsafe { ::core::ptr::addr_of!((*ptr).num_texture_formats) as usize - ptr as usize },
         12usize,
         concat!(
             "Offset of field: ",
@@ -22922,9 +15365,7 @@ fn bindgen_test_layout_SDL_RendererInfo() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::core::ptr::null::<SDL_RendererInfo>())).texture_formats as *const _ as usize
-        },
+        unsafe { ::core::ptr::addr_of!((*ptr).texture_formats) as usize - ptr as usize },
         16usize,
         concat!(
             "Offset of field: ",
@@ -22934,9 +15375,7 @@ fn bindgen_test_layout_SDL_RendererInfo() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::core::ptr::null::<SDL_RendererInfo>())).max_texture_width as *const _ as usize
-        },
+        unsafe { ::core::ptr::addr_of!((*ptr).max_texture_width) as usize - ptr as usize },
         80usize,
         concat!(
             "Offset of field: ",
@@ -22946,9 +15385,7 @@ fn bindgen_test_layout_SDL_RendererInfo() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::core::ptr::null::<SDL_RendererInfo>())).max_texture_height as *const _ as usize
-        },
+        unsafe { ::core::ptr::addr_of!((*ptr).max_texture_height) as usize - ptr as usize },
         84usize,
         concat!(
             "Offset of field: ",
@@ -22971,6 +15408,8 @@ pub struct SDL_Vertex {
 }
 #[test]
 fn bindgen_test_layout_SDL_Vertex() {
+    const UNINIT: ::core::mem::MaybeUninit<SDL_Vertex> = ::core::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::core::mem::size_of::<SDL_Vertex>(),
         20usize,
@@ -22982,7 +15421,7 @@ fn bindgen_test_layout_SDL_Vertex() {
         concat!("Alignment of ", stringify!(SDL_Vertex))
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_Vertex>())).position as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).position) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -22992,7 +15431,7 @@ fn bindgen_test_layout_SDL_Vertex() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_Vertex>())).color as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).color) as usize - ptr as usize },
         8usize,
         concat!(
             "Offset of field: ",
@@ -23002,7 +15441,7 @@ fn bindgen_test_layout_SDL_Vertex() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_Vertex>())).tex_coord as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).tex_coord) as usize - ptr as usize },
         12usize,
         concat!(
             "Offset of field: ",
@@ -23014,7 +15453,7 @@ fn bindgen_test_layout_SDL_Vertex() {
 }
 #[repr(u32)]
 #[doc = " The scaling mode for a texture."]
-#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
+#[derive(Copy, Clone, Hash, PartialEq, Eq)]
 pub enum SDL_ScaleMode {
     #[doc = "< nearest pixel sampling"]
     SDL_ScaleModeNearest = 0,
@@ -23025,7 +15464,7 @@ pub enum SDL_ScaleMode {
 }
 #[repr(u32)]
 #[doc = " The access pattern allowed for a texture."]
-#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
+#[derive(Copy, Clone, Hash, PartialEq, Eq)]
 pub enum SDL_TextureAccess {
     #[doc = "< Changes rarely, not lockable"]
     SDL_TEXTUREACCESS_STATIC = 0,
@@ -23036,7 +15475,7 @@ pub enum SDL_TextureAccess {
 }
 #[repr(u32)]
 #[doc = " The texture channel modulation used in SDL_RenderCopy()."]
-#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
+#[derive(Copy, Clone, Hash, PartialEq, Eq)]
 pub enum SDL_TextureModulate {
     #[doc = "< No modulation"]
     SDL_TEXTUREMODULATE_NONE = 0,
@@ -23047,7 +15486,7 @@ pub enum SDL_TextureModulate {
 }
 #[repr(u32)]
 #[doc = " Flip constants for SDL_RenderCopyEx"]
-#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
+#[derive(Copy, Clone, Hash, PartialEq, Eq)]
 pub enum SDL_RendererFlip {
     #[doc = "< Do not flip"]
     SDL_FLIP_NONE = 0,
@@ -23069,54 +15508,15 @@ pub struct SDL_Texture {
     _unused: [u8; 0],
 }
 extern "C" {
-    #[doc = " Get the number of 2D rendering drivers available for the current display."]
-    #[doc = ""]
-    #[doc = " A render driver is a set of code that handles rendering and texture"]
-    #[doc = " management on a particular display. Normally there is only one, but some"]
-    #[doc = " drivers may have several available with different capabilities."]
-    #[doc = ""]
-    #[doc = " There may be none if SDL was compiled without render support."]
-    #[doc = ""]
-    #[doc = " \\returns a number >= 0 on success or a negative error code on failure; call"]
-    #[doc = "          SDL_GetError() for more information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_CreateRenderer"]
-    #[doc = " \\sa SDL_GetRenderDriverInfo"]
+    #[doc = " Get the number of 2D rendering drivers available for the current display.\n\n A render driver is a set of code that handles rendering and texture\n management on a particular display. Normally there is only one, but some\n drivers may have several available with different capabilities.\n\n There may be none if SDL was compiled without render support.\n\n \\returns a number >= 0 on success or a negative error code on failure; call\n          SDL_GetError() for more information.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_CreateRenderer\n \\sa SDL_GetRenderDriverInfo"]
     pub fn SDL_GetNumRenderDrivers() -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Get info about a specific 2D rendering driver for the current display."]
-    #[doc = ""]
-    #[doc = " \\param index the index of the driver to query information about"]
-    #[doc = " \\param info an SDL_RendererInfo structure to be filled with information on"]
-    #[doc = "             the rendering driver"]
-    #[doc = " \\returns 0 on success or a negative error code on failure; call"]
-    #[doc = "          SDL_GetError() for more information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_CreateRenderer"]
-    #[doc = " \\sa SDL_GetNumRenderDrivers"]
+    #[doc = " Get info about a specific 2D rendering driver for the current display.\n\n \\param index the index of the driver to query information about\n \\param info an SDL_RendererInfo structure to be filled with information on\n             the rendering driver\n \\returns 0 on success or a negative error code on failure; call\n          SDL_GetError() for more information.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_CreateRenderer\n \\sa SDL_GetNumRenderDrivers"]
     pub fn SDL_GetRenderDriverInfo(index: libc::c_int, info: *mut SDL_RendererInfo) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Create a window and default renderer."]
-    #[doc = ""]
-    #[doc = " \\param width the width of the window"]
-    #[doc = " \\param height the height of the window"]
-    #[doc = " \\param window_flags the flags used to create the window (see"]
-    #[doc = "                     SDL_CreateWindow())"]
-    #[doc = " \\param window a pointer filled with the window, or NULL on error"]
-    #[doc = " \\param renderer a pointer filled with the renderer, or NULL on error"]
-    #[doc = " \\returns 0 on success, or -1 on error; call SDL_GetError() for more"]
-    #[doc = "          information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_CreateRenderer"]
-    #[doc = " \\sa SDL_CreateWindow"]
+    #[doc = " Create a window and default renderer.\n\n \\param width the width of the window\n \\param height the height of the window\n \\param window_flags the flags used to create the window (see\n                     SDL_CreateWindow())\n \\param window a pointer filled with the window, or NULL on error\n \\param renderer a pointer filled with the renderer, or NULL on error\n \\returns 0 on success, or -1 on error; call SDL_GetError() for more\n          information.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_CreateRenderer\n \\sa SDL_CreateWindow"]
     pub fn SDL_CreateWindowAndRenderer(
         width: libc::c_int,
         height: libc::c_int,
@@ -23126,21 +15526,7 @@ extern "C" {
     ) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Create a 2D rendering context for a window."]
-    #[doc = ""]
-    #[doc = " \\param window the window where rendering is displayed"]
-    #[doc = " \\param index the index of the rendering driver to initialize, or -1 to"]
-    #[doc = "              initialize the first one supporting the requested flags"]
-    #[doc = " \\param flags 0, or one or more SDL_RendererFlags OR'd together"]
-    #[doc = " \\returns a valid rendering context or NULL if there was an error; call"]
-    #[doc = "          SDL_GetError() for more information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_CreateSoftwareRenderer"]
-    #[doc = " \\sa SDL_DestroyRenderer"]
-    #[doc = " \\sa SDL_GetNumRenderDrivers"]
-    #[doc = " \\sa SDL_GetRendererInfo"]
+    #[doc = " Create a 2D rendering context for a window.\n\n \\param window the window where rendering is displayed\n \\param index the index of the rendering driver to initialize, or -1 to\n              initialize the first one supporting the requested flags\n \\param flags 0, or one or more SDL_RendererFlags OR'd together\n \\returns a valid rendering context or NULL if there was an error; call\n          SDL_GetError() for more information.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_CreateSoftwareRenderer\n \\sa SDL_DestroyRenderer\n \\sa SDL_GetNumRenderDrivers\n \\sa SDL_GetRendererInfo"]
     pub fn SDL_CreateRenderer(
         window: *mut SDL_Window,
         index: libc::c_int,
@@ -23148,70 +15534,26 @@ extern "C" {
     ) -> *mut SDL_Renderer;
 }
 extern "C" {
-    #[doc = " Create a 2D software rendering context for a surface."]
-    #[doc = ""]
-    #[doc = " Two other API which can be used to create SDL_Renderer:"]
-    #[doc = " SDL_CreateRenderer() and SDL_CreateWindowAndRenderer(). These can _also_"]
-    #[doc = " create a software renderer, but they are intended to be used with an"]
-    #[doc = " SDL_Window as the final destination and not an SDL_Surface."]
-    #[doc = ""]
-    #[doc = " \\param surface the SDL_Surface structure representing the surface where"]
-    #[doc = "                rendering is done"]
-    #[doc = " \\returns a valid rendering context or NULL if there was an error; call"]
-    #[doc = "          SDL_GetError() for more information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_CreateRenderer"]
-    #[doc = " \\sa SDL_CreateWindowRenderer"]
-    #[doc = " \\sa SDL_DestroyRenderer"]
+    #[doc = " Create a 2D software rendering context for a surface.\n\n Two other API which can be used to create SDL_Renderer:\n SDL_CreateRenderer() and SDL_CreateWindowAndRenderer(). These can _also_\n create a software renderer, but they are intended to be used with an\n SDL_Window as the final destination and not an SDL_Surface.\n\n \\param surface the SDL_Surface structure representing the surface where\n                rendering is done\n \\returns a valid rendering context or NULL if there was an error; call\n          SDL_GetError() for more information.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_CreateRenderer\n \\sa SDL_CreateWindowRenderer\n \\sa SDL_DestroyRenderer"]
     pub fn SDL_CreateSoftwareRenderer(surface: *mut SDL_Surface) -> *mut SDL_Renderer;
 }
 extern "C" {
-    #[doc = " Get the renderer associated with a window."]
-    #[doc = ""]
-    #[doc = " \\param window the window to query"]
-    #[doc = " \\returns the rendering context on success or NULL on failure; call"]
-    #[doc = "          SDL_GetError() for more information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_CreateRenderer"]
+    #[doc = " Get the renderer associated with a window.\n\n \\param window the window to query\n \\returns the rendering context on success or NULL on failure; call\n          SDL_GetError() for more information.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_CreateRenderer"]
     pub fn SDL_GetRenderer(window: *mut SDL_Window) -> *mut SDL_Renderer;
 }
 extern "C" {
-    #[doc = " Get information about a rendering context."]
-    #[doc = ""]
-    #[doc = " \\param renderer the rendering context"]
-    #[doc = " \\param info an SDL_RendererInfo structure filled with information about the"]
-    #[doc = "             current renderer"]
-    #[doc = " \\returns 0 on success or a negative error code on failure; call"]
-    #[doc = "          SDL_GetError() for more information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_CreateRenderer"]
+    #[doc = " Get the window associated with a renderer.\n\n \\param renderer the renderer to query\n \\returns the window on success or NULL on failure; call SDL_GetError() for\n          more information.\n\n \\since This function is available since SDL 2.0.22."]
+    pub fn SDL_RenderGetWindow(renderer: *mut SDL_Renderer) -> *mut SDL_Window;
+}
+extern "C" {
+    #[doc = " Get information about a rendering context.\n\n \\param renderer the rendering context\n \\param info an SDL_RendererInfo structure filled with information about the\n             current renderer\n \\returns 0 on success or a negative error code on failure; call\n          SDL_GetError() for more information.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_CreateRenderer"]
     pub fn SDL_GetRendererInfo(
         renderer: *mut SDL_Renderer,
         info: *mut SDL_RendererInfo,
     ) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Get the output size in pixels of a rendering context."]
-    #[doc = ""]
-    #[doc = " Due to high-dpi displays, you might end up with a rendering context that"]
-    #[doc = " has more pixels than the window that contains it, so use this instead of"]
-    #[doc = " SDL_GetWindowSize() to decide how much drawing area you have."]
-    #[doc = ""]
-    #[doc = " \\param renderer the rendering context"]
-    #[doc = " \\param w an int filled with the width"]
-    #[doc = " \\param h an int filled with the height"]
-    #[doc = " \\returns 0 on success or a negative error code on failure; call"]
-    #[doc = "          SDL_GetError() for more information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_GetRenderer"]
+    #[doc = " Get the output size in pixels of a rendering context.\n\n Due to high-dpi displays, you might end up with a rendering context that\n has more pixels than the window that contains it, so use this instead of\n SDL_GetWindowSize() to decide how much drawing area you have.\n\n \\param renderer the rendering context\n \\param w an int filled with the width\n \\param h an int filled with the height\n \\returns 0 on success or a negative error code on failure; call\n          SDL_GetError() for more information.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_GetRenderer"]
     pub fn SDL_GetRendererOutputSize(
         renderer: *mut SDL_Renderer,
         w: *mut libc::c_int,
@@ -23219,26 +15561,7 @@ extern "C" {
     ) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Create a texture for a rendering context."]
-    #[doc = ""]
-    #[doc = " You can set the texture scaling method by setting"]
-    #[doc = " `SDL_HINT_RENDER_SCALE_QUALITY` before creating the texture."]
-    #[doc = ""]
-    #[doc = " \\param renderer the rendering context"]
-    #[doc = " \\param format one of the enumerated values in SDL_PixelFormatEnum"]
-    #[doc = " \\param access one of the enumerated values in SDL_TextureAccess"]
-    #[doc = " \\param w the width of the texture in pixels"]
-    #[doc = " \\param h the height of the texture in pixels"]
-    #[doc = " \\returns a pointer to the created texture or NULL if no rendering context"]
-    #[doc = "          was active, the format was unsupported, or the width or height"]
-    #[doc = "          were out of range; call SDL_GetError() for more information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_CreateTextureFromSurface"]
-    #[doc = " \\sa SDL_DestroyTexture"]
-    #[doc = " \\sa SDL_QueryTexture"]
-    #[doc = " \\sa SDL_UpdateTexture"]
+    #[doc = " Create a texture for a rendering context.\n\n You can set the texture scaling method by setting\n `SDL_HINT_RENDER_SCALE_QUALITY` before creating the texture.\n\n \\param renderer the rendering context\n \\param format one of the enumerated values in SDL_PixelFormatEnum\n \\param access one of the enumerated values in SDL_TextureAccess\n \\param w the width of the texture in pixels\n \\param h the height of the texture in pixels\n \\returns a pointer to the created texture or NULL if no rendering context\n          was active, the format was unsupported, or the width or height\n          were out of range; call SDL_GetError() for more information.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_CreateTextureFromSurface\n \\sa SDL_DestroyTexture\n \\sa SDL_QueryTexture\n \\sa SDL_UpdateTexture"]
     pub fn SDL_CreateTexture(
         renderer: *mut SDL_Renderer,
         format: Uint32,
@@ -23248,50 +15571,14 @@ extern "C" {
     ) -> *mut SDL_Texture;
 }
 extern "C" {
-    #[doc = " Create a texture from an existing surface."]
-    #[doc = ""]
-    #[doc = " The surface is not modified or freed by this function."]
-    #[doc = ""]
-    #[doc = " The SDL_TextureAccess hint for the created texture is"]
-    #[doc = " `SDL_TEXTUREACCESS_STATIC`."]
-    #[doc = ""]
-    #[doc = " The pixel format of the created texture may be different from the pixel"]
-    #[doc = " format of the surface. Use SDL_QueryTexture() to query the pixel format of"]
-    #[doc = " the texture."]
-    #[doc = ""]
-    #[doc = " \\param renderer the rendering context"]
-    #[doc = " \\param surface the SDL_Surface structure containing pixel data used to fill"]
-    #[doc = "                the texture"]
-    #[doc = " \\returns the created texture or NULL on failure; call SDL_GetError() for"]
-    #[doc = "          more information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_CreateTexture"]
-    #[doc = " \\sa SDL_DestroyTexture"]
-    #[doc = " \\sa SDL_QueryTexture"]
+    #[doc = " Create a texture from an existing surface.\n\n The surface is not modified or freed by this function.\n\n The SDL_TextureAccess hint for the created texture is\n `SDL_TEXTUREACCESS_STATIC`.\n\n The pixel format of the created texture may be different from the pixel\n format of the surface. Use SDL_QueryTexture() to query the pixel format of\n the texture.\n\n \\param renderer the rendering context\n \\param surface the SDL_Surface structure containing pixel data used to fill\n                the texture\n \\returns the created texture or NULL on failure; call SDL_GetError() for\n          more information.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_CreateTexture\n \\sa SDL_DestroyTexture\n \\sa SDL_QueryTexture"]
     pub fn SDL_CreateTextureFromSurface(
         renderer: *mut SDL_Renderer,
         surface: *mut SDL_Surface,
     ) -> *mut SDL_Texture;
 }
 extern "C" {
-    #[doc = " Query the attributes of a texture."]
-    #[doc = ""]
-    #[doc = " \\param texture the texture to query"]
-    #[doc = " \\param format a pointer filled in with the raw format of the texture; the"]
-    #[doc = "               actual format may differ, but pixel transfers will use this"]
-    #[doc = "               format (one of the SDL_PixelFormatEnum values)"]
-    #[doc = " \\param access a pointer filled in with the actual access to the texture"]
-    #[doc = "               (one of the SDL_TextureAccess values)"]
-    #[doc = " \\param w a pointer filled in with the width of the texture in pixels"]
-    #[doc = " \\param h a pointer filled in with the height of the texture in pixels"]
-    #[doc = " \\returns 0 on success or a negative error code on failure; call"]
-    #[doc = "          SDL_GetError() for more information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_CreateTexture"]
+    #[doc = " Query the attributes of a texture.\n\n \\param texture the texture to query\n \\param format a pointer filled in with the raw format of the texture; the\n               actual format may differ, but pixel transfers will use this\n               format (one of the SDL_PixelFormatEnum values). This argument\n               can be NULL if you don't need this information.\n \\param access a pointer filled in with the actual access to the texture\n               (one of the SDL_TextureAccess values). This argument can be\n               NULL if you don't need this information.\n \\param w a pointer filled in with the width of the texture in pixels. This\n          argument can be NULL if you don't need this information.\n \\param h a pointer filled in with the height of the texture in pixels. This\n          argument can be NULL if you don't need this information.\n \\returns 0 on success or a negative error code on failure; call\n          SDL_GetError() for more information.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_CreateTexture"]
     pub fn SDL_QueryTexture(
         texture: *mut SDL_Texture,
         format: *mut Uint32,
@@ -23301,28 +15588,7 @@ extern "C" {
     ) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Set an additional color value multiplied into render copy operations."]
-    #[doc = ""]
-    #[doc = " When this texture is rendered, during the copy operation each source color"]
-    #[doc = " channel is modulated by the appropriate color value according to the"]
-    #[doc = " following formula:"]
-    #[doc = ""]
-    #[doc = " `srcC = srcC * (color / 255)`"]
-    #[doc = ""]
-    #[doc = " Color modulation is not always supported by the renderer; it will return -1"]
-    #[doc = " if color modulation is not supported."]
-    #[doc = ""]
-    #[doc = " \\param texture the texture to update"]
-    #[doc = " \\param r the red color value multiplied into copy operations"]
-    #[doc = " \\param g the green color value multiplied into copy operations"]
-    #[doc = " \\param b the blue color value multiplied into copy operations"]
-    #[doc = " \\returns 0 on success or a negative error code on failure; call"]
-    #[doc = "          SDL_GetError() for more information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_GetTextureColorMod"]
-    #[doc = " \\sa SDL_SetTextureAlphaMod"]
+    #[doc = " Set an additional color value multiplied into render copy operations.\n\n When this texture is rendered, during the copy operation each source color\n channel is modulated by the appropriate color value according to the\n following formula:\n\n `srcC = srcC * (color / 255)`\n\n Color modulation is not always supported by the renderer; it will return -1\n if color modulation is not supported.\n\n \\param texture the texture to update\n \\param r the red color value multiplied into copy operations\n \\param g the green color value multiplied into copy operations\n \\param b the blue color value multiplied into copy operations\n \\returns 0 on success or a negative error code on failure; call\n          SDL_GetError() for more information.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_GetTextureColorMod\n \\sa SDL_SetTextureAlphaMod"]
     pub fn SDL_SetTextureColorMod(
         texture: *mut SDL_Texture,
         r: Uint8,
@@ -23331,19 +15597,7 @@ extern "C" {
     ) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Get the additional color value multiplied into render copy operations."]
-    #[doc = ""]
-    #[doc = " \\param texture the texture to query"]
-    #[doc = " \\param r a pointer filled in with the current red color value"]
-    #[doc = " \\param g a pointer filled in with the current green color value"]
-    #[doc = " \\param b a pointer filled in with the current blue color value"]
-    #[doc = " \\returns 0 on success or a negative error code on failure; call"]
-    #[doc = "          SDL_GetError() for more information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_GetTextureAlphaMod"]
-    #[doc = " \\sa SDL_SetTextureColorMod"]
+    #[doc = " Get the additional color value multiplied into render copy operations.\n\n \\param texture the texture to query\n \\param r a pointer filled in with the current red color value\n \\param g a pointer filled in with the current green color value\n \\param b a pointer filled in with the current blue color value\n \\returns 0 on success or a negative error code on failure; call\n          SDL_GetError() for more information.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_GetTextureAlphaMod\n \\sa SDL_SetTextureColorMod"]
     pub fn SDL_GetTextureColorMod(
         texture: *mut SDL_Texture,
         r: *mut Uint8,
@@ -23352,164 +15606,54 @@ extern "C" {
     ) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Set an additional alpha value multiplied into render copy operations."]
-    #[doc = ""]
-    #[doc = " When this texture is rendered, during the copy operation the source alpha"]
-    #[doc = " value is modulated by this alpha value according to the following formula:"]
-    #[doc = ""]
-    #[doc = " `srcA = srcA * (alpha / 255)`"]
-    #[doc = ""]
-    #[doc = " Alpha modulation is not always supported by the renderer; it will return -1"]
-    #[doc = " if alpha modulation is not supported."]
-    #[doc = ""]
-    #[doc = " \\param texture the texture to update"]
-    #[doc = " \\param alpha the source alpha value multiplied into copy operations"]
-    #[doc = " \\returns 0 on success or a negative error code on failure; call"]
-    #[doc = "          SDL_GetError() for more information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_GetTextureAlphaMod"]
-    #[doc = " \\sa SDL_SetTextureColorMod"]
+    #[doc = " Set an additional alpha value multiplied into render copy operations.\n\n When this texture is rendered, during the copy operation the source alpha\n value is modulated by this alpha value according to the following formula:\n\n `srcA = srcA * (alpha / 255)`\n\n Alpha modulation is not always supported by the renderer; it will return -1\n if alpha modulation is not supported.\n\n \\param texture the texture to update\n \\param alpha the source alpha value multiplied into copy operations\n \\returns 0 on success or a negative error code on failure; call\n          SDL_GetError() for more information.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_GetTextureAlphaMod\n \\sa SDL_SetTextureColorMod"]
     pub fn SDL_SetTextureAlphaMod(texture: *mut SDL_Texture, alpha: Uint8) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Get the additional alpha value multiplied into render copy operations."]
-    #[doc = ""]
-    #[doc = " \\param texture the texture to query"]
-    #[doc = " \\param alpha a pointer filled in with the current alpha value"]
-    #[doc = " \\returns 0 on success or a negative error code on failure; call"]
-    #[doc = "          SDL_GetError() for more information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_GetTextureColorMod"]
-    #[doc = " \\sa SDL_SetTextureAlphaMod"]
+    #[doc = " Get the additional alpha value multiplied into render copy operations.\n\n \\param texture the texture to query\n \\param alpha a pointer filled in with the current alpha value\n \\returns 0 on success or a negative error code on failure; call\n          SDL_GetError() for more information.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_GetTextureColorMod\n \\sa SDL_SetTextureAlphaMod"]
     pub fn SDL_GetTextureAlphaMod(texture: *mut SDL_Texture, alpha: *mut Uint8) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Set the blend mode for a texture, used by SDL_RenderCopy()."]
-    #[doc = ""]
-    #[doc = " If the blend mode is not supported, the closest supported mode is chosen"]
-    #[doc = " and this function returns -1."]
-    #[doc = ""]
-    #[doc = " \\param texture the texture to update"]
-    #[doc = " \\param blendMode the SDL_BlendMode to use for texture blending"]
-    #[doc = " \\returns 0 on success or a negative error code on failure; call"]
-    #[doc = "          SDL_GetError() for more information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_GetTextureBlendMode"]
-    #[doc = " \\sa SDL_RenderCopy"]
+    #[doc = " Set the blend mode for a texture, used by SDL_RenderCopy().\n\n If the blend mode is not supported, the closest supported mode is chosen\n and this function returns -1.\n\n \\param texture the texture to update\n \\param blendMode the SDL_BlendMode to use for texture blending\n \\returns 0 on success or a negative error code on failure; call\n          SDL_GetError() for more information.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_GetTextureBlendMode\n \\sa SDL_RenderCopy"]
     pub fn SDL_SetTextureBlendMode(
         texture: *mut SDL_Texture,
         blendMode: SDL_BlendMode,
     ) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Get the blend mode used for texture copy operations."]
-    #[doc = ""]
-    #[doc = " \\param texture the texture to query"]
-    #[doc = " \\param blendMode a pointer filled in with the current SDL_BlendMode"]
-    #[doc = " \\returns 0 on success or a negative error code on failure; call"]
-    #[doc = "          SDL_GetError() for more information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_SetTextureBlendMode"]
+    #[doc = " Get the blend mode used for texture copy operations.\n\n \\param texture the texture to query\n \\param blendMode a pointer filled in with the current SDL_BlendMode\n \\returns 0 on success or a negative error code on failure; call\n          SDL_GetError() for more information.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_SetTextureBlendMode"]
     pub fn SDL_GetTextureBlendMode(
         texture: *mut SDL_Texture,
         blendMode: *mut SDL_BlendMode,
     ) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Set the scale mode used for texture scale operations."]
-    #[doc = ""]
-    #[doc = " If the scale mode is not supported, the closest supported mode is chosen."]
-    #[doc = ""]
-    #[doc = " \\param texture The texture to update."]
-    #[doc = " \\param scaleMode the SDL_ScaleMode to use for texture scaling."]
-    #[doc = " \\returns 0 on success, or -1 if the texture is not valid."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.12."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_GetTextureScaleMode"]
+    #[doc = " Set the scale mode used for texture scale operations.\n\n If the scale mode is not supported, the closest supported mode is chosen.\n\n \\param texture The texture to update.\n \\param scaleMode the SDL_ScaleMode to use for texture scaling.\n \\returns 0 on success, or -1 if the texture is not valid.\n\n \\since This function is available since SDL 2.0.12.\n\n \\sa SDL_GetTextureScaleMode"]
     pub fn SDL_SetTextureScaleMode(
         texture: *mut SDL_Texture,
         scaleMode: SDL_ScaleMode,
     ) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Get the scale mode used for texture scale operations."]
-    #[doc = ""]
-    #[doc = " \\param texture the texture to query."]
-    #[doc = " \\param scaleMode a pointer filled in with the current scale mode."]
-    #[doc = " \\return 0 on success, or -1 if the texture is not valid."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.12."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_SetTextureScaleMode"]
+    #[doc = " Get the scale mode used for texture scale operations.\n\n \\param texture the texture to query.\n \\param scaleMode a pointer filled in with the current scale mode.\n \\return 0 on success, or -1 if the texture is not valid.\n\n \\since This function is available since SDL 2.0.12.\n\n \\sa SDL_SetTextureScaleMode"]
     pub fn SDL_GetTextureScaleMode(
         texture: *mut SDL_Texture,
         scaleMode: *mut SDL_ScaleMode,
     ) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Associate a user-specified pointer with a texture."]
-    #[doc = ""]
-    #[doc = " \\param texture the texture to update."]
-    #[doc = " \\param userdata the pointer to associate with the texture."]
-    #[doc = " \\returns 0 on success, or -1 if the texture is not valid."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.18."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_GetTextureUserData"]
+    #[doc = " Associate a user-specified pointer with a texture.\n\n \\param texture the texture to update.\n \\param userdata the pointer to associate with the texture.\n \\returns 0 on success, or -1 if the texture is not valid.\n\n \\since This function is available since SDL 2.0.18.\n\n \\sa SDL_GetTextureUserData"]
     pub fn SDL_SetTextureUserData(
         texture: *mut SDL_Texture,
         userdata: *mut libc::c_void,
     ) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Get the user-specified pointer associated with a texture"]
-    #[doc = ""]
-    #[doc = " \\param texture the texture to query."]
-    #[doc = " \\return the pointer associated with the texture, or NULL if the texture is"]
-    #[doc = "         not valid."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.18."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_SetTextureUserData"]
+    #[doc = " Get the user-specified pointer associated with a texture\n\n \\param texture the texture to query.\n \\return the pointer associated with the texture, or NULL if the texture is\n         not valid.\n\n \\since This function is available since SDL 2.0.18.\n\n \\sa SDL_SetTextureUserData"]
     pub fn SDL_GetTextureUserData(texture: *mut SDL_Texture) -> *mut libc::c_void;
 }
 extern "C" {
-    #[doc = " Update the given texture rectangle with new pixel data."]
-    #[doc = ""]
-    #[doc = " The pixel data must be in the pixel format of the texture. Use"]
-    #[doc = " SDL_QueryTexture() to query the pixel format of the texture."]
-    #[doc = ""]
-    #[doc = " This is a fairly slow function, intended for use with static textures that"]
-    #[doc = " do not change often."]
-    #[doc = ""]
-    #[doc = " If the texture is intended to be updated often, it is preferred to create"]
-    #[doc = " the texture as streaming and use the locking functions referenced below."]
-    #[doc = " While this function will work with streaming textures, for optimization"]
-    #[doc = " reasons you may not get the pixels back if you lock the texture afterward."]
-    #[doc = ""]
-    #[doc = " \\param texture the texture to update"]
-    #[doc = " \\param rect an SDL_Rect structure representing the area to update, or NULL"]
-    #[doc = "             to update the entire texture"]
-    #[doc = " \\param pixels the raw pixel data in the format of the texture"]
-    #[doc = " \\param pitch the number of bytes in a row of pixel data, including padding"]
-    #[doc = "              between lines"]
-    #[doc = " \\returns 0 on success or a negative error code on failure; call"]
-    #[doc = "          SDL_GetError() for more information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_CreateTexture"]
-    #[doc = " \\sa SDL_LockTexture"]
-    #[doc = " \\sa SDL_UnlockTexture"]
+    #[doc = " Update the given texture rectangle with new pixel data.\n\n The pixel data must be in the pixel format of the texture. Use\n SDL_QueryTexture() to query the pixel format of the texture.\n\n This is a fairly slow function, intended for use with static textures that\n do not change often.\n\n If the texture is intended to be updated often, it is preferred to create\n the texture as streaming and use the locking functions referenced below.\n While this function will work with streaming textures, for optimization\n reasons you may not get the pixels back if you lock the texture afterward.\n\n \\param texture the texture to update\n \\param rect an SDL_Rect structure representing the area to update, or NULL\n             to update the entire texture\n \\param pixels the raw pixel data in the format of the texture\n \\param pitch the number of bytes in a row of pixel data, including padding\n              between lines\n \\returns 0 on success or a negative error code on failure; call\n          SDL_GetError() for more information.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_CreateTexture\n \\sa SDL_LockTexture\n \\sa SDL_UnlockTexture"]
     pub fn SDL_UpdateTexture(
         texture: *mut SDL_Texture,
         rect: *const SDL_Rect,
@@ -23518,31 +15662,7 @@ extern "C" {
     ) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Update a rectangle within a planar YV12 or IYUV texture with new pixel"]
-    #[doc = " data."]
-    #[doc = ""]
-    #[doc = " You can use SDL_UpdateTexture() as long as your pixel data is a contiguous"]
-    #[doc = " block of Y and U/V planes in the proper order, but this function is"]
-    #[doc = " available if your pixel data is not contiguous."]
-    #[doc = ""]
-    #[doc = " \\param texture the texture to update"]
-    #[doc = " \\param rect a pointer to the rectangle of pixels to update, or NULL to"]
-    #[doc = "             update the entire texture"]
-    #[doc = " \\param Yplane the raw pixel data for the Y plane"]
-    #[doc = " \\param Ypitch the number of bytes between rows of pixel data for the Y"]
-    #[doc = "               plane"]
-    #[doc = " \\param Uplane the raw pixel data for the U plane"]
-    #[doc = " \\param Upitch the number of bytes between rows of pixel data for the U"]
-    #[doc = "               plane"]
-    #[doc = " \\param Vplane the raw pixel data for the V plane"]
-    #[doc = " \\param Vpitch the number of bytes between rows of pixel data for the V"]
-    #[doc = "               plane"]
-    #[doc = " \\returns 0 on success or -1 if the texture is not valid; call"]
-    #[doc = "          SDL_GetError() for more information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.1."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_UpdateTexture"]
+    #[doc = " Update a rectangle within a planar YV12 or IYUV texture with new pixel\n data.\n\n You can use SDL_UpdateTexture() as long as your pixel data is a contiguous\n block of Y and U/V planes in the proper order, but this function is\n available if your pixel data is not contiguous.\n\n \\param texture the texture to update\n \\param rect a pointer to the rectangle of pixels to update, or NULL to\n             update the entire texture\n \\param Yplane the raw pixel data for the Y plane\n \\param Ypitch the number of bytes between rows of pixel data for the Y\n               plane\n \\param Uplane the raw pixel data for the U plane\n \\param Upitch the number of bytes between rows of pixel data for the U\n               plane\n \\param Vplane the raw pixel data for the V plane\n \\param Vpitch the number of bytes between rows of pixel data for the V\n               plane\n \\returns 0 on success or -1 if the texture is not valid; call\n          SDL_GetError() for more information.\n\n \\since This function is available since SDL 2.0.1.\n\n \\sa SDL_UpdateTexture"]
     pub fn SDL_UpdateYUVTexture(
         texture: *mut SDL_Texture,
         rect: *const SDL_Rect,
@@ -23555,24 +15675,7 @@ extern "C" {
     ) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Update a rectangle within a planar NV12 or NV21 texture with new pixels."]
-    #[doc = ""]
-    #[doc = " You can use SDL_UpdateTexture() as long as your pixel data is a contiguous"]
-    #[doc = " block of NV12/21 planes in the proper order, but this function is available"]
-    #[doc = " if your pixel data is not contiguous."]
-    #[doc = ""]
-    #[doc = " \\param texture the texture to update"]
-    #[doc = " \\param rect a pointer to the rectangle of pixels to update, or NULL to"]
-    #[doc = "             update the entire texture."]
-    #[doc = " \\param Yplane the raw pixel data for the Y plane."]
-    #[doc = " \\param Ypitch the number of bytes between rows of pixel data for the Y"]
-    #[doc = "               plane."]
-    #[doc = " \\param UVplane the raw pixel data for the UV plane."]
-    #[doc = " \\param UVpitch the number of bytes between rows of pixel data for the UV"]
-    #[doc = "                plane."]
-    #[doc = " \\return 0 on success, or -1 if the texture is not valid."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.16."]
+    #[doc = " Update a rectangle within a planar NV12 or NV21 texture with new pixels.\n\n You can use SDL_UpdateTexture() as long as your pixel data is a contiguous\n block of NV12/21 planes in the proper order, but this function is available\n if your pixel data is not contiguous.\n\n \\param texture the texture to update\n \\param rect a pointer to the rectangle of pixels to update, or NULL to\n             update the entire texture.\n \\param Yplane the raw pixel data for the Y plane.\n \\param Ypitch the number of bytes between rows of pixel data for the Y\n               plane.\n \\param UVplane the raw pixel data for the UV plane.\n \\param UVpitch the number of bytes between rows of pixel data for the UV\n                plane.\n \\return 0 on success, or -1 if the texture is not valid.\n\n \\since This function is available since SDL 2.0.16."]
     pub fn SDL_UpdateNVTexture(
         texture: *mut SDL_Texture,
         rect: *const SDL_Rect,
@@ -23583,31 +15686,7 @@ extern "C" {
     ) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Lock a portion of the texture for **write-only** pixel access."]
-    #[doc = ""]
-    #[doc = " As an optimization, the pixels made available for editing don't necessarily"]
-    #[doc = " contain the old texture data. This is a write-only operation, and if you"]
-    #[doc = " need to keep a copy of the texture data you should do that at the"]
-    #[doc = " application level."]
-    #[doc = ""]
-    #[doc = " You must use SDL_UnlockTexture() to unlock the pixels and apply any"]
-    #[doc = " changes."]
-    #[doc = ""]
-    #[doc = " \\param texture the texture to lock for access, which was created with"]
-    #[doc = "                `SDL_TEXTUREACCESS_STREAMING`"]
-    #[doc = " \\param rect an SDL_Rect structure representing the area to lock for access;"]
-    #[doc = "             NULL to lock the entire texture"]
-    #[doc = " \\param pixels this is filled in with a pointer to the locked pixels,"]
-    #[doc = "               appropriately offset by the locked area"]
-    #[doc = " \\param pitch this is filled in with the pitch of the locked pixels; the"]
-    #[doc = "              pitch is the length of one row in bytes"]
-    #[doc = " \\returns 0 on success or a negative error code if the texture is not valid"]
-    #[doc = "          or was not created with `SDL_TEXTUREACCESS_STREAMING`; call"]
-    #[doc = "          SDL_GetError() for more information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_UnlockTexture"]
+    #[doc = " Lock a portion of the texture for **write-only** pixel access.\n\n As an optimization, the pixels made available for editing don't necessarily\n contain the old texture data. This is a write-only operation, and if you\n need to keep a copy of the texture data you should do that at the\n application level.\n\n You must use SDL_UnlockTexture() to unlock the pixels and apply any\n changes.\n\n \\param texture the texture to lock for access, which was created with\n                `SDL_TEXTUREACCESS_STREAMING`\n \\param rect an SDL_Rect structure representing the area to lock for access;\n             NULL to lock the entire texture\n \\param pixels this is filled in with a pointer to the locked pixels,\n               appropriately offset by the locked area\n \\param pitch this is filled in with the pitch of the locked pixels; the\n              pitch is the length of one row in bytes\n \\returns 0 on success or a negative error code if the texture is not valid\n          or was not created with `SDL_TEXTUREACCESS_STREAMING`; call\n          SDL_GetError() for more information.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_UnlockTexture"]
     pub fn SDL_LockTexture(
         texture: *mut SDL_Texture,
         rect: *const SDL_Rect,
@@ -23616,36 +15695,7 @@ extern "C" {
     ) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Lock a portion of the texture for **write-only** pixel access, and expose"]
-    #[doc = " it as a SDL surface."]
-    #[doc = ""]
-    #[doc = " Besides providing an SDL_Surface instead of raw pixel data, this function"]
-    #[doc = " operates like SDL_LockTexture."]
-    #[doc = ""]
-    #[doc = " As an optimization, the pixels made available for editing don't necessarily"]
-    #[doc = " contain the old texture data. This is a write-only operation, and if you"]
-    #[doc = " need to keep a copy of the texture data you should do that at the"]
-    #[doc = " application level."]
-    #[doc = ""]
-    #[doc = " You must use SDL_UnlockTexture() to unlock the pixels and apply any"]
-    #[doc = " changes."]
-    #[doc = ""]
-    #[doc = " The returned surface is freed internally after calling SDL_UnlockTexture()"]
-    #[doc = " or SDL_DestroyTexture(). The caller should not free it."]
-    #[doc = ""]
-    #[doc = " \\param texture the texture to lock for access, which was created with"]
-    #[doc = "                `SDL_TEXTUREACCESS_STREAMING`"]
-    #[doc = " \\param rect a pointer to the rectangle to lock for access. If the rect is"]
-    #[doc = "             NULL, the entire texture will be locked"]
-    #[doc = " \\param surface this is filled in with an SDL surface representing the"]
-    #[doc = "                locked area"]
-    #[doc = " \\returns 0 on success, or -1 if the texture is not valid or was not created"]
-    #[doc = "          with `SDL_TEXTUREACCESS_STREAMING`"]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.12."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_LockTexture"]
-    #[doc = " \\sa SDL_UnlockTexture"]
+    #[doc = " Lock a portion of the texture for **write-only** pixel access, and expose\n it as a SDL surface.\n\n Besides providing an SDL_Surface instead of raw pixel data, this function\n operates like SDL_LockTexture.\n\n As an optimization, the pixels made available for editing don't necessarily\n contain the old texture data. This is a write-only operation, and if you\n need to keep a copy of the texture data you should do that at the\n application level.\n\n You must use SDL_UnlockTexture() to unlock the pixels and apply any\n changes.\n\n The returned surface is freed internally after calling SDL_UnlockTexture()\n or SDL_DestroyTexture(). The caller should not free it.\n\n \\param texture the texture to lock for access, which was created with\n                `SDL_TEXTUREACCESS_STREAMING`\n \\param rect a pointer to the rectangle to lock for access. If the rect is\n             NULL, the entire texture will be locked\n \\param surface this is filled in with an SDL surface representing the\n                locked area\n \\returns 0 on success, or -1 if the texture is not valid or was not created\n          with `SDL_TEXTUREACCESS_STREAMING`\n\n \\since This function is available since SDL 2.0.12.\n\n \\sa SDL_LockTexture\n \\sa SDL_UnlockTexture"]
     pub fn SDL_LockTextureToSurface(
         texture: *mut SDL_Texture,
         rect: *const SDL_Rect,
@@ -23653,99 +15703,26 @@ extern "C" {
     ) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Unlock a texture, uploading the changes to video memory, if needed."]
-    #[doc = ""]
-    #[doc = " **Warning**: Please note that SDL_LockTexture() is intended to be"]
-    #[doc = " write-only; it will not guarantee the previous contents of the texture will"]
-    #[doc = " be provided. You must fully initialize any area of a texture that you lock"]
-    #[doc = " before unlocking it, as the pixels might otherwise be uninitialized memory."]
-    #[doc = ""]
-    #[doc = " Which is to say: locking and immediately unlocking a texture can result in"]
-    #[doc = " corrupted textures, depending on the renderer in use."]
-    #[doc = ""]
-    #[doc = " \\param texture a texture locked by SDL_LockTexture()"]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_LockTexture"]
+    #[doc = " Unlock a texture, uploading the changes to video memory, if needed.\n\n **Warning**: Please note that SDL_LockTexture() is intended to be\n write-only; it will not guarantee the previous contents of the texture will\n be provided. You must fully initialize any area of a texture that you lock\n before unlocking it, as the pixels might otherwise be uninitialized memory.\n\n Which is to say: locking and immediately unlocking a texture can result in\n corrupted textures, depending on the renderer in use.\n\n \\param texture a texture locked by SDL_LockTexture()\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_LockTexture"]
     pub fn SDL_UnlockTexture(texture: *mut SDL_Texture);
 }
 extern "C" {
-    #[doc = " Determine whether a renderer supports the use of render targets."]
-    #[doc = ""]
-    #[doc = " \\param renderer the renderer that will be checked"]
-    #[doc = " \\returns SDL_TRUE if supported or SDL_FALSE if not."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_SetRenderTarget"]
+    #[doc = " Determine whether a renderer supports the use of render targets.\n\n \\param renderer the renderer that will be checked\n \\returns SDL_TRUE if supported or SDL_FALSE if not.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_SetRenderTarget"]
     pub fn SDL_RenderTargetSupported(renderer: *mut SDL_Renderer) -> SDL_bool;
 }
 extern "C" {
-    #[doc = " Set a texture as the current rendering target."]
-    #[doc = ""]
-    #[doc = " Before using this function, you should check the"]
-    #[doc = " `SDL_RENDERER_TARGETTEXTURE` bit in the flags of SDL_RendererInfo to see if"]
-    #[doc = " render targets are supported."]
-    #[doc = ""]
-    #[doc = " The default render target is the window for which the renderer was created."]
-    #[doc = " To stop rendering to a texture and render to the window again, call this"]
-    #[doc = " function with a NULL `texture`."]
-    #[doc = ""]
-    #[doc = " \\param renderer the rendering context"]
-    #[doc = " \\param texture the targeted texture, which must be created with the"]
-    #[doc = "                `SDL_TEXTUREACCESS_TARGET` flag, or NULL to render to the"]
-    #[doc = "                window instead of a texture."]
-    #[doc = " \\returns 0 on success or a negative error code on failure; call"]
-    #[doc = "          SDL_GetError() for more information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_GetRenderTarget"]
+    #[doc = " Set a texture as the current rendering target.\n\n Before using this function, you should check the\n `SDL_RENDERER_TARGETTEXTURE` bit in the flags of SDL_RendererInfo to see if\n render targets are supported.\n\n The default render target is the window for which the renderer was created.\n To stop rendering to a texture and render to the window again, call this\n function with a NULL `texture`.\n\n \\param renderer the rendering context\n \\param texture the targeted texture, which must be created with the\n                `SDL_TEXTUREACCESS_TARGET` flag, or NULL to render to the\n                window instead of a texture.\n \\returns 0 on success or a negative error code on failure; call\n          SDL_GetError() for more information.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_GetRenderTarget"]
     pub fn SDL_SetRenderTarget(
         renderer: *mut SDL_Renderer,
         texture: *mut SDL_Texture,
     ) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Get the current render target."]
-    #[doc = ""]
-    #[doc = " The default render target is the window for which the renderer was created,"]
-    #[doc = " and is reported a NULL here."]
-    #[doc = ""]
-    #[doc = " \\param renderer the rendering context"]
-    #[doc = " \\returns the current render target or NULL for the default render target."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_SetRenderTarget"]
+    #[doc = " Get the current render target.\n\n The default render target is the window for which the renderer was created,\n and is reported a NULL here.\n\n \\param renderer the rendering context\n \\returns the current render target or NULL for the default render target.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_SetRenderTarget"]
     pub fn SDL_GetRenderTarget(renderer: *mut SDL_Renderer) -> *mut SDL_Texture;
 }
 extern "C" {
-    #[doc = " Set a device independent resolution for rendering."]
-    #[doc = ""]
-    #[doc = " This function uses the viewport and scaling functionality to allow a fixed"]
-    #[doc = " logical resolution for rendering, regardless of the actual output"]
-    #[doc = " resolution. If the actual output resolution doesn't have the same aspect"]
-    #[doc = " ratio the output rendering will be centered within the output display."]
-    #[doc = ""]
-    #[doc = " If the output display is a window, mouse and touch events in the window"]
-    #[doc = " will be filtered and scaled so they seem to arrive within the logical"]
-    #[doc = " resolution. The SDL_HINT_MOUSE_RELATIVE_SCALING hint controls whether"]
-    #[doc = " relative motion events are also scaled."]
-    #[doc = ""]
-    #[doc = " If this function results in scaling or subpixel drawing by the rendering"]
-    #[doc = " backend, it will be handled using the appropriate quality hints."]
-    #[doc = ""]
-    #[doc = " \\param renderer the renderer for which resolution should be set"]
-    #[doc = " \\param w the width of the logical resolution"]
-    #[doc = " \\param h the height of the logical resolution"]
-    #[doc = " \\returns 0 on success or a negative error code on failure; call"]
-    #[doc = "          SDL_GetError() for more information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_RenderGetLogicalSize"]
+    #[doc = " Set a device independent resolution for rendering.\n\n This function uses the viewport and scaling functionality to allow a fixed\n logical resolution for rendering, regardless of the actual output\n resolution. If the actual output resolution doesn't have the same aspect\n ratio the output rendering will be centered within the output display.\n\n If the output display is a window, mouse and touch events in the window\n will be filtered and scaled so they seem to arrive within the logical\n resolution. The SDL_HINT_MOUSE_RELATIVE_SCALING hint controls whether\n relative motion events are also scaled.\n\n If this function results in scaling or subpixel drawing by the rendering\n backend, it will be handled using the appropriate quality hints.\n\n \\param renderer the renderer for which resolution should be set\n \\param w the width of the logical resolution\n \\param h the height of the logical resolution\n \\returns 0 on success or a negative error code on failure; call\n          SDL_GetError() for more information.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_RenderGetLogicalSize"]
     pub fn SDL_RenderSetLogicalSize(
         renderer: *mut SDL_Renderer,
         w: libc::c_int,
@@ -23753,19 +15730,7 @@ extern "C" {
     ) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Get device independent resolution for rendering."]
-    #[doc = ""]
-    #[doc = " This may return 0 for `w` and `h` if the SDL_Renderer has never had its"]
-    #[doc = " logical size set by SDL_RenderSetLogicalSize() and never had a render"]
-    #[doc = " target set."]
-    #[doc = ""]
-    #[doc = " \\param renderer a rendering context"]
-    #[doc = " \\param w an int to be filled with the width"]
-    #[doc = " \\param h an int to be filled with the height"]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_RenderSetLogicalSize"]
+    #[doc = " Get device independent resolution for rendering.\n\n When using the main rendering target (eg no target texture is set): this\n may return 0 for `w` and `h` if the SDL_Renderer has never had its logical\n size set by SDL_RenderSetLogicalSize(). Otherwise it returns the logical\n width and height.\n\n When using a target texture: Never return 0 for `w` and `h` at first. Then\n it returns the logical width and height that are set.\n\n \\param renderer a rendering context\n \\param w an int to be filled with the width\n \\param h an int to be filled with the height\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_RenderSetLogicalSize"]
     pub fn SDL_RenderGetLogicalSize(
         renderer: *mut SDL_Renderer,
         w: *mut libc::c_int,
@@ -23773,164 +15738,46 @@ extern "C" {
     );
 }
 extern "C" {
-    #[doc = " Set whether to force integer scales for resolution-independent rendering."]
-    #[doc = ""]
-    #[doc = " This function restricts the logical viewport to integer values - that is,"]
-    #[doc = " when a resolution is between two multiples of a logical size, the viewport"]
-    #[doc = " size is rounded down to the lower multiple."]
-    #[doc = ""]
-    #[doc = " \\param renderer the renderer for which integer scaling should be set"]
-    #[doc = " \\param enable enable or disable the integer scaling for rendering"]
-    #[doc = " \\returns 0 on success or a negative error code on failure; call"]
-    #[doc = "          SDL_GetError() for more information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.5."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_RenderGetIntegerScale"]
-    #[doc = " \\sa SDL_RenderSetLogicalSize"]
+    #[doc = " Set whether to force integer scales for resolution-independent rendering.\n\n This function restricts the logical viewport to integer values - that is,\n when a resolution is between two multiples of a logical size, the viewport\n size is rounded down to the lower multiple.\n\n \\param renderer the renderer for which integer scaling should be set\n \\param enable enable or disable the integer scaling for rendering\n \\returns 0 on success or a negative error code on failure; call\n          SDL_GetError() for more information.\n\n \\since This function is available since SDL 2.0.5.\n\n \\sa SDL_RenderGetIntegerScale\n \\sa SDL_RenderSetLogicalSize"]
     pub fn SDL_RenderSetIntegerScale(renderer: *mut SDL_Renderer, enable: SDL_bool) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Get whether integer scales are forced for resolution-independent rendering."]
-    #[doc = ""]
-    #[doc = " \\param renderer the renderer from which integer scaling should be queried"]
-    #[doc = " \\returns SDL_TRUE if integer scales are forced or SDL_FALSE if not and on"]
-    #[doc = "          failure; call SDL_GetError() for more information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.5."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_RenderSetIntegerScale"]
+    #[doc = " Get whether integer scales are forced for resolution-independent rendering.\n\n \\param renderer the renderer from which integer scaling should be queried\n \\returns SDL_TRUE if integer scales are forced or SDL_FALSE if not and on\n          failure; call SDL_GetError() for more information.\n\n \\since This function is available since SDL 2.0.5.\n\n \\sa SDL_RenderSetIntegerScale"]
     pub fn SDL_RenderGetIntegerScale(renderer: *mut SDL_Renderer) -> SDL_bool;
 }
 extern "C" {
-    #[doc = " Set the drawing area for rendering on the current target."]
-    #[doc = ""]
-    #[doc = " When the window is resized, the viewport is reset to fill the entire new"]
-    #[doc = " window size."]
-    #[doc = ""]
-    #[doc = " \\param renderer the rendering context"]
-    #[doc = " \\param rect the SDL_Rect structure representing the drawing area, or NULL"]
-    #[doc = "             to set the viewport to the entire target"]
-    #[doc = " \\returns 0 on success or a negative error code on failure; call"]
-    #[doc = "          SDL_GetError() for more information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_RenderGetViewport"]
+    #[doc = " Set the drawing area for rendering on the current target.\n\n When the window is resized, the viewport is reset to fill the entire new\n window size.\n\n \\param renderer the rendering context\n \\param rect the SDL_Rect structure representing the drawing area, or NULL\n             to set the viewport to the entire target\n \\returns 0 on success or a negative error code on failure; call\n          SDL_GetError() for more information.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_RenderGetViewport"]
     pub fn SDL_RenderSetViewport(renderer: *mut SDL_Renderer, rect: *const SDL_Rect)
         -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Get the drawing area for the current target."]
-    #[doc = ""]
-    #[doc = " \\param renderer the rendering context"]
-    #[doc = " \\param rect an SDL_Rect structure filled in with the current drawing area"]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_RenderSetViewport"]
+    #[doc = " Get the drawing area for the current target.\n\n \\param renderer the rendering context\n \\param rect an SDL_Rect structure filled in with the current drawing area\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_RenderSetViewport"]
     pub fn SDL_RenderGetViewport(renderer: *mut SDL_Renderer, rect: *mut SDL_Rect);
 }
 extern "C" {
-    #[doc = " Set the clip rectangle for rendering on the specified target."]
-    #[doc = ""]
-    #[doc = " \\param renderer the rendering context for which clip rectangle should be"]
-    #[doc = "                 set"]
-    #[doc = " \\param rect an SDL_Rect structure representing the clip area, relative to"]
-    #[doc = "             the viewport, or NULL to disable clipping"]
-    #[doc = " \\returns 0 on success or a negative error code on failure; call"]
-    #[doc = "          SDL_GetError() for more information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_RenderGetClipRect"]
-    #[doc = " \\sa SDL_RenderIsClipEnabled"]
+    #[doc = " Set the clip rectangle for rendering on the specified target.\n\n \\param renderer the rendering context for which clip rectangle should be\n                 set\n \\param rect an SDL_Rect structure representing the clip area, relative to\n             the viewport, or NULL to disable clipping\n \\returns 0 on success or a negative error code on failure; call\n          SDL_GetError() for more information.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_RenderGetClipRect\n \\sa SDL_RenderIsClipEnabled"]
     pub fn SDL_RenderSetClipRect(renderer: *mut SDL_Renderer, rect: *const SDL_Rect)
         -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Get the clip rectangle for the current target."]
-    #[doc = ""]
-    #[doc = " \\param renderer the rendering context from which clip rectangle should be"]
-    #[doc = "                 queried"]
-    #[doc = " \\param rect an SDL_Rect structure filled in with the current clipping area"]
-    #[doc = "             or an empty rectangle if clipping is disabled"]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_RenderIsClipEnabled"]
-    #[doc = " \\sa SDL_RenderSetClipRect"]
+    #[doc = " Get the clip rectangle for the current target.\n\n \\param renderer the rendering context from which clip rectangle should be\n                 queried\n \\param rect an SDL_Rect structure filled in with the current clipping area\n             or an empty rectangle if clipping is disabled\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_RenderIsClipEnabled\n \\sa SDL_RenderSetClipRect"]
     pub fn SDL_RenderGetClipRect(renderer: *mut SDL_Renderer, rect: *mut SDL_Rect);
 }
 extern "C" {
-    #[doc = " Get whether clipping is enabled on the given renderer."]
-    #[doc = ""]
-    #[doc = " \\param renderer the renderer from which clip state should be queried"]
-    #[doc = " \\returns SDL_TRUE if clipping is enabled or SDL_FALSE if not; call"]
-    #[doc = "          SDL_GetError() for more information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.4."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_RenderGetClipRect"]
-    #[doc = " \\sa SDL_RenderSetClipRect"]
+    #[doc = " Get whether clipping is enabled on the given renderer.\n\n \\param renderer the renderer from which clip state should be queried\n \\returns SDL_TRUE if clipping is enabled or SDL_FALSE if not; call\n          SDL_GetError() for more information.\n\n \\since This function is available since SDL 2.0.4.\n\n \\sa SDL_RenderGetClipRect\n \\sa SDL_RenderSetClipRect"]
     pub fn SDL_RenderIsClipEnabled(renderer: *mut SDL_Renderer) -> SDL_bool;
 }
 extern "C" {
-    #[doc = " Set the drawing scale for rendering on the current target."]
-    #[doc = ""]
-    #[doc = " The drawing coordinates are scaled by the x/y scaling factors before they"]
-    #[doc = " are used by the renderer. This allows resolution independent drawing with a"]
-    #[doc = " single coordinate system."]
-    #[doc = ""]
-    #[doc = " If this results in scaling or subpixel drawing by the rendering backend, it"]
-    #[doc = " will be handled using the appropriate quality hints. For best results use"]
-    #[doc = " integer scaling factors."]
-    #[doc = ""]
-    #[doc = " \\param renderer a rendering context"]
-    #[doc = " \\param scaleX the horizontal scaling factor"]
-    #[doc = " \\param scaleY the vertical scaling factor"]
-    #[doc = " \\returns 0 on success or a negative error code on failure; call"]
-    #[doc = "          SDL_GetError() for more information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_RenderGetScale"]
-    #[doc = " \\sa SDL_RenderSetLogicalSize"]
+    #[doc = " Set the drawing scale for rendering on the current target.\n\n The drawing coordinates are scaled by the x/y scaling factors before they\n are used by the renderer. This allows resolution independent drawing with a\n single coordinate system.\n\n If this results in scaling or subpixel drawing by the rendering backend, it\n will be handled using the appropriate quality hints. For best results use\n integer scaling factors.\n\n \\param renderer a rendering context\n \\param scaleX the horizontal scaling factor\n \\param scaleY the vertical scaling factor\n \\returns 0 on success or a negative error code on failure; call\n          SDL_GetError() for more information.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_RenderGetScale\n \\sa SDL_RenderSetLogicalSize"]
     pub fn SDL_RenderSetScale(renderer: *mut SDL_Renderer, scaleX: f32, scaleY: f32)
         -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Get the drawing scale for the current target."]
-    #[doc = ""]
-    #[doc = " \\param renderer the renderer from which drawing scale should be queried"]
-    #[doc = " \\param scaleX a pointer filled in with the horizontal scaling factor"]
-    #[doc = " \\param scaleY a pointer filled in with the vertical scaling factor"]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_RenderSetScale"]
+    #[doc = " Get the drawing scale for the current target.\n\n \\param renderer the renderer from which drawing scale should be queried\n \\param scaleX a pointer filled in with the horizontal scaling factor\n \\param scaleY a pointer filled in with the vertical scaling factor\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_RenderSetScale"]
     pub fn SDL_RenderGetScale(renderer: *mut SDL_Renderer, scaleX: *mut f32, scaleY: *mut f32);
 }
 extern "C" {
-    #[doc = " Get logical coordinates of point in renderer when given real coordinates of"]
-    #[doc = " point in window."]
-    #[doc = ""]
-    #[doc = " Logical coordinates will differ from real coordinates when render is scaled"]
-    #[doc = " and logical renderer size set"]
-    #[doc = ""]
-    #[doc = " \\param renderer the renderer from which the logical coordinates should be"]
-    #[doc = "                 calcualted"]
-    #[doc = " \\param windowX the real X coordinate in the window"]
-    #[doc = " \\param windowY the real Y coordinate in the window"]
-    #[doc = " \\param logicalX the pointer filled with the logical x coordinate"]
-    #[doc = " \\param logicalY the pointer filled with the logical y coordinate"]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.18."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_RenderGetScale"]
-    #[doc = " \\sa SDL_RenderSetScale"]
-    #[doc = " \\sa SDL_RenderGetLogicalSize"]
-    #[doc = " \\sa SDL_RenderSetLogicalSize"]
+    #[doc = " Get logical coordinates of point in renderer when given real coordinates of\n point in window.\n\n Logical coordinates will differ from real coordinates when render is scaled\n and logical renderer size set\n\n \\param renderer the renderer from which the logical coordinates should be\n                 calculated\n \\param windowX the real X coordinate in the window\n \\param windowY the real Y coordinate in the window\n \\param logicalX the pointer filled with the logical x coordinate\n \\param logicalY the pointer filled with the logical y coordinate\n\n \\since This function is available since SDL 2.0.18.\n\n \\sa SDL_RenderGetScale\n \\sa SDL_RenderSetScale\n \\sa SDL_RenderGetLogicalSize\n \\sa SDL_RenderSetLogicalSize"]
     pub fn SDL_RenderWindowToLogical(
         renderer: *mut SDL_Renderer,
         windowX: libc::c_int,
@@ -23940,22 +15787,7 @@ extern "C" {
     );
 }
 extern "C" {
-    #[doc = " Get real coordinates of point in window when given logical coordinates of point in renderer."]
-    #[doc = " Logical coordinates will differ from real coordinates when render is scaled and logical renderer size set"]
-    #[doc = ""]
-    #[doc = " \\param renderer the renderer from which the window coordinates should be calculated"]
-    #[doc = " \\param logicalX the logical x coordinate"]
-    #[doc = " \\param logicalY the logical y coordinate"]
-    #[doc = " \\param windowX the pointer filled with the real X coordinate in the window"]
-    #[doc = " \\param windowY the pointer filled with the real Y coordinate in the window"]
-    #[doc = ""]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.18."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_RenderGetScale"]
-    #[doc = " \\sa SDL_RenderSetScale"]
-    #[doc = " \\sa SDL_RenderGetLogicalSize"]
-    #[doc = " \\sa SDL_RenderSetLogicalSize"]
+    #[doc = " Get real coordinates of point in window when given logical coordinates of\n point in renderer.\n\n Logical coordinates will differ from real coordinates when render is scaled\n and logical renderer size set\n\n \\param renderer the renderer from which the window coordinates should be\n                 calculated\n \\param logicalX the logical x coordinate\n \\param logicalY the logical y coordinate\n \\param windowX the pointer filled with the real X coordinate in the window\n \\param windowY the pointer filled with the real Y coordinate in the window\n\n \\since This function is available since SDL 2.0.18.\n\n \\sa SDL_RenderGetScale\n \\sa SDL_RenderSetScale\n \\sa SDL_RenderGetLogicalSize\n \\sa SDL_RenderSetLogicalSize"]
     pub fn SDL_RenderLogicalToWindow(
         renderer: *mut SDL_Renderer,
         logicalX: f32,
@@ -23965,33 +15797,7 @@ extern "C" {
     );
 }
 extern "C" {
-    #[doc = " Set the color used for drawing operations (Rect, Line and Clear)."]
-    #[doc = ""]
-    #[doc = " Set the color for drawing or filling rectangles, lines, and points, and for"]
-    #[doc = " SDL_RenderClear()."]
-    #[doc = ""]
-    #[doc = " \\param renderer the rendering context"]
-    #[doc = " \\param r the red value used to draw on the rendering target"]
-    #[doc = " \\param g the green value used to draw on the rendering target"]
-    #[doc = " \\param b the blue value used to draw on the rendering target"]
-    #[doc = " \\param a the alpha value used to draw on the rendering target; usually"]
-    #[doc = "          `SDL_ALPHA_OPAQUE` (255). Use SDL_SetRenderDrawBlendMode to"]
-    #[doc = "          specify how the alpha channel is used"]
-    #[doc = " \\returns 0 on success or a negative error code on failure; call"]
-    #[doc = "          SDL_GetError() for more information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_GetRenderDrawColor"]
-    #[doc = " \\sa SDL_RenderClear"]
-    #[doc = " \\sa SDL_RenderDrawLine"]
-    #[doc = " \\sa SDL_RenderDrawLines"]
-    #[doc = " \\sa SDL_RenderDrawPoint"]
-    #[doc = " \\sa SDL_RenderDrawPoints"]
-    #[doc = " \\sa SDL_RenderDrawRect"]
-    #[doc = " \\sa SDL_RenderDrawRects"]
-    #[doc = " \\sa SDL_RenderFillRect"]
-    #[doc = " \\sa SDL_RenderFillRects"]
+    #[doc = " Set the color used for drawing operations (Rect, Line and Clear).\n\n Set the color for drawing or filling rectangles, lines, and points, and for\n SDL_RenderClear().\n\n \\param renderer the rendering context\n \\param r the red value used to draw on the rendering target\n \\param g the green value used to draw on the rendering target\n \\param b the blue value used to draw on the rendering target\n \\param a the alpha value used to draw on the rendering target; usually\n          `SDL_ALPHA_OPAQUE` (255). Use SDL_SetRenderDrawBlendMode to\n          specify how the alpha channel is used\n \\returns 0 on success or a negative error code on failure; call\n          SDL_GetError() for more information.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_GetRenderDrawColor\n \\sa SDL_RenderClear\n \\sa SDL_RenderDrawLine\n \\sa SDL_RenderDrawLines\n \\sa SDL_RenderDrawPoint\n \\sa SDL_RenderDrawPoints\n \\sa SDL_RenderDrawRect\n \\sa SDL_RenderDrawRects\n \\sa SDL_RenderFillRect\n \\sa SDL_RenderFillRects"]
     pub fn SDL_SetRenderDrawColor(
         renderer: *mut SDL_Renderer,
         r: Uint8,
@@ -24001,23 +15807,7 @@ extern "C" {
     ) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Get the color used for drawing operations (Rect, Line and Clear)."]
-    #[doc = ""]
-    #[doc = " \\param renderer the rendering context"]
-    #[doc = " \\param r a pointer filled in with the red value used to draw on the"]
-    #[doc = "          rendering target"]
-    #[doc = " \\param g a pointer filled in with the green value used to draw on the"]
-    #[doc = "          rendering target"]
-    #[doc = " \\param b a pointer filled in with the blue value used to draw on the"]
-    #[doc = "          rendering target"]
-    #[doc = " \\param a a pointer filled in with the alpha value used to draw on the"]
-    #[doc = "          rendering target; usually `SDL_ALPHA_OPAQUE` (255)"]
-    #[doc = " \\returns 0 on success or a negative error code on failure; call"]
-    #[doc = "          SDL_GetError() for more information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_SetRenderDrawColor"]
+    #[doc = " Get the color used for drawing operations (Rect, Line and Clear).\n\n \\param renderer the rendering context\n \\param r a pointer filled in with the red value used to draw on the\n          rendering target\n \\param g a pointer filled in with the green value used to draw on the\n          rendering target\n \\param b a pointer filled in with the blue value used to draw on the\n          rendering target\n \\param a a pointer filled in with the alpha value used to draw on the\n          rendering target; usually `SDL_ALPHA_OPAQUE` (255)\n \\returns 0 on success or a negative error code on failure; call\n          SDL_GetError() for more information.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_SetRenderDrawColor"]
     pub fn SDL_GetRenderDrawColor(
         renderer: *mut SDL_Renderer,
         r: *mut Uint8,
@@ -24027,86 +15817,25 @@ extern "C" {
     ) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Set the blend mode used for drawing operations (Fill and Line)."]
-    #[doc = ""]
-    #[doc = " If the blend mode is not supported, the closest supported mode is chosen."]
-    #[doc = ""]
-    #[doc = " \\param renderer the rendering context"]
-    #[doc = " \\param blendMode the SDL_BlendMode to use for blending"]
-    #[doc = " \\returns 0 on success or a negative error code on failure; call"]
-    #[doc = "          SDL_GetError() for more information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_GetRenderDrawBlendMode"]
-    #[doc = " \\sa SDL_RenderDrawLine"]
-    #[doc = " \\sa SDL_RenderDrawLines"]
-    #[doc = " \\sa SDL_RenderDrawPoint"]
-    #[doc = " \\sa SDL_RenderDrawPoints"]
-    #[doc = " \\sa SDL_RenderDrawRect"]
-    #[doc = " \\sa SDL_RenderDrawRects"]
-    #[doc = " \\sa SDL_RenderFillRect"]
-    #[doc = " \\sa SDL_RenderFillRects"]
+    #[doc = " Set the blend mode used for drawing operations (Fill and Line).\n\n If the blend mode is not supported, the closest supported mode is chosen.\n\n \\param renderer the rendering context\n \\param blendMode the SDL_BlendMode to use for blending\n \\returns 0 on success or a negative error code on failure; call\n          SDL_GetError() for more information.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_GetRenderDrawBlendMode\n \\sa SDL_RenderDrawLine\n \\sa SDL_RenderDrawLines\n \\sa SDL_RenderDrawPoint\n \\sa SDL_RenderDrawPoints\n \\sa SDL_RenderDrawRect\n \\sa SDL_RenderDrawRects\n \\sa SDL_RenderFillRect\n \\sa SDL_RenderFillRects"]
     pub fn SDL_SetRenderDrawBlendMode(
         renderer: *mut SDL_Renderer,
         blendMode: SDL_BlendMode,
     ) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Get the blend mode used for drawing operations."]
-    #[doc = ""]
-    #[doc = " \\param renderer the rendering context"]
-    #[doc = " \\param blendMode a pointer filled in with the current SDL_BlendMode"]
-    #[doc = " \\returns 0 on success or a negative error code on failure; call"]
-    #[doc = "          SDL_GetError() for more information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_SetRenderDrawBlendMode"]
+    #[doc = " Get the blend mode used for drawing operations.\n\n \\param renderer the rendering context\n \\param blendMode a pointer filled in with the current SDL_BlendMode\n \\returns 0 on success or a negative error code on failure; call\n          SDL_GetError() for more information.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_SetRenderDrawBlendMode"]
     pub fn SDL_GetRenderDrawBlendMode(
         renderer: *mut SDL_Renderer,
         blendMode: *mut SDL_BlendMode,
     ) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Clear the current rendering target with the drawing color."]
-    #[doc = ""]
-    #[doc = " This function clears the entire rendering target, ignoring the viewport and"]
-    #[doc = " the clip rectangle."]
-    #[doc = ""]
-    #[doc = " \\param renderer the rendering context"]
-    #[doc = " \\returns 0 on success or a negative error code on failure; call"]
-    #[doc = "          SDL_GetError() for more information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_SetRenderDrawColor"]
+    #[doc = " Clear the current rendering target with the drawing color.\n\n This function clears the entire rendering target, ignoring the viewport and\n the clip rectangle.\n\n \\param renderer the rendering context\n \\returns 0 on success or a negative error code on failure; call\n          SDL_GetError() for more information.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_SetRenderDrawColor"]
     pub fn SDL_RenderClear(renderer: *mut SDL_Renderer) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Draw a point on the current rendering target."]
-    #[doc = ""]
-    #[doc = " SDL_RenderDrawPoint() draws a single point. If you want to draw multiple,"]
-    #[doc = " use SDL_RenderDrawPoints() instead."]
-    #[doc = ""]
-    #[doc = " \\param renderer the rendering context"]
-    #[doc = " \\param x the x coordinate of the point"]
-    #[doc = " \\param y the y coordinate of the point"]
-    #[doc = " \\returns 0 on success or a negative error code on failure; call"]
-    #[doc = "          SDL_GetError() for more information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_RenderDrawLine"]
-    #[doc = " \\sa SDL_RenderDrawLines"]
-    #[doc = " \\sa SDL_RenderDrawPoints"]
-    #[doc = " \\sa SDL_RenderDrawRect"]
-    #[doc = " \\sa SDL_RenderDrawRects"]
-    #[doc = " \\sa SDL_RenderFillRect"]
-    #[doc = " \\sa SDL_RenderFillRects"]
-    #[doc = " \\sa SDL_RenderPresent"]
-    #[doc = " \\sa SDL_SetRenderDrawBlendMode"]
-    #[doc = " \\sa SDL_SetRenderDrawColor"]
+    #[doc = " Draw a point on the current rendering target.\n\n SDL_RenderDrawPoint() draws a single point. If you want to draw multiple,\n use SDL_RenderDrawPoints() instead.\n\n \\param renderer the rendering context\n \\param x the x coordinate of the point\n \\param y the y coordinate of the point\n \\returns 0 on success or a negative error code on failure; call\n          SDL_GetError() for more information.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_RenderDrawLine\n \\sa SDL_RenderDrawLines\n \\sa SDL_RenderDrawPoints\n \\sa SDL_RenderDrawRect\n \\sa SDL_RenderDrawRects\n \\sa SDL_RenderFillRect\n \\sa SDL_RenderFillRects\n \\sa SDL_RenderPresent\n \\sa SDL_SetRenderDrawBlendMode\n \\sa SDL_SetRenderDrawColor"]
     pub fn SDL_RenderDrawPoint(
         renderer: *mut SDL_Renderer,
         x: libc::c_int,
@@ -24114,27 +15843,7 @@ extern "C" {
     ) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Draw multiple points on the current rendering target."]
-    #[doc = ""]
-    #[doc = " \\param renderer the rendering context"]
-    #[doc = " \\param points an array of SDL_Point structures that represent the points to"]
-    #[doc = "               draw"]
-    #[doc = " \\param count the number of points to draw"]
-    #[doc = " \\returns 0 on success or a negative error code on failure; call"]
-    #[doc = "          SDL_GetError() for more information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_RenderDrawLine"]
-    #[doc = " \\sa SDL_RenderDrawLines"]
-    #[doc = " \\sa SDL_RenderDrawPoint"]
-    #[doc = " \\sa SDL_RenderDrawRect"]
-    #[doc = " \\sa SDL_RenderDrawRects"]
-    #[doc = " \\sa SDL_RenderFillRect"]
-    #[doc = " \\sa SDL_RenderFillRects"]
-    #[doc = " \\sa SDL_RenderPresent"]
-    #[doc = " \\sa SDL_SetRenderDrawBlendMode"]
-    #[doc = " \\sa SDL_SetRenderDrawColor"]
+    #[doc = " Draw multiple points on the current rendering target.\n\n \\param renderer the rendering context\n \\param points an array of SDL_Point structures that represent the points to\n               draw\n \\param count the number of points to draw\n \\returns 0 on success or a negative error code on failure; call\n          SDL_GetError() for more information.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_RenderDrawLine\n \\sa SDL_RenderDrawLines\n \\sa SDL_RenderDrawPoint\n \\sa SDL_RenderDrawRect\n \\sa SDL_RenderDrawRects\n \\sa SDL_RenderFillRect\n \\sa SDL_RenderFillRects\n \\sa SDL_RenderPresent\n \\sa SDL_SetRenderDrawBlendMode\n \\sa SDL_SetRenderDrawColor"]
     pub fn SDL_RenderDrawPoints(
         renderer: *mut SDL_Renderer,
         points: *const SDL_Point,
@@ -24142,31 +15851,7 @@ extern "C" {
     ) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Draw a line on the current rendering target."]
-    #[doc = ""]
-    #[doc = " SDL_RenderDrawLine() draws the line to include both end points. If you want"]
-    #[doc = " to draw multiple, connecting lines use SDL_RenderDrawLines() instead."]
-    #[doc = ""]
-    #[doc = " \\param renderer the rendering context"]
-    #[doc = " \\param x1 the x coordinate of the start point"]
-    #[doc = " \\param y1 the y coordinate of the start point"]
-    #[doc = " \\param x2 the x coordinate of the end point"]
-    #[doc = " \\param y2 the y coordinate of the end point"]
-    #[doc = " \\returns 0 on success or a negative error code on failure; call"]
-    #[doc = "          SDL_GetError() for more information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_RenderDrawLines"]
-    #[doc = " \\sa SDL_RenderDrawPoint"]
-    #[doc = " \\sa SDL_RenderDrawPoints"]
-    #[doc = " \\sa SDL_RenderDrawRect"]
-    #[doc = " \\sa SDL_RenderDrawRects"]
-    #[doc = " \\sa SDL_RenderFillRect"]
-    #[doc = " \\sa SDL_RenderFillRects"]
-    #[doc = " \\sa SDL_RenderPresent"]
-    #[doc = " \\sa SDL_SetRenderDrawBlendMode"]
-    #[doc = " \\sa SDL_SetRenderDrawColor"]
+    #[doc = " Draw a line on the current rendering target.\n\n SDL_RenderDrawLine() draws the line to include both end points. If you want\n to draw multiple, connecting lines use SDL_RenderDrawLines() instead.\n\n \\param renderer the rendering context\n \\param x1 the x coordinate of the start point\n \\param y1 the y coordinate of the start point\n \\param x2 the x coordinate of the end point\n \\param y2 the y coordinate of the end point\n \\returns 0 on success or a negative error code on failure; call\n          SDL_GetError() for more information.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_RenderDrawLines\n \\sa SDL_RenderDrawPoint\n \\sa SDL_RenderDrawPoints\n \\sa SDL_RenderDrawRect\n \\sa SDL_RenderDrawRects\n \\sa SDL_RenderFillRect\n \\sa SDL_RenderFillRects\n \\sa SDL_RenderPresent\n \\sa SDL_SetRenderDrawBlendMode\n \\sa SDL_SetRenderDrawColor"]
     pub fn SDL_RenderDrawLine(
         renderer: *mut SDL_Renderer,
         x1: libc::c_int,
@@ -24176,27 +15861,7 @@ extern "C" {
     ) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Draw a series of connected lines on the current rendering target."]
-    #[doc = ""]
-    #[doc = " \\param renderer the rendering context"]
-    #[doc = " \\param points an array of SDL_Point structures representing points along"]
-    #[doc = "               the lines"]
-    #[doc = " \\param count the number of points, drawing count-1 lines"]
-    #[doc = " \\returns 0 on success or a negative error code on failure; call"]
-    #[doc = "          SDL_GetError() for more information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_RenderDrawLine"]
-    #[doc = " \\sa SDL_RenderDrawPoint"]
-    #[doc = " \\sa SDL_RenderDrawPoints"]
-    #[doc = " \\sa SDL_RenderDrawRect"]
-    #[doc = " \\sa SDL_RenderDrawRects"]
-    #[doc = " \\sa SDL_RenderFillRect"]
-    #[doc = " \\sa SDL_RenderFillRects"]
-    #[doc = " \\sa SDL_RenderPresent"]
-    #[doc = " \\sa SDL_SetRenderDrawBlendMode"]
-    #[doc = " \\sa SDL_SetRenderDrawColor"]
+    #[doc = " Draw a series of connected lines on the current rendering target.\n\n \\param renderer the rendering context\n \\param points an array of SDL_Point structures representing points along\n               the lines\n \\param count the number of points, drawing count-1 lines\n \\returns 0 on success or a negative error code on failure; call\n          SDL_GetError() for more information.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_RenderDrawLine\n \\sa SDL_RenderDrawPoint\n \\sa SDL_RenderDrawPoints\n \\sa SDL_RenderDrawRect\n \\sa SDL_RenderDrawRects\n \\sa SDL_RenderFillRect\n \\sa SDL_RenderFillRects\n \\sa SDL_RenderPresent\n \\sa SDL_SetRenderDrawBlendMode\n \\sa SDL_SetRenderDrawColor"]
     pub fn SDL_RenderDrawLines(
         renderer: *mut SDL_Renderer,
         points: *const SDL_Point,
@@ -24204,50 +15869,11 @@ extern "C" {
     ) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Draw a rectangle on the current rendering target."]
-    #[doc = ""]
-    #[doc = " \\param renderer the rendering context"]
-    #[doc = " \\param rect an SDL_Rect structure representing the rectangle to draw, or"]
-    #[doc = "             NULL to outline the entire rendering target"]
-    #[doc = " \\returns 0 on success or a negative error code on failure; call"]
-    #[doc = "          SDL_GetError() for more information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_RenderDrawLine"]
-    #[doc = " \\sa SDL_RenderDrawLines"]
-    #[doc = " \\sa SDL_RenderDrawPoint"]
-    #[doc = " \\sa SDL_RenderDrawPoints"]
-    #[doc = " \\sa SDL_RenderDrawRects"]
-    #[doc = " \\sa SDL_RenderFillRect"]
-    #[doc = " \\sa SDL_RenderFillRects"]
-    #[doc = " \\sa SDL_RenderPresent"]
-    #[doc = " \\sa SDL_SetRenderDrawBlendMode"]
-    #[doc = " \\sa SDL_SetRenderDrawColor"]
+    #[doc = " Draw a rectangle on the current rendering target.\n\n \\param renderer the rendering context\n \\param rect an SDL_Rect structure representing the rectangle to draw, or\n             NULL to outline the entire rendering target\n \\returns 0 on success or a negative error code on failure; call\n          SDL_GetError() for more information.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_RenderDrawLine\n \\sa SDL_RenderDrawLines\n \\sa SDL_RenderDrawPoint\n \\sa SDL_RenderDrawPoints\n \\sa SDL_RenderDrawRects\n \\sa SDL_RenderFillRect\n \\sa SDL_RenderFillRects\n \\sa SDL_RenderPresent\n \\sa SDL_SetRenderDrawBlendMode\n \\sa SDL_SetRenderDrawColor"]
     pub fn SDL_RenderDrawRect(renderer: *mut SDL_Renderer, rect: *const SDL_Rect) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Draw some number of rectangles on the current rendering target."]
-    #[doc = ""]
-    #[doc = " \\param renderer the rendering context"]
-    #[doc = " \\param rects an array of SDL_Rect structures representing the rectangles to"]
-    #[doc = "              be drawn"]
-    #[doc = " \\param count the number of rectangles"]
-    #[doc = " \\returns 0 on success or a negative error code on failure; call"]
-    #[doc = "          SDL_GetError() for more information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_RenderDrawLine"]
-    #[doc = " \\sa SDL_RenderDrawLines"]
-    #[doc = " \\sa SDL_RenderDrawPoint"]
-    #[doc = " \\sa SDL_RenderDrawPoints"]
-    #[doc = " \\sa SDL_RenderDrawRect"]
-    #[doc = " \\sa SDL_RenderFillRect"]
-    #[doc = " \\sa SDL_RenderFillRects"]
-    #[doc = " \\sa SDL_RenderPresent"]
-    #[doc = " \\sa SDL_SetRenderDrawBlendMode"]
-    #[doc = " \\sa SDL_SetRenderDrawColor"]
+    #[doc = " Draw some number of rectangles on the current rendering target.\n\n \\param renderer the rendering context\n \\param rects an array of SDL_Rect structures representing the rectangles to\n              be drawn\n \\param count the number of rectangles\n \\returns 0 on success or a negative error code on failure; call\n          SDL_GetError() for more information.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_RenderDrawLine\n \\sa SDL_RenderDrawLines\n \\sa SDL_RenderDrawPoint\n \\sa SDL_RenderDrawPoints\n \\sa SDL_RenderDrawRect\n \\sa SDL_RenderFillRect\n \\sa SDL_RenderFillRects\n \\sa SDL_RenderPresent\n \\sa SDL_SetRenderDrawBlendMode\n \\sa SDL_SetRenderDrawColor"]
     pub fn SDL_RenderDrawRects(
         renderer: *mut SDL_Renderer,
         rects: *const SDL_Rect,
@@ -24255,53 +15881,11 @@ extern "C" {
     ) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Fill a rectangle on the current rendering target with the drawing color."]
-    #[doc = ""]
-    #[doc = " The current drawing color is set by SDL_SetRenderDrawColor(), and the"]
-    #[doc = " color's alpha value is ignored unless blending is enabled with the"]
-    #[doc = " appropriate call to SDL_SetRenderDrawBlendMode()."]
-    #[doc = ""]
-    #[doc = " \\param renderer the rendering context"]
-    #[doc = " \\param rect the SDL_Rect structure representing the rectangle to fill, or"]
-    #[doc = "             NULL for the entire rendering target"]
-    #[doc = " \\returns 0 on success or a negative error code on failure; call"]
-    #[doc = "          SDL_GetError() for more information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_RenderDrawLine"]
-    #[doc = " \\sa SDL_RenderDrawLines"]
-    #[doc = " \\sa SDL_RenderDrawPoint"]
-    #[doc = " \\sa SDL_RenderDrawPoints"]
-    #[doc = " \\sa SDL_RenderDrawRect"]
-    #[doc = " \\sa SDL_RenderDrawRects"]
-    #[doc = " \\sa SDL_RenderFillRects"]
-    #[doc = " \\sa SDL_RenderPresent"]
-    #[doc = " \\sa SDL_SetRenderDrawBlendMode"]
-    #[doc = " \\sa SDL_SetRenderDrawColor"]
+    #[doc = " Fill a rectangle on the current rendering target with the drawing color.\n\n The current drawing color is set by SDL_SetRenderDrawColor(), and the\n color's alpha value is ignored unless blending is enabled with the\n appropriate call to SDL_SetRenderDrawBlendMode().\n\n \\param renderer the rendering context\n \\param rect the SDL_Rect structure representing the rectangle to fill, or\n             NULL for the entire rendering target\n \\returns 0 on success or a negative error code on failure; call\n          SDL_GetError() for more information.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_RenderDrawLine\n \\sa SDL_RenderDrawLines\n \\sa SDL_RenderDrawPoint\n \\sa SDL_RenderDrawPoints\n \\sa SDL_RenderDrawRect\n \\sa SDL_RenderDrawRects\n \\sa SDL_RenderFillRects\n \\sa SDL_RenderPresent\n \\sa SDL_SetRenderDrawBlendMode\n \\sa SDL_SetRenderDrawColor"]
     pub fn SDL_RenderFillRect(renderer: *mut SDL_Renderer, rect: *const SDL_Rect) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Fill some number of rectangles on the current rendering target with the"]
-    #[doc = " drawing color."]
-    #[doc = ""]
-    #[doc = " \\param renderer the rendering context"]
-    #[doc = " \\param rects an array of SDL_Rect structures representing the rectangles to"]
-    #[doc = "              be filled"]
-    #[doc = " \\param count the number of rectangles"]
-    #[doc = " \\returns 0 on success or a negative error code on failure; call"]
-    #[doc = "          SDL_GetError() for more information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_RenderDrawLine"]
-    #[doc = " \\sa SDL_RenderDrawLines"]
-    #[doc = " \\sa SDL_RenderDrawPoint"]
-    #[doc = " \\sa SDL_RenderDrawPoints"]
-    #[doc = " \\sa SDL_RenderDrawRect"]
-    #[doc = " \\sa SDL_RenderDrawRects"]
-    #[doc = " \\sa SDL_RenderFillRect"]
-    #[doc = " \\sa SDL_RenderPresent"]
+    #[doc = " Fill some number of rectangles on the current rendering target with the\n drawing color.\n\n \\param renderer the rendering context\n \\param rects an array of SDL_Rect structures representing the rectangles to\n              be filled\n \\param count the number of rectangles\n \\returns 0 on success or a negative error code on failure; call\n          SDL_GetError() for more information.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_RenderDrawLine\n \\sa SDL_RenderDrawLines\n \\sa SDL_RenderDrawPoint\n \\sa SDL_RenderDrawPoints\n \\sa SDL_RenderDrawRect\n \\sa SDL_RenderDrawRects\n \\sa SDL_RenderFillRect\n \\sa SDL_RenderPresent"]
     pub fn SDL_RenderFillRects(
         renderer: *mut SDL_Renderer,
         rects: *const SDL_Rect,
@@ -24309,32 +15893,7 @@ extern "C" {
     ) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Copy a portion of the texture to the current rendering target."]
-    #[doc = ""]
-    #[doc = " The texture is blended with the destination based on its blend mode set"]
-    #[doc = " with SDL_SetTextureBlendMode()."]
-    #[doc = ""]
-    #[doc = " The texture color is affected based on its color modulation set by"]
-    #[doc = " SDL_SetTextureColorMod()."]
-    #[doc = ""]
-    #[doc = " The texture alpha is affected based on its alpha modulation set by"]
-    #[doc = " SDL_SetTextureAlphaMod()."]
-    #[doc = ""]
-    #[doc = " \\param renderer the rendering context"]
-    #[doc = " \\param texture the source texture"]
-    #[doc = " \\param srcrect the source SDL_Rect structure or NULL for the entire texture"]
-    #[doc = " \\param dstrect the destination SDL_Rect structure or NULL for the entire"]
-    #[doc = "                rendering target; the texture will be stretched to fill the"]
-    #[doc = "                given rectangle"]
-    #[doc = " \\returns 0 on success or a negative error code on failure; call"]
-    #[doc = "          SDL_GetError() for more information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_RenderCopyEx"]
-    #[doc = " \\sa SDL_SetTextureAlphaMod"]
-    #[doc = " \\sa SDL_SetTextureBlendMode"]
-    #[doc = " \\sa SDL_SetTextureColorMod"]
+    #[doc = " Copy a portion of the texture to the current rendering target.\n\n The texture is blended with the destination based on its blend mode set\n with SDL_SetTextureBlendMode().\n\n The texture color is affected based on its color modulation set by\n SDL_SetTextureColorMod().\n\n The texture alpha is affected based on its alpha modulation set by\n SDL_SetTextureAlphaMod().\n\n \\param renderer the rendering context\n \\param texture the source texture\n \\param srcrect the source SDL_Rect structure or NULL for the entire texture\n \\param dstrect the destination SDL_Rect structure or NULL for the entire\n                rendering target; the texture will be stretched to fill the\n                given rectangle\n \\returns 0 on success or a negative error code on failure; call\n          SDL_GetError() for more information.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_RenderCopyEx\n \\sa SDL_SetTextureAlphaMod\n \\sa SDL_SetTextureBlendMode\n \\sa SDL_SetTextureColorMod"]
     pub fn SDL_RenderCopy(
         renderer: *mut SDL_Renderer,
         texture: *mut SDL_Texture,
@@ -24343,43 +15902,7 @@ extern "C" {
     ) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Copy a portion of the texture to the current rendering, with optional"]
-    #[doc = " rotation and flipping."]
-    #[doc = ""]
-    #[doc = " Copy a portion of the texture to the current rendering target, optionally"]
-    #[doc = " rotating it by angle around the given center and also flipping it"]
-    #[doc = " top-bottom and/or left-right."]
-    #[doc = ""]
-    #[doc = " The texture is blended with the destination based on its blend mode set"]
-    #[doc = " with SDL_SetTextureBlendMode()."]
-    #[doc = ""]
-    #[doc = " The texture color is affected based on its color modulation set by"]
-    #[doc = " SDL_SetTextureColorMod()."]
-    #[doc = ""]
-    #[doc = " The texture alpha is affected based on its alpha modulation set by"]
-    #[doc = " SDL_SetTextureAlphaMod()."]
-    #[doc = ""]
-    #[doc = " \\param renderer the rendering context"]
-    #[doc = " \\param texture the source texture"]
-    #[doc = " \\param srcrect the source SDL_Rect structure or NULL for the entire texture"]
-    #[doc = " \\param dstrect the destination SDL_Rect structure or NULL for the entire"]
-    #[doc = "                rendering target"]
-    #[doc = " \\param angle an angle in degrees that indicates the rotation that will be"]
-    #[doc = "              applied to dstrect, rotating it in a clockwise direction"]
-    #[doc = " \\param center a pointer to a point indicating the point around which"]
-    #[doc = "               dstrect will be rotated (if NULL, rotation will be done"]
-    #[doc = "               around `dstrect.w / 2`, `dstrect.h / 2`)"]
-    #[doc = " \\param flip a SDL_RendererFlip value stating which flipping actions should"]
-    #[doc = "             be performed on the texture"]
-    #[doc = " \\returns 0 on success or a negative error code on failure; call"]
-    #[doc = "          SDL_GetError() for more information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_RenderCopy"]
-    #[doc = " \\sa SDL_SetTextureAlphaMod"]
-    #[doc = " \\sa SDL_SetTextureBlendMode"]
-    #[doc = " \\sa SDL_SetTextureColorMod"]
+    #[doc = " Copy a portion of the texture to the current rendering, with optional\n rotation and flipping.\n\n Copy a portion of the texture to the current rendering target, optionally\n rotating it by angle around the given center and also flipping it\n top-bottom and/or left-right.\n\n The texture is blended with the destination based on its blend mode set\n with SDL_SetTextureBlendMode().\n\n The texture color is affected based on its color modulation set by\n SDL_SetTextureColorMod().\n\n The texture alpha is affected based on its alpha modulation set by\n SDL_SetTextureAlphaMod().\n\n \\param renderer the rendering context\n \\param texture the source texture\n \\param srcrect the source SDL_Rect structure or NULL for the entire texture\n \\param dstrect the destination SDL_Rect structure or NULL for the entire\n                rendering target\n \\param angle an angle in degrees that indicates the rotation that will be\n              applied to dstrect, rotating it in a clockwise direction\n \\param center a pointer to a point indicating the point around which\n               dstrect will be rotated (if NULL, rotation will be done\n               around `dstrect.w / 2`, `dstrect.h / 2`)\n \\param flip a SDL_RendererFlip value stating which flipping actions should\n             be performed on the texture\n \\returns 0 on success or a negative error code on failure; call\n          SDL_GetError() for more information.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_RenderCopy\n \\sa SDL_SetTextureAlphaMod\n \\sa SDL_SetTextureBlendMode\n \\sa SDL_SetTextureColorMod"]
     pub fn SDL_RenderCopyEx(
         renderer: *mut SDL_Renderer,
         texture: *mut SDL_Texture,
@@ -24391,25 +15914,11 @@ extern "C" {
     ) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Draw a point on the current rendering target at subpixel precision."]
-    #[doc = ""]
-    #[doc = " \\param renderer The renderer which should draw a point."]
-    #[doc = " \\param x The x coordinate of the point."]
-    #[doc = " \\param y The y coordinate of the point."]
-    #[doc = " \\return 0 on success, or -1 on error"]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.10."]
+    #[doc = " Draw a point on the current rendering target at subpixel precision.\n\n \\param renderer The renderer which should draw a point.\n \\param x The x coordinate of the point.\n \\param y The y coordinate of the point.\n \\return 0 on success, or -1 on error\n\n \\since This function is available since SDL 2.0.10."]
     pub fn SDL_RenderDrawPointF(renderer: *mut SDL_Renderer, x: f32, y: f32) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Draw multiple points on the current rendering target at subpixel precision."]
-    #[doc = ""]
-    #[doc = " \\param renderer The renderer which should draw multiple points."]
-    #[doc = " \\param points The points to draw"]
-    #[doc = " \\param count The number of points to draw"]
-    #[doc = " \\return 0 on success, or -1 on error"]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.10."]
+    #[doc = " Draw multiple points on the current rendering target at subpixel precision.\n\n \\param renderer The renderer which should draw multiple points.\n \\param points The points to draw\n \\param count The number of points to draw\n \\return 0 on success, or -1 on error\n\n \\since This function is available since SDL 2.0.10."]
     pub fn SDL_RenderDrawPointsF(
         renderer: *mut SDL_Renderer,
         points: *const SDL_FPoint,
@@ -24417,16 +15926,7 @@ extern "C" {
     ) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Draw a line on the current rendering target at subpixel precision."]
-    #[doc = ""]
-    #[doc = " \\param renderer The renderer which should draw a line."]
-    #[doc = " \\param x1 The x coordinate of the start point."]
-    #[doc = " \\param y1 The y coordinate of the start point."]
-    #[doc = " \\param x2 The x coordinate of the end point."]
-    #[doc = " \\param y2 The y coordinate of the end point."]
-    #[doc = " \\return 0 on success, or -1 on error"]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.10."]
+    #[doc = " Draw a line on the current rendering target at subpixel precision.\n\n \\param renderer The renderer which should draw a line.\n \\param x1 The x coordinate of the start point.\n \\param y1 The y coordinate of the start point.\n \\param x2 The x coordinate of the end point.\n \\param y2 The y coordinate of the end point.\n \\return 0 on success, or -1 on error\n\n \\since This function is available since SDL 2.0.10."]
     pub fn SDL_RenderDrawLineF(
         renderer: *mut SDL_Renderer,
         x1: f32,
@@ -24436,15 +15936,7 @@ extern "C" {
     ) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Draw a series of connected lines on the current rendering target at"]
-    #[doc = " subpixel precision."]
-    #[doc = ""]
-    #[doc = " \\param renderer The renderer which should draw multiple lines."]
-    #[doc = " \\param points The points along the lines"]
-    #[doc = " \\param count The number of points, drawing count-1 lines"]
-    #[doc = " \\return 0 on success, or -1 on error"]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.10."]
+    #[doc = " Draw a series of connected lines on the current rendering target at\n subpixel precision.\n\n \\param renderer The renderer which should draw multiple lines.\n \\param points The points along the lines\n \\param count The number of points, drawing count-1 lines\n \\return 0 on success, or -1 on error\n\n \\since This function is available since SDL 2.0.10."]
     pub fn SDL_RenderDrawLinesF(
         renderer: *mut SDL_Renderer,
         points: *const SDL_FPoint,
@@ -24452,26 +15944,11 @@ extern "C" {
     ) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Draw a rectangle on the current rendering target at subpixel precision."]
-    #[doc = ""]
-    #[doc = " \\param renderer The renderer which should draw a rectangle."]
-    #[doc = " \\param rect A pointer to the destination rectangle, or NULL to outline the"]
-    #[doc = "             entire rendering target."]
-    #[doc = " \\return 0 on success, or -1 on error"]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.10."]
+    #[doc = " Draw a rectangle on the current rendering target at subpixel precision.\n\n \\param renderer The renderer which should draw a rectangle.\n \\param rect A pointer to the destination rectangle, or NULL to outline the\n             entire rendering target.\n \\return 0 on success, or -1 on error\n\n \\since This function is available since SDL 2.0.10."]
     pub fn SDL_RenderDrawRectF(renderer: *mut SDL_Renderer, rect: *const SDL_FRect) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Draw some number of rectangles on the current rendering target at subpixel"]
-    #[doc = " precision."]
-    #[doc = ""]
-    #[doc = " \\param renderer The renderer which should draw multiple rectangles."]
-    #[doc = " \\param rects A pointer to an array of destination rectangles."]
-    #[doc = " \\param count The number of rectangles."]
-    #[doc = " \\return 0 on success, or -1 on error"]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.10."]
+    #[doc = " Draw some number of rectangles on the current rendering target at subpixel\n precision.\n\n \\param renderer The renderer which should draw multiple rectangles.\n \\param rects A pointer to an array of destination rectangles.\n \\param count The number of rectangles.\n \\return 0 on success, or -1 on error\n\n \\since This function is available since SDL 2.0.10."]
     pub fn SDL_RenderDrawRectsF(
         renderer: *mut SDL_Renderer,
         rects: *const SDL_FRect,
@@ -24479,27 +15956,11 @@ extern "C" {
     ) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Fill a rectangle on the current rendering target with the drawing color at"]
-    #[doc = " subpixel precision."]
-    #[doc = ""]
-    #[doc = " \\param renderer The renderer which should fill a rectangle."]
-    #[doc = " \\param rect A pointer to the destination rectangle, or NULL for the entire"]
-    #[doc = "             rendering target."]
-    #[doc = " \\return 0 on success, or -1 on error"]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.10."]
+    #[doc = " Fill a rectangle on the current rendering target with the drawing color at\n subpixel precision.\n\n \\param renderer The renderer which should fill a rectangle.\n \\param rect A pointer to the destination rectangle, or NULL for the entire\n             rendering target.\n \\return 0 on success, or -1 on error\n\n \\since This function is available since SDL 2.0.10."]
     pub fn SDL_RenderFillRectF(renderer: *mut SDL_Renderer, rect: *const SDL_FRect) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Fill some number of rectangles on the current rendering target with the"]
-    #[doc = " drawing color at subpixel precision."]
-    #[doc = ""]
-    #[doc = " \\param renderer The renderer which should fill multiple rectangles."]
-    #[doc = " \\param rects A pointer to an array of destination rectangles."]
-    #[doc = " \\param count The number of rectangles."]
-    #[doc = " \\return 0 on success, or -1 on error"]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.10."]
+    #[doc = " Fill some number of rectangles on the current rendering target with the\n drawing color at subpixel precision.\n\n \\param renderer The renderer which should fill multiple rectangles.\n \\param rects A pointer to an array of destination rectangles.\n \\param count The number of rectangles.\n \\return 0 on success, or -1 on error\n\n \\since This function is available since SDL 2.0.10."]
     pub fn SDL_RenderFillRectsF(
         renderer: *mut SDL_Renderer,
         rects: *const SDL_FRect,
@@ -24507,18 +15968,7 @@ extern "C" {
     ) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Copy a portion of the texture to the current rendering target at subpixel"]
-    #[doc = " precision."]
-    #[doc = ""]
-    #[doc = " \\param renderer The renderer which should copy parts of a texture."]
-    #[doc = " \\param texture The source texture."]
-    #[doc = " \\param srcrect A pointer to the source rectangle, or NULL for the entire"]
-    #[doc = "                texture."]
-    #[doc = " \\param dstrect A pointer to the destination rectangle, or NULL for the"]
-    #[doc = "                entire rendering target."]
-    #[doc = " \\return 0 on success, or -1 on error"]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.10."]
+    #[doc = " Copy a portion of the texture to the current rendering target at subpixel\n precision.\n\n \\param renderer The renderer which should copy parts of a texture.\n \\param texture The source texture.\n \\param srcrect A pointer to the source rectangle, or NULL for the entire\n                texture.\n \\param dstrect A pointer to the destination rectangle, or NULL for the\n                entire rendering target.\n \\return 0 on success, or -1 on error\n\n \\since This function is available since SDL 2.0.10."]
     pub fn SDL_RenderCopyF(
         renderer: *mut SDL_Renderer,
         texture: *mut SDL_Texture,
@@ -24527,25 +15977,7 @@ extern "C" {
     ) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Copy a portion of the source texture to the current rendering target, with"]
-    #[doc = " rotation and flipping, at subpixel precision."]
-    #[doc = ""]
-    #[doc = " \\param renderer The renderer which should copy parts of a texture."]
-    #[doc = " \\param texture The source texture."]
-    #[doc = " \\param srcrect A pointer to the source rectangle, or NULL for the entire"]
-    #[doc = "                texture."]
-    #[doc = " \\param dstrect A pointer to the destination rectangle, or NULL for the"]
-    #[doc = "                entire rendering target."]
-    #[doc = " \\param angle An angle in degrees that indicates the rotation that will be"]
-    #[doc = "              applied to dstrect, rotating it in a clockwise direction"]
-    #[doc = " \\param center A pointer to a point indicating the point around which"]
-    #[doc = "               dstrect will be rotated (if NULL, rotation will be done"]
-    #[doc = "               around dstrect.w/2, dstrect.h/2)."]
-    #[doc = " \\param flip An SDL_RendererFlip value stating which flipping actions should"]
-    #[doc = "             be performed on the texture"]
-    #[doc = " \\return 0 on success, or -1 on error"]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.10."]
+    #[doc = " Copy a portion of the source texture to the current rendering target, with\n rotation and flipping, at subpixel precision.\n\n \\param renderer The renderer which should copy parts of a texture.\n \\param texture The source texture.\n \\param srcrect A pointer to the source rectangle, or NULL for the entire\n                texture.\n \\param dstrect A pointer to the destination rectangle, or NULL for the\n                entire rendering target.\n \\param angle An angle in degrees that indicates the rotation that will be\n              applied to dstrect, rotating it in a clockwise direction\n \\param center A pointer to a point indicating the point around which\n               dstrect will be rotated (if NULL, rotation will be done\n               around dstrect.w/2, dstrect.h/2).\n \\param flip An SDL_RendererFlip value stating which flipping actions should\n             be performed on the texture\n \\return 0 on success, or -1 on error\n\n \\since This function is available since SDL 2.0.10."]
     pub fn SDL_RenderCopyExF(
         renderer: *mut SDL_Renderer,
         texture: *mut SDL_Texture,
@@ -24557,23 +15989,7 @@ extern "C" {
     ) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Render a list of triangles, optionally using a texture and indices into the"]
-    #[doc = " vertex array Color and alpha modulation is done per vertex"]
-    #[doc = " (SDL_SetTextureColorMod and SDL_SetTextureAlphaMod are ignored)."]
-    #[doc = ""]
-    #[doc = " \\param texture (optional) The SDL texture to use."]
-    #[doc = " \\param vertices Vertices."]
-    #[doc = " \\param num_vertices Number of vertices."]
-    #[doc = " \\param indices (optional) An array of integer indices into the 'vertices'"]
-    #[doc = "                array, if NULL all vertices will be rendered in sequential"]
-    #[doc = "                order."]
-    #[doc = " \\param num_indices Number of indices."]
-    #[doc = " \\return 0 on success, or -1 if the operation is not supported"]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.18."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_RenderGeometryRaw"]
-    #[doc = " \\sa SDL_Vertex"]
+    #[doc = " Render a list of triangles, optionally using a texture and indices into the\n vertex array Color and alpha modulation is done per vertex\n (SDL_SetTextureColorMod and SDL_SetTextureAlphaMod are ignored).\n\n \\param renderer The rendering context.\n \\param texture (optional) The SDL texture to use.\n \\param vertices Vertices.\n \\param num_vertices Number of vertices.\n \\param indices (optional) An array of integer indices into the 'vertices'\n                array, if NULL all vertices will be rendered in sequential\n                order.\n \\param num_indices Number of indices.\n \\return 0 on success, or -1 if the operation is not supported\n\n \\since This function is available since SDL 2.0.18.\n\n \\sa SDL_RenderGeometryRaw\n \\sa SDL_Vertex"]
     pub fn SDL_RenderGeometry(
         renderer: *mut SDL_Renderer,
         texture: *mut SDL_Texture,
@@ -24584,28 +16000,7 @@ extern "C" {
     ) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Render a list of triangles, optionally using a texture and indices into the"]
-    #[doc = " vertex arrays Color and alpha modulation is done per vertex"]
-    #[doc = " (SDL_SetTextureColorMod and SDL_SetTextureAlphaMod are ignored)."]
-    #[doc = ""]
-    #[doc = " \\param texture (optional) The SDL texture to use."]
-    #[doc = " \\param xy Vertex positions"]
-    #[doc = " \\param xy_stride Byte size to move from one element to the next element"]
-    #[doc = " \\param color Vertex colors (as SDL_Color)"]
-    #[doc = " \\param color_stride Byte size to move from one element to the next element"]
-    #[doc = " \\param uv Vertex normalized texture coordinates"]
-    #[doc = " \\param uv_stride Byte size to move from one element to the next element"]
-    #[doc = " \\param num_vertices Number of vertices."]
-    #[doc = " \\param indices (optional) An array of indices into the 'vertices' arrays,"]
-    #[doc = "                if NULL all vertices will be rendered in sequential order."]
-    #[doc = " \\param num_indices Number of indices."]
-    #[doc = " \\param size_indices Index size: 1 (byte), 2 (short), 4 (int)"]
-    #[doc = " \\return 0 on success, or -1 if the operation is not supported"]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.18."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_RenderGeometry"]
-    #[doc = " \\sa SDL_Vertex"]
+    #[doc = " Render a list of triangles, optionally using a texture and indices into the\n vertex arrays Color and alpha modulation is done per vertex\n (SDL_SetTextureColorMod and SDL_SetTextureAlphaMod are ignored).\n\n \\param renderer The rendering context.\n \\param texture (optional) The SDL texture to use.\n \\param xy Vertex positions\n \\param xy_stride Byte size to move from one element to the next element\n \\param color Vertex colors (as SDL_Color)\n \\param color_stride Byte size to move from one element to the next element\n \\param uv Vertex normalized texture coordinates\n \\param uv_stride Byte size to move from one element to the next element\n \\param num_vertices Number of vertices.\n \\param indices (optional) An array of indices into the 'vertices' arrays,\n                if NULL all vertices will be rendered in sequential order.\n \\param num_indices Number of indices.\n \\param size_indices Index size: 1 (byte), 2 (short), 4 (int)\n \\return 0 on success, or -1 if the operation is not supported\n\n \\since This function is available since SDL 2.0.18.\n\n \\sa SDL_RenderGeometry\n \\sa SDL_Vertex"]
     pub fn SDL_RenderGeometryRaw(
         renderer: *mut SDL_Renderer,
         texture: *mut SDL_Texture,
@@ -24622,29 +16017,7 @@ extern "C" {
     ) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Read pixels from the current rendering target to an array of pixels."]
-    #[doc = ""]
-    #[doc = " **WARNING**: This is a very slow operation, and should not be used"]
-    #[doc = " frequently."]
-    #[doc = ""]
-    #[doc = " `pitch` specifies the number of bytes between rows in the destination"]
-    #[doc = " `pixels` data. This allows you to write to a subrectangle or have padded"]
-    #[doc = " rows in the destination. Generally, `pitch` should equal the number of"]
-    #[doc = " pixels per row in the `pixels` data times the number of bytes per pixel,"]
-    #[doc = " but it might contain additional padding (for example, 24bit RGB Windows"]
-    #[doc = " Bitmap data pads all rows to multiples of 4 bytes)."]
-    #[doc = ""]
-    #[doc = " \\param renderer the rendering context"]
-    #[doc = " \\param rect an SDL_Rect structure representing the area to read, or NULL"]
-    #[doc = "             for the entire render target"]
-    #[doc = " \\param format an SDL_PixelFormatEnum value of the desired format of the"]
-    #[doc = "               pixel data, or 0 to use the format of the rendering target"]
-    #[doc = " \\param pixels a pointer to the pixel data to copy into"]
-    #[doc = " \\param pitch the pitch of the `pixels` parameter"]
-    #[doc = " \\returns 0 on success or a negative error code on failure; call"]
-    #[doc = "          SDL_GetError() for more information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
+    #[doc = " Read pixels from the current rendering target to an array of pixels.\n\n **WARNING**: This is a very slow operation, and should not be used\n frequently. If you're using this on the main rendering target, it should be\n called after rendering and before SDL_RenderPresent().\n\n `pitch` specifies the number of bytes between rows in the destination\n `pixels` data. This allows you to write to a subrectangle or have padded\n rows in the destination. Generally, `pitch` should equal the number of\n pixels per row in the `pixels` data times the number of bytes per pixel,\n but it might contain additional padding (for example, 24bit RGB Windows\n Bitmap data pads all rows to multiples of 4 bytes).\n\n \\param renderer the rendering context\n \\param rect an SDL_Rect structure representing the area to read, or NULL\n             for the entire render target\n \\param format an SDL_PixelFormatEnum value of the desired format of the\n               pixel data, or 0 to use the format of the rendering target\n \\param pixels a pointer to the pixel data to copy into\n \\param pitch the pitch of the `pixels` parameter\n \\returns 0 on success or a negative error code on failure; call\n          SDL_GetError() for more information.\n\n \\since This function is available since SDL 2.0.0."]
     pub fn SDL_RenderReadPixels(
         renderer: *mut SDL_Renderer,
         rect: *const SDL_Rect,
@@ -24654,129 +16027,23 @@ extern "C" {
     ) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Update the screen with any rendering performed since the previous call."]
-    #[doc = ""]
-    #[doc = " SDL's rendering functions operate on a backbuffer; that is, calling a"]
-    #[doc = " rendering function such as SDL_RenderDrawLine() does not directly put a"]
-    #[doc = " line on the screen, but rather updates the backbuffer. As such, you compose"]
-    #[doc = " your entire scene and *present* the composed backbuffer to the screen as a"]
-    #[doc = " complete picture."]
-    #[doc = ""]
-    #[doc = " Therefore, when using SDL's rendering API, one does all drawing intended"]
-    #[doc = " for the frame, and then calls this function once per frame to present the"]
-    #[doc = " final drawing to the user."]
-    #[doc = ""]
-    #[doc = " The backbuffer should be considered invalidated after each present; do not"]
-    #[doc = " assume that previous contents will exist between frames. You are strongly"]
-    #[doc = " encouraged to call SDL_RenderClear() to initialize the backbuffer before"]
-    #[doc = " starting each new frame's drawing, even if you plan to overwrite every"]
-    #[doc = " pixel."]
-    #[doc = ""]
-    #[doc = " \\param renderer the rendering context"]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_RenderClear"]
-    #[doc = " \\sa SDL_RenderDrawLine"]
-    #[doc = " \\sa SDL_RenderDrawLines"]
-    #[doc = " \\sa SDL_RenderDrawPoint"]
-    #[doc = " \\sa SDL_RenderDrawPoints"]
-    #[doc = " \\sa SDL_RenderDrawRect"]
-    #[doc = " \\sa SDL_RenderDrawRects"]
-    #[doc = " \\sa SDL_RenderFillRect"]
-    #[doc = " \\sa SDL_RenderFillRects"]
-    #[doc = " \\sa SDL_SetRenderDrawBlendMode"]
-    #[doc = " \\sa SDL_SetRenderDrawColor"]
+    #[doc = " Update the screen with any rendering performed since the previous call.\n\n SDL's rendering functions operate on a backbuffer; that is, calling a\n rendering function such as SDL_RenderDrawLine() does not directly put a\n line on the screen, but rather updates the backbuffer. As such, you compose\n your entire scene and *present* the composed backbuffer to the screen as a\n complete picture.\n\n Therefore, when using SDL's rendering API, one does all drawing intended\n for the frame, and then calls this function once per frame to present the\n final drawing to the user.\n\n The backbuffer should be considered invalidated after each present; do not\n assume that previous contents will exist between frames. You are strongly\n encouraged to call SDL_RenderClear() to initialize the backbuffer before\n starting each new frame's drawing, even if you plan to overwrite every\n pixel.\n\n \\param renderer the rendering context\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_RenderClear\n \\sa SDL_RenderDrawLine\n \\sa SDL_RenderDrawLines\n \\sa SDL_RenderDrawPoint\n \\sa SDL_RenderDrawPoints\n \\sa SDL_RenderDrawRect\n \\sa SDL_RenderDrawRects\n \\sa SDL_RenderFillRect\n \\sa SDL_RenderFillRects\n \\sa SDL_SetRenderDrawBlendMode\n \\sa SDL_SetRenderDrawColor"]
     pub fn SDL_RenderPresent(renderer: *mut SDL_Renderer);
 }
 extern "C" {
-    #[doc = " Destroy the specified texture."]
-    #[doc = ""]
-    #[doc = " Passing NULL or an otherwise invalid texture will set the SDL error message"]
-    #[doc = " to \"Invalid texture\"."]
-    #[doc = ""]
-    #[doc = " \\param texture the texture to destroy"]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_CreateTexture"]
-    #[doc = " \\sa SDL_CreateTextureFromSurface"]
+    #[doc = " Destroy the specified texture.\n\n Passing NULL or an otherwise invalid texture will set the SDL error message\n to \"Invalid texture\".\n\n \\param texture the texture to destroy\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_CreateTexture\n \\sa SDL_CreateTextureFromSurface"]
     pub fn SDL_DestroyTexture(texture: *mut SDL_Texture);
 }
 extern "C" {
-    #[doc = " Destroy the rendering context for a window and free associated textures."]
-    #[doc = ""]
-    #[doc = " \\param renderer the rendering context"]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_CreateRenderer"]
+    #[doc = " Destroy the rendering context for a window and free associated textures.\n\n If `renderer` is NULL, this function will return immediately after setting\n the SDL error message to \"Invalid renderer\". See SDL_GetError().\n\n \\param renderer the rendering context\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_CreateRenderer"]
     pub fn SDL_DestroyRenderer(renderer: *mut SDL_Renderer);
 }
 extern "C" {
-    #[doc = " Force the rendering context to flush any pending commands to the underlying"]
-    #[doc = " rendering API."]
-    #[doc = ""]
-    #[doc = " You do not need to (and in fact, shouldn't) call this function unless you"]
-    #[doc = " are planning to call into OpenGL/Direct3D/Metal/whatever directly in"]
-    #[doc = " addition to using an SDL_Renderer."]
-    #[doc = ""]
-    #[doc = " This is for a very-specific case: if you are using SDL's render API, you"]
-    #[doc = " asked for a specific renderer backend (OpenGL, Direct3D, etc), you set"]
-    #[doc = " SDL_HINT_RENDER_BATCHING to \"1\", and you plan to make OpenGL/D3D/whatever"]
-    #[doc = " calls in addition to SDL render API calls. If all of this applies, you"]
-    #[doc = " should call SDL_RenderFlush() between calls to SDL's render API and the"]
-    #[doc = " low-level API you're using in cooperation."]
-    #[doc = ""]
-    #[doc = " In all other cases, you can ignore this function. This is only here to get"]
-    #[doc = " maximum performance out of a specific situation. In all other cases, SDL"]
-    #[doc = " will do the right thing, perhaps at a performance loss."]
-    #[doc = ""]
-    #[doc = " This function is first available in SDL 2.0.10, and is not needed in 2.0.9"]
-    #[doc = " and earlier, as earlier versions did not queue rendering commands at all,"]
-    #[doc = " instead flushing them to the OS immediately."]
-    #[doc = ""]
-    #[doc = " \\param renderer the rendering context"]
-    #[doc = " \\returns 0 on success or a negative error code on failure; call"]
-    #[doc = "          SDL_GetError() for more information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.10."]
+    #[doc = " Force the rendering context to flush any pending commands to the underlying\n rendering API.\n\n You do not need to (and in fact, shouldn't) call this function unless you\n are planning to call into OpenGL/Direct3D/Metal/whatever directly in\n addition to using an SDL_Renderer.\n\n This is for a very-specific case: if you are using SDL's render API, you\n asked for a specific renderer backend (OpenGL, Direct3D, etc), you set\n SDL_HINT_RENDER_BATCHING to \"1\", and you plan to make OpenGL/D3D/whatever\n calls in addition to SDL render API calls. If all of this applies, you\n should call SDL_RenderFlush() between calls to SDL's render API and the\n low-level API you're using in cooperation.\n\n In all other cases, you can ignore this function. This is only here to get\n maximum performance out of a specific situation. In all other cases, SDL\n will do the right thing, perhaps at a performance loss.\n\n This function is first available in SDL 2.0.10, and is not needed in 2.0.9\n and earlier, as earlier versions did not queue rendering commands at all,\n instead flushing them to the OS immediately.\n\n \\param renderer the rendering context\n \\returns 0 on success or a negative error code on failure; call\n          SDL_GetError() for more information.\n\n \\since This function is available since SDL 2.0.10."]
     pub fn SDL_RenderFlush(renderer: *mut SDL_Renderer) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Bind an OpenGL/ES/ES2 texture to the current context."]
-    #[doc = ""]
-    #[doc = " This is for use with OpenGL instructions when rendering OpenGL primitives"]
-    #[doc = " directly."]
-    #[doc = ""]
-    #[doc = " If not NULL, `texw` and `texh` will be filled with the width and height"]
-    #[doc = " values suitable for the provided texture. In most cases, both will be 1.0,"]
-    #[doc = " however, on systems that support the GL_ARB_texture_rectangle extension,"]
-    #[doc = " these values will actually be the pixel width and height used to create the"]
-    #[doc = " texture, so this factor needs to be taken into account when providing"]
-    #[doc = " texture coordinates to OpenGL."]
-    #[doc = ""]
-    #[doc = " You need a renderer to create an SDL_Texture, therefore you can only use"]
-    #[doc = " this function with an implicit OpenGL context from SDL_CreateRenderer(),"]
-    #[doc = " not with your own OpenGL context. If you need control over your OpenGL"]
-    #[doc = " context, you need to write your own texture-loading methods."]
-    #[doc = ""]
-    #[doc = " Also note that SDL may upload RGB textures as BGR (or vice-versa), and"]
-    #[doc = " re-order the color channels in the shaders phase, so the uploaded texture"]
-    #[doc = " may have swapped color channels."]
-    #[doc = ""]
-    #[doc = " \\param texture the texture to bind to the current OpenGL/ES/ES2 context"]
-    #[doc = " \\param texw a pointer to a float value which will be filled with the"]
-    #[doc = "             texture width or NULL if you don't need that value"]
-    #[doc = " \\param texh a pointer to a float value which will be filled with the"]
-    #[doc = "             texture height or NULL if you don't need that value"]
-    #[doc = " \\returns 0 on success, or -1 if the operation is not supported; call"]
-    #[doc = "          SDL_GetError() for more information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_GL_MakeCurrent"]
-    #[doc = " \\sa SDL_GL_UnbindTexture"]
+    #[doc = " Bind an OpenGL/ES/ES2 texture to the current context.\n\n This is for use with OpenGL instructions when rendering OpenGL primitives\n directly.\n\n If not NULL, `texw` and `texh` will be filled with the width and height\n values suitable for the provided texture. In most cases, both will be 1.0,\n however, on systems that support the GL_ARB_texture_rectangle extension,\n these values will actually be the pixel width and height used to create the\n texture, so this factor needs to be taken into account when providing\n texture coordinates to OpenGL.\n\n You need a renderer to create an SDL_Texture, therefore you can only use\n this function with an implicit OpenGL context from SDL_CreateRenderer(),\n not with your own OpenGL context. If you need control over your OpenGL\n context, you need to write your own texture-loading methods.\n\n Also note that SDL may upload RGB textures as BGR (or vice-versa), and\n re-order the color channels in the shaders phase, so the uploaded texture\n may have swapped color channels.\n\n \\param texture the texture to bind to the current OpenGL/ES/ES2 context\n \\param texw a pointer to a float value which will be filled with the\n             texture width or NULL if you don't need that value\n \\param texh a pointer to a float value which will be filled with the\n             texture height or NULL if you don't need that value\n \\returns 0 on success, or -1 if the operation is not supported; call\n          SDL_GetError() for more information.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_GL_MakeCurrent\n \\sa SDL_GL_UnbindTexture"]
     pub fn SDL_GL_BindTexture(
         texture: *mut SDL_Texture,
         texw: *mut f32,
@@ -24784,86 +16051,23 @@ extern "C" {
     ) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Unbind an OpenGL/ES/ES2 texture from the current context."]
-    #[doc = ""]
-    #[doc = " See SDL_GL_BindTexture() for examples on how to use these functions"]
-    #[doc = ""]
-    #[doc = " \\param texture the texture to unbind from the current OpenGL/ES/ES2 context"]
-    #[doc = " \\returns 0 on success, or -1 if the operation is not supported"]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_GL_BindTexture"]
-    #[doc = " \\sa SDL_GL_MakeCurrent"]
+    #[doc = " Unbind an OpenGL/ES/ES2 texture from the current context.\n\n See SDL_GL_BindTexture() for examples on how to use these functions\n\n \\param texture the texture to unbind from the current OpenGL/ES/ES2 context\n \\returns 0 on success, or -1 if the operation is not supported\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_GL_BindTexture\n \\sa SDL_GL_MakeCurrent"]
     pub fn SDL_GL_UnbindTexture(texture: *mut SDL_Texture) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Get the CAMetalLayer associated with the given Metal renderer."]
-    #[doc = ""]
-    #[doc = " This function returns `void *`, so SDL doesn't have to include Metal's"]
-    #[doc = " headers, but it can be safely cast to a `CAMetalLayer *`."]
-    #[doc = ""]
-    #[doc = " \\param renderer The renderer to query"]
-    #[doc = " \\returns a `CAMetalLayer *` on success, or NULL if the renderer isn't a"]
-    #[doc = "          Metal renderer"]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.8."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_RenderGetMetalCommandEncoder"]
+    #[doc = " Get the CAMetalLayer associated with the given Metal renderer.\n\n This function returns `void *`, so SDL doesn't have to include Metal's\n headers, but it can be safely cast to a `CAMetalLayer *`.\n\n \\param renderer The renderer to query\n \\returns a `CAMetalLayer *` on success, or NULL if the renderer isn't a\n          Metal renderer\n\n \\since This function is available since SDL 2.0.8.\n\n \\sa SDL_RenderGetMetalCommandEncoder"]
     pub fn SDL_RenderGetMetalLayer(renderer: *mut SDL_Renderer) -> *mut libc::c_void;
 }
 extern "C" {
-    #[doc = " Get the Metal command encoder for the current frame"]
-    #[doc = ""]
-    #[doc = " This function returns `void *`, so SDL doesn't have to include Metal's"]
-    #[doc = " headers, but it can be safely cast to an `id<MTLRenderCommandEncoder>`."]
-    #[doc = ""]
-    #[doc = " Note that as of SDL 2.0.18, this will return NULL if Metal refuses to give"]
-    #[doc = " SDL a drawable to render to, which might happen if the window is"]
-    #[doc = " hidden/minimized/offscreen. This doesn't apply to command encoders for"]
-    #[doc = " render targets, just the window's backbacker. Check your return values!"]
-    #[doc = ""]
-    #[doc = " \\param renderer The renderer to query"]
-    #[doc = " \\returns an `id<MTLRenderCommandEncoder>` on success, or NULL if the"]
-    #[doc = "          renderer isn't a Metal renderer or there was an error."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.8."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_RenderGetMetalLayer"]
+    #[doc = " Get the Metal command encoder for the current frame\n\n This function returns `void *`, so SDL doesn't have to include Metal's\n headers, but it can be safely cast to an `id<MTLRenderCommandEncoder>`.\n\n Note that as of SDL 2.0.18, this will return NULL if Metal refuses to give\n SDL a drawable to render to, which might happen if the window is\n hidden/minimized/offscreen. This doesn't apply to command encoders for\n render targets, just the window's backbacker. Check your return values!\n\n \\param renderer The renderer to query\n \\returns an `id<MTLRenderCommandEncoder>` on success, or NULL if the\n          renderer isn't a Metal renderer or there was an error.\n\n \\since This function is available since SDL 2.0.8.\n\n \\sa SDL_RenderGetMetalLayer"]
     pub fn SDL_RenderGetMetalCommandEncoder(renderer: *mut SDL_Renderer) -> *mut libc::c_void;
 }
 extern "C" {
-    #[doc = " Toggle VSync of the given renderer."]
-    #[doc = ""]
-    #[doc = " \\param renderer The renderer to toggle"]
-    #[doc = " \\param vsync 1 for on, 0 for off. All other values are reserved"]
-    #[doc = " \\returns a 0 int on success, or non-zero on failure"]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.18."]
+    #[doc = " Toggle VSync of the given renderer.\n\n \\param renderer The renderer to toggle\n \\param vsync 1 for on, 0 for off. All other values are reserved\n \\returns a 0 int on success, or non-zero on failure\n\n \\since This function is available since SDL 2.0.18."]
     pub fn SDL_RenderSetVSync(renderer: *mut SDL_Renderer, vsync: libc::c_int) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Create a window that can be shaped with the specified position, dimensions,"]
-    #[doc = " and flags."]
-    #[doc = ""]
-    #[doc = " \\param title The title of the window, in UTF-8 encoding."]
-    #[doc = " \\param x The x position of the window, ::SDL_WINDOWPOS_CENTERED, or"]
-    #[doc = "          ::SDL_WINDOWPOS_UNDEFINED."]
-    #[doc = " \\param y The y position of the window, ::SDL_WINDOWPOS_CENTERED, or"]
-    #[doc = "          ::SDL_WINDOWPOS_UNDEFINED."]
-    #[doc = " \\param w The width of the window."]
-    #[doc = " \\param h The height of the window."]
-    #[doc = " \\param flags The flags for the window, a mask of SDL_WINDOW_BORDERLESS with"]
-    #[doc = "              any of the following: ::SDL_WINDOW_OPENGL,"]
-    #[doc = "              ::SDL_WINDOW_INPUT_GRABBED, ::SDL_WINDOW_HIDDEN,"]
-    #[doc = "              ::SDL_WINDOW_RESIZABLE, ::SDL_WINDOW_MAXIMIZED,"]
-    #[doc = "              ::SDL_WINDOW_MINIMIZED, ::SDL_WINDOW_BORDERLESS is always set,"]
-    #[doc = "              and ::SDL_WINDOW_FULLSCREEN is always unset."]
-    #[doc = " \\return the window created, or NULL if window creation failed."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_DestroyWindow"]
+    #[doc = " Create a window that can be shaped with the specified position, dimensions,\n and flags.\n\n \\param title The title of the window, in UTF-8 encoding.\n \\param x The x position of the window, ::SDL_WINDOWPOS_CENTERED, or\n          ::SDL_WINDOWPOS_UNDEFINED.\n \\param y The y position of the window, ::SDL_WINDOWPOS_CENTERED, or\n          ::SDL_WINDOWPOS_UNDEFINED.\n \\param w The width of the window.\n \\param h The height of the window.\n \\param flags The flags for the window, a mask of SDL_WINDOW_BORDERLESS with\n              any of the following: ::SDL_WINDOW_OPENGL,\n              ::SDL_WINDOW_INPUT_GRABBED, ::SDL_WINDOW_HIDDEN,\n              ::SDL_WINDOW_RESIZABLE, ::SDL_WINDOW_MAXIMIZED,\n              ::SDL_WINDOW_MINIMIZED, ::SDL_WINDOW_BORDERLESS is always set,\n              and ::SDL_WINDOW_FULLSCREEN is always unset.\n \\return the window created, or NULL if window creation failed.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_DestroyWindow"]
     pub fn SDL_CreateShapedWindow(
         title: *const libc::c_char,
         x: libc::c_uint,
@@ -24874,20 +16078,12 @@ extern "C" {
     ) -> *mut SDL_Window;
 }
 extern "C" {
-    #[doc = " Return whether the given window is a shaped window."]
-    #[doc = ""]
-    #[doc = " \\param window The window to query for being shaped."]
-    #[doc = " \\return SDL_TRUE if the window is a window that can be shaped, SDL_FALSE if"]
-    #[doc = "         the window is unshaped or NULL."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_CreateShapedWindow"]
+    #[doc = " Return whether the given window is a shaped window.\n\n \\param window The window to query for being shaped.\n \\return SDL_TRUE if the window is a window that can be shaped, SDL_FALSE if\n         the window is unshaped or NULL.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_CreateShapedWindow"]
     pub fn SDL_IsShapedWindow(window: *const SDL_Window) -> SDL_bool;
 }
 #[repr(u32)]
 #[doc = " \\brief An enum denoting the specific type of contents present in an SDL_WindowShapeParams union."]
-#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
+#[derive(Copy, Clone, Hash, PartialEq, Eq)]
 pub enum WindowShapeMode {
     #[doc = " \\brief The default mode, a binarized alpha cutoff of 1."]
     ShapeModeDefault = 0,
@@ -24905,10 +16101,12 @@ pub union SDL_WindowShapeParams {
     #[doc = " \\brief A cutoff alpha value for binarization of the window shape's alpha channel."]
     pub binarizationCutoff: Uint8,
     pub colorKey: SDL_Color,
-    _bindgen_union_align: [u8; 4usize],
 }
 #[test]
 fn bindgen_test_layout_SDL_WindowShapeParams() {
+    const UNINIT: ::core::mem::MaybeUninit<SDL_WindowShapeParams> =
+        ::core::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::core::mem::size_of::<SDL_WindowShapeParams>(),
         4usize,
@@ -24920,10 +16118,7 @@ fn bindgen_test_layout_SDL_WindowShapeParams() {
         concat!("Alignment of ", stringify!(SDL_WindowShapeParams))
     );
     assert_eq!(
-        unsafe {
-            &(*(::core::ptr::null::<SDL_WindowShapeParams>())).binarizationCutoff as *const _
-                as usize
-        },
+        unsafe { ::core::ptr::addr_of!((*ptr).binarizationCutoff) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -24933,7 +16128,7 @@ fn bindgen_test_layout_SDL_WindowShapeParams() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_WindowShapeParams>())).colorKey as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).colorKey) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -24954,6 +16149,9 @@ pub struct SDL_WindowShapeMode {
 }
 #[test]
 fn bindgen_test_layout_SDL_WindowShapeMode() {
+    const UNINIT: ::core::mem::MaybeUninit<SDL_WindowShapeMode> =
+        ::core::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::core::mem::size_of::<SDL_WindowShapeMode>(),
         8usize,
@@ -24965,7 +16163,7 @@ fn bindgen_test_layout_SDL_WindowShapeMode() {
         concat!("Alignment of ", stringify!(SDL_WindowShapeMode))
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_WindowShapeMode>())).mode as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).mode) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -24975,7 +16173,7 @@ fn bindgen_test_layout_SDL_WindowShapeMode() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_WindowShapeMode>())).parameters as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).parameters) as usize - ptr as usize },
         4usize,
         concat!(
             "Offset of field: ",
@@ -24986,19 +16184,7 @@ fn bindgen_test_layout_SDL_WindowShapeMode() {
     );
 }
 extern "C" {
-    #[doc = " Set the shape and parameters of a shaped window."]
-    #[doc = ""]
-    #[doc = " \\param window The shaped window whose parameters should be set."]
-    #[doc = " \\param shape A surface encoding the desired shape for the window."]
-    #[doc = " \\param shape_mode The parameters to set for the shaped window."]
-    #[doc = " \\return 0 on success, SDL_INVALID_SHAPE_ARGUMENT on an invalid shape"]
-    #[doc = "         argument, or SDL_NONSHAPEABLE_WINDOW if the SDL_Window given does"]
-    #[doc = "         not reference a valid shaped window."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_WindowShapeMode"]
-    #[doc = " \\sa SDL_GetShapedWindowMode"]
+    #[doc = " Set the shape and parameters of a shaped window.\n\n \\param window The shaped window whose parameters should be set.\n \\param shape A surface encoding the desired shape for the window.\n \\param shape_mode The parameters to set for the shaped window.\n \\return 0 on success, SDL_INVALID_SHAPE_ARGUMENT on an invalid shape\n         argument, or SDL_NONSHAPEABLE_WINDOW if the SDL_Window given does\n         not reference a valid shaped window.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_WindowShapeMode\n \\sa SDL_GetShapedWindowMode"]
     pub fn SDL_SetWindowShape(
         window: *mut SDL_Window,
         shape: *mut SDL_Surface,
@@ -25006,50 +16192,18 @@ extern "C" {
     ) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Get the shape parameters of a shaped window."]
-    #[doc = ""]
-    #[doc = " \\param window The shaped window whose parameters should be retrieved."]
-    #[doc = " \\param shape_mode An empty shape-mode structure to fill, or NULL to check"]
-    #[doc = "                   whether the window has a shape."]
-    #[doc = " \\return 0 if the window has a shape and, provided shape_mode was not NULL,"]
-    #[doc = "         shape_mode has been filled with the mode data,"]
-    #[doc = "         SDL_NONSHAPEABLE_WINDOW if the SDL_Window given is not a shaped"]
-    #[doc = "         window, or SDL_WINDOW_LACKS_SHAPE if the SDL_Window given is a"]
-    #[doc = "         shapeable window currently lacking a shape."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_WindowShapeMode"]
-    #[doc = " \\sa SDL_SetWindowShape"]
+    #[doc = " Get the shape parameters of a shaped window.\n\n \\param window The shaped window whose parameters should be retrieved.\n \\param shape_mode An empty shape-mode structure to fill, or NULL to check\n                   whether the window has a shape.\n \\return 0 if the window has a shape and, provided shape_mode was not NULL,\n         shape_mode has been filled with the mode data,\n         SDL_NONSHAPEABLE_WINDOW if the SDL_Window given is not a shaped\n         window, or SDL_WINDOW_LACKS_SHAPE if the SDL_Window given is a\n         shapeable window currently lacking a shape.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_WindowShapeMode\n \\sa SDL_SetWindowShape"]
     pub fn SDL_GetShapedWindowMode(
         window: *mut SDL_Window,
         shape_mode: *mut SDL_WindowShapeMode,
     ) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Sets the UNIX nice value for a thread."]
-    #[doc = ""]
-    #[doc = " This uses setpriority() if possible, and RealtimeKit if available."]
-    #[doc = ""]
-    #[doc = " \\param threadID the Unix thread ID to change priority of."]
-    #[doc = " \\param priority The new, Unix-specific, priority value."]
-    #[doc = " \\returns 0 on success, or -1 on error."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.9."]
+    #[doc = " Sets the UNIX nice value for a thread.\n\n This uses setpriority() if possible, and RealtimeKit if available.\n\n \\param threadID the Unix thread ID to change priority of.\n \\param priority The new, Unix-specific, priority value.\n \\returns 0 on success, or -1 on error.\n\n \\since This function is available since SDL 2.0.9."]
     pub fn SDL_LinuxSetThreadPriority(threadID: Sint64, priority: libc::c_int) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Sets the priority (not nice level) and scheduling policy for a thread."]
-    #[doc = ""]
-    #[doc = " This uses setpriority() if possible, and RealtimeKit if available."]
-    #[doc = ""]
-    #[doc = " \\param threadID The Unix thread ID to change priority of."]
-    #[doc = " \\param sdlPriority The new SDL_ThreadPriority value."]
-    #[doc = " \\param schedPolicy The new scheduling policy (SCHED_FIFO, SCHED_RR,"]
-    #[doc = "                    SCHED_OTHER, etc...)"]
-    #[doc = " \\returns 0 on success, or -1 on error."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.18."]
+    #[doc = " Sets the priority (not nice level) and scheduling policy for a thread.\n\n This uses setpriority() if possible, and RealtimeKit if available.\n\n \\param threadID The Unix thread ID to change priority of.\n \\param sdlPriority The new SDL_ThreadPriority value.\n \\param schedPolicy The new scheduling policy (SCHED_FIFO, SCHED_RR,\n                    SCHED_OTHER, etc...)\n \\returns 0 on success, or -1 on error.\n\n \\since This function is available since SDL 2.0.18."]
     pub fn SDL_LinuxSetThreadPriorityAndPolicy(
         threadID: Sint64,
         sdlPriority: libc::c_int,
@@ -25057,13 +16211,7 @@ extern "C" {
     ) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Query if the current device is a tablet."]
-    #[doc = ""]
-    #[doc = " If SDL can't determine this, it will return SDL_FALSE."]
-    #[doc = ""]
-    #[doc = " \\returns SDL_TRUE if the device is a tablet, SDL_FALSE otherwise."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.9."]
+    #[doc = " Query if the current device is a tablet.\n\n If SDL can't determine this, it will return SDL_FALSE.\n\n \\returns SDL_TRUE if the device is a tablet, SDL_FALSE otherwise.\n\n \\since This function is available since SDL 2.0.9."]
     pub fn SDL_IsTablet() -> SDL_bool;
 }
 extern "C" {
@@ -25085,127 +16233,33 @@ extern "C" {
     pub fn SDL_OnApplicationDidBecomeActive();
 }
 extern "C" {
-    #[doc = " Get the number of milliseconds since SDL library initialization."]
-    #[doc = ""]
-    #[doc = " This value wraps if the program runs for more than ~49 days."]
-    #[doc = ""]
-    #[doc = " This function is not recommended as of SDL 2.0.18; use SDL_GetTicks64()"]
-    #[doc = " instead, where the value doesn't wrap every ~49 days. There are places in"]
-    #[doc = " SDL where we provide a 32-bit timestamp that can not change without"]
-    #[doc = " breaking binary compatibility, though, so this function isn't officially"]
-    #[doc = " deprecated."]
-    #[doc = ""]
-    #[doc = " \\returns an unsigned 32-bit value representing the number of milliseconds"]
-    #[doc = "          since the SDL library initialized."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_TICKS_PASSED"]
+    #[doc = " Get the number of milliseconds since SDL library initialization.\n\n This value wraps if the program runs for more than ~49 days.\n\n This function is not recommended as of SDL 2.0.18; use SDL_GetTicks64()\n instead, where the value doesn't wrap every ~49 days. There are places in\n SDL where we provide a 32-bit timestamp that can not change without\n breaking binary compatibility, though, so this function isn't officially\n deprecated.\n\n \\returns an unsigned 32-bit value representing the number of milliseconds\n          since the SDL library initialized.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_TICKS_PASSED"]
     pub fn SDL_GetTicks() -> Uint32;
 }
 extern "C" {
-    #[doc = " Get the number of milliseconds since SDL library initialization."]
-    #[doc = ""]
-    #[doc = " Note that you should not use the SDL_TICKS_PASSED macro with values"]
-    #[doc = " returned by this function, as that macro does clever math to compensate for"]
-    #[doc = " the 32-bit overflow every ~49 days that SDL_GetTicks() suffers from. 64-bit"]
-    #[doc = " values from this function can be safely compared directly."]
-    #[doc = ""]
-    #[doc = " For example, if you want to wait 100 ms, you could do this:"]
-    #[doc = ""]
-    #[doc = " ```c"]
-    #[doc = " const Uint64 timeout = SDL_GetTicks64() + 100;"]
-    #[doc = " while (SDL_GetTicks64() < timeout) {"]
-    #[doc = "     // ... do work until timeout has elapsed"]
-    #[doc = " }"]
-    #[doc = " ```"]
-    #[doc = ""]
-    #[doc = " \\returns an unsigned 64-bit value representing the number of milliseconds"]
-    #[doc = "          since the SDL library initialized."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.18."]
+    #[doc = " Get the number of milliseconds since SDL library initialization.\n\n Note that you should not use the SDL_TICKS_PASSED macro with values\n returned by this function, as that macro does clever math to compensate for\n the 32-bit overflow every ~49 days that SDL_GetTicks() suffers from. 64-bit\n values from this function can be safely compared directly.\n\n For example, if you want to wait 100 ms, you could do this:\n\n ```c\n const Uint64 timeout = SDL_GetTicks64() + 100;\n while (SDL_GetTicks64() < timeout) {\n     // ... do work until timeout has elapsed\n }\n ```\n\n \\returns an unsigned 64-bit value representing the number of milliseconds\n          since the SDL library initialized.\n\n \\since This function is available since SDL 2.0.18."]
     pub fn SDL_GetTicks64() -> Uint64;
 }
 extern "C" {
-    #[doc = " Get the current value of the high resolution counter."]
-    #[doc = ""]
-    #[doc = " This function is typically used for profiling."]
-    #[doc = ""]
-    #[doc = " The counter values are only meaningful relative to each other. Differences"]
-    #[doc = " between values can be converted to times by using"]
-    #[doc = " SDL_GetPerformanceFrequency()."]
-    #[doc = ""]
-    #[doc = " \\returns the current counter value."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_GetPerformanceFrequency"]
+    #[doc = " Get the current value of the high resolution counter.\n\n This function is typically used for profiling.\n\n The counter values are only meaningful relative to each other. Differences\n between values can be converted to times by using\n SDL_GetPerformanceFrequency().\n\n \\returns the current counter value.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_GetPerformanceFrequency"]
     pub fn SDL_GetPerformanceCounter() -> Uint64;
 }
 extern "C" {
-    #[doc = " Get the count per second of the high resolution counter."]
-    #[doc = ""]
-    #[doc = " \\returns a platform-specific count per second."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_GetPerformanceCounter"]
+    #[doc = " Get the count per second of the high resolution counter.\n\n \\returns a platform-specific count per second.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_GetPerformanceCounter"]
     pub fn SDL_GetPerformanceFrequency() -> Uint64;
 }
 extern "C" {
-    #[doc = " Wait a specified number of milliseconds before returning."]
-    #[doc = ""]
-    #[doc = " This function waits a specified number of milliseconds before returning. It"]
-    #[doc = " waits at least the specified time, but possibly longer due to OS"]
-    #[doc = " scheduling."]
-    #[doc = ""]
-    #[doc = " \\param ms the number of milliseconds to delay"]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
+    #[doc = " Wait a specified number of milliseconds before returning.\n\n This function waits a specified number of milliseconds before returning. It\n waits at least the specified time, but possibly longer due to OS\n scheduling.\n\n \\param ms the number of milliseconds to delay\n\n \\since This function is available since SDL 2.0.0."]
     pub fn SDL_Delay(ms: Uint32);
 }
-#[doc = " Function prototype for the timer callback function."]
-#[doc = ""]
-#[doc = " The callback function is passed the current timer interval and returns"]
-#[doc = " the next timer interval. If the returned value is the same as the one"]
-#[doc = " passed in, the periodic alarm continues, otherwise a new alarm is"]
-#[doc = " scheduled. If the callback returns 0, the periodic alarm is cancelled."]
+#[doc = " Function prototype for the timer callback function.\n\n The callback function is passed the current timer interval and returns\n the next timer interval. If the returned value is the same as the one\n passed in, the periodic alarm continues, otherwise a new alarm is\n scheduled. If the callback returns 0, the periodic alarm is cancelled."]
 pub type SDL_TimerCallback = ::core::option::Option<
     unsafe extern "C" fn(interval: Uint32, param: *mut libc::c_void) -> Uint32,
 >;
 #[doc = " Definition of the timer ID type."]
 pub type SDL_TimerID = libc::c_int;
 extern "C" {
-    #[doc = " Call a callback function at a future time."]
-    #[doc = ""]
-    #[doc = " If you use this function, you must pass `SDL_INIT_TIMER` to SDL_Init()."]
-    #[doc = ""]
-    #[doc = " The callback function is passed the current timer interval and the user"]
-    #[doc = " supplied parameter from the SDL_AddTimer() call and should return the next"]
-    #[doc = " timer interval. If the value returned from the callback is 0, the timer is"]
-    #[doc = " canceled."]
-    #[doc = ""]
-    #[doc = " The callback is run on a separate thread."]
-    #[doc = ""]
-    #[doc = " Timers take into account the amount of time it took to execute the"]
-    #[doc = " callback. For example, if the callback took 250 ms to execute and returned"]
-    #[doc = " 1000 (ms), the timer would only wait another 750 ms before its next"]
-    #[doc = " iteration."]
-    #[doc = ""]
-    #[doc = " Timing may be inexact due to OS scheduling. Be sure to note the current"]
-    #[doc = " time with SDL_GetTicks() or SDL_GetPerformanceCounter() in case your"]
-    #[doc = " callback needs to adjust for variances."]
-    #[doc = ""]
-    #[doc = " \\param interval the timer delay, in milliseconds, passed to `callback`"]
-    #[doc = " \\param callback the SDL_TimerCallback function to call when the specified"]
-    #[doc = "                 `interval` elapses"]
-    #[doc = " \\param param a pointer that is passed to `callback`"]
-    #[doc = " \\returns a timer ID or 0 if an error occurs; call SDL_GetError() for more"]
-    #[doc = "          information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_RemoveTimer"]
+    #[doc = " Call a callback function at a future time.\n\n If you use this function, you must pass `SDL_INIT_TIMER` to SDL_Init().\n\n The callback function is passed the current timer interval and the user\n supplied parameter from the SDL_AddTimer() call and should return the next\n timer interval. If the value returned from the callback is 0, the timer is\n canceled.\n\n The callback is run on a separate thread.\n\n Timers take into account the amount of time it took to execute the\n callback. For example, if the callback took 250 ms to execute and returned\n 1000 (ms), the timer would only wait another 750 ms before its next\n iteration.\n\n Timing may be inexact due to OS scheduling. Be sure to note the current\n time with SDL_GetTicks() or SDL_GetPerformanceCounter() in case your\n callback needs to adjust for variances.\n\n \\param interval the timer delay, in milliseconds, passed to `callback`\n \\param callback the SDL_TimerCallback function to call when the specified\n                 `interval` elapses\n \\param param a pointer that is passed to `callback`\n \\returns a timer ID or 0 if an error occurs; call SDL_GetError() for more\n          information.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_RemoveTimer"]
     pub fn SDL_AddTimer(
         interval: Uint32,
         callback: SDL_TimerCallback,
@@ -25213,27 +16267,10 @@ extern "C" {
     ) -> SDL_TimerID;
 }
 extern "C" {
-    #[doc = " Remove a timer created with SDL_AddTimer()."]
-    #[doc = ""]
-    #[doc = " \\param id the ID of the timer to remove"]
-    #[doc = " \\returns SDL_TRUE if the timer is removed or SDL_FALSE if the timer wasn't"]
-    #[doc = "          found."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_AddTimer"]
+    #[doc = " Remove a timer created with SDL_AddTimer().\n\n \\param id the ID of the timer to remove\n \\returns SDL_TRUE if the timer is removed or SDL_FALSE if the timer wasn't\n          found.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_AddTimer"]
     pub fn SDL_RemoveTimer(id: SDL_TimerID) -> SDL_bool;
 }
-#[doc = " Information about the version of SDL in use."]
-#[doc = ""]
-#[doc = " Represents the library's version as three levels: major revision"]
-#[doc = " (increments with massive changes, additions, and enhancements),"]
-#[doc = " minor revision (increments with backwards-compatible changes to the"]
-#[doc = " major revision), and patchlevel (increments with fixes to the minor"]
-#[doc = " revision)."]
-#[doc = ""]
-#[doc = " \\sa SDL_VERSION"]
-#[doc = " \\sa SDL_GetVersion"]
+#[doc = " Information about the version of SDL in use.\n\n Represents the library's version as three levels: major revision\n (increments with massive changes, additions, and enhancements),\n minor revision (increments with backwards-compatible changes to the\n major revision), and patchlevel (increments with fixes to the minor\n revision).\n\n \\sa SDL_VERSION\n \\sa SDL_GetVersion"]
 #[repr(C)]
 #[derive(Copy, Clone)]
 pub struct SDL_version {
@@ -25246,6 +16283,8 @@ pub struct SDL_version {
 }
 #[test]
 fn bindgen_test_layout_SDL_version() {
+    const UNINIT: ::core::mem::MaybeUninit<SDL_version> = ::core::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::core::mem::size_of::<SDL_version>(),
         3usize,
@@ -25257,7 +16296,7 @@ fn bindgen_test_layout_SDL_version() {
         concat!("Alignment of ", stringify!(SDL_version))
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_version>())).major as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).major) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -25267,7 +16306,7 @@ fn bindgen_test_layout_SDL_version() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_version>())).minor as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).minor) as usize - ptr as usize },
         1usize,
         concat!(
             "Offset of field: ",
@@ -25277,7 +16316,7 @@ fn bindgen_test_layout_SDL_version() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_version>())).patch as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).patch) as usize - ptr as usize },
         2usize,
         concat!(
             "Offset of field: ",
@@ -25288,70 +16327,15 @@ fn bindgen_test_layout_SDL_version() {
     );
 }
 extern "C" {
-    #[doc = " Get the version of SDL that is linked against your program."]
-    #[doc = ""]
-    #[doc = " If you are linking to SDL dynamically, then it is possible that the current"]
-    #[doc = " version will be different than the version you compiled against. This"]
-    #[doc = " function returns the current version, while SDL_VERSION() is a macro that"]
-    #[doc = " tells you what version you compiled with."]
-    #[doc = ""]
-    #[doc = " This function may be called safely at any time, even before SDL_Init()."]
-    #[doc = ""]
-    #[doc = " \\param ver the SDL_version structure that contains the version information"]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_GetRevision"]
+    #[doc = " Get the version of SDL that is linked against your program.\n\n If you are linking to SDL dynamically, then it is possible that the current\n version will be different than the version you compiled against. This\n function returns the current version, while SDL_VERSION() is a macro that\n tells you what version you compiled with.\n\n This function may be called safely at any time, even before SDL_Init().\n\n \\param ver the SDL_version structure that contains the version information\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_GetRevision"]
     pub fn SDL_GetVersion(ver: *mut SDL_version);
 }
 extern "C" {
-    #[doc = " Get the code revision of SDL that is linked against your program."]
-    #[doc = ""]
-    #[doc = " This value is the revision of the code you are linked with and may be"]
-    #[doc = " different from the code you are compiling with, which is found in the"]
-    #[doc = " constant SDL_REVISION."]
-    #[doc = ""]
-    #[doc = " The revision is arbitrary string (a hash value) uniquely identifying the"]
-    #[doc = " exact revision of the SDL library in use, and is only useful in comparing"]
-    #[doc = " against other revisions. It is NOT an incrementing number."]
-    #[doc = ""]
-    #[doc = " If SDL wasn't built from a git repository with the appropriate tools, this"]
-    #[doc = " will return an empty string."]
-    #[doc = ""]
-    #[doc = " Prior to SDL 2.0.16, before development moved to GitHub, this returned a"]
-    #[doc = " hash for a Mercurial repository."]
-    #[doc = ""]
-    #[doc = " You shouldn't use this function for anything but logging it for debugging"]
-    #[doc = " purposes. The string is not intended to be reliable in any way."]
-    #[doc = ""]
-    #[doc = " \\returns an arbitrary string, uniquely identifying the exact revision of"]
-    #[doc = "          the SDL library in use."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_GetVersion"]
+    #[doc = " Get the code revision of SDL that is linked against your program.\n\n This value is the revision of the code you are linked with and may be\n different from the code you are compiling with, which is found in the\n constant SDL_REVISION.\n\n The revision is arbitrary string (a hash value) uniquely identifying the\n exact revision of the SDL library in use, and is only useful in comparing\n against other revisions. It is NOT an incrementing number.\n\n If SDL wasn't built from a git repository with the appropriate tools, this\n will return an empty string.\n\n Prior to SDL 2.0.16, before development moved to GitHub, this returned a\n hash for a Mercurial repository.\n\n You shouldn't use this function for anything but logging it for debugging\n purposes. The string is not intended to be reliable in any way.\n\n \\returns an arbitrary string, uniquely identifying the exact revision of\n          the SDL library in use.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_GetVersion"]
     pub fn SDL_GetRevision() -> *const libc::c_char;
 }
 extern "C" {
-    #[doc = " Obsolete function, do not use."]
-    #[doc = ""]
-    #[doc = " When SDL was hosted in a Mercurial repository, and was built carefully,"]
-    #[doc = " this would return the revision number that the build was created from. This"]
-    #[doc = " number was not reliable for several reasons, but more importantly, SDL is"]
-    #[doc = " now hosted in a git repository, which does not offer numbers at all, only"]
-    #[doc = " hashes. This function only ever returns zero now. Don't use it."]
-    #[doc = ""]
-    #[doc = " Before SDL 2.0.16, this might have returned an unreliable, but non-zero"]
-    #[doc = " number."]
-    #[doc = ""]
-    #[doc = " \\deprecated Use SDL_GetRevision() instead; if SDL was carefully built, it"]
-    #[doc = "             will return a git hash."]
-    #[doc = ""]
-    #[doc = " \\returns zero, always, in modern SDL releases."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_GetRevision"]
+    #[doc = " Obsolete function, do not use.\n\n When SDL was hosted in a Mercurial repository, and was built carefully,\n this would return the revision number that the build was created from. This\n number was not reliable for several reasons, but more importantly, SDL is\n now hosted in a git repository, which does not offer numbers at all, only\n hashes. This function only ever returns zero now. Don't use it.\n\n Before SDL 2.0.16, this might have returned an unreliable, but non-zero\n number.\n\n \\deprecated Use SDL_GetRevision() instead; if SDL was carefully built, it\n             will return a git hash.\n\n \\returns zero, always, in modern SDL releases.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_GetRevision"]
     pub fn SDL_GetRevisionNumber() -> libc::c_int;
 }
 #[repr(C)]
@@ -25364,6 +16348,8 @@ pub struct SDL_Locale {
 }
 #[test]
 fn bindgen_test_layout_SDL_Locale() {
+    const UNINIT: ::core::mem::MaybeUninit<SDL_Locale> = ::core::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::core::mem::size_of::<SDL_Locale>(),
         16usize,
@@ -25375,7 +16361,7 @@ fn bindgen_test_layout_SDL_Locale() {
         concat!("Alignment of ", stringify!(SDL_Locale))
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_Locale>())).language as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).language) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -25385,7 +16371,7 @@ fn bindgen_test_layout_SDL_Locale() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_Locale>())).country as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).country) as usize - ptr as usize },
         8usize,
         concat!(
             "Offset of field: ",
@@ -25396,199 +16382,31 @@ fn bindgen_test_layout_SDL_Locale() {
     );
 }
 extern "C" {
-    #[doc = " Report the user's preferred locale."]
-    #[doc = ""]
-    #[doc = " This returns an array of SDL_Locale structs, the final item zeroed out."]
-    #[doc = " When the caller is done with this array, it should call SDL_free() on the"]
-    #[doc = " returned value; all the memory involved is allocated in a single block, so"]
-    #[doc = " a single SDL_free() will suffice."]
-    #[doc = ""]
-    #[doc = " Returned language strings are in the format xx, where 'xx' is an ISO-639"]
-    #[doc = " language specifier (such as \"en\" for English, \"de\" for German, etc)."]
-    #[doc = " Country strings are in the format YY, where \"YY\" is an ISO-3166 country"]
-    #[doc = " code (such as \"US\" for the United States, \"CA\" for Canada, etc). Country"]
-    #[doc = " might be NULL if there's no specific guidance on them (so you might get {"]
-    #[doc = " \"en\", \"US\" } for American English, but { \"en\", NULL } means \"English"]
-    #[doc = " language, generically\"). Language strings are never NULL, except to"]
-    #[doc = " terminate the array."]
-    #[doc = ""]
-    #[doc = " Please note that not all of these strings are 2 characters; some are three"]
-    #[doc = " or more."]
-    #[doc = ""]
-    #[doc = " The returned list of locales are in the order of the user's preference. For"]
-    #[doc = " example, a German citizen that is fluent in US English and knows enough"]
-    #[doc = " Japanese to navigate around Tokyo might have a list like: { \"de\", \"en_US\","]
-    #[doc = " \"jp\", NULL }. Someone from England might prefer British English (where"]
-    #[doc = " \"color\" is spelled \"colour\", etc), but will settle for anything like it: {"]
-    #[doc = " \"en_GB\", \"en\", NULL }."]
-    #[doc = ""]
-    #[doc = " This function returns NULL on error, including when the platform does not"]
-    #[doc = " supply this information at all."]
-    #[doc = ""]
-    #[doc = " This might be a \"slow\" call that has to query the operating system. It's"]
-    #[doc = " best to ask for this once and save the results. However, this list can"]
-    #[doc = " change, usually because the user has changed a system preference outside of"]
-    #[doc = " your program; SDL will send an SDL_LOCALECHANGED event in this case, if"]
-    #[doc = " possible, and you can call this function again to get an updated copy of"]
-    #[doc = " preferred locales."]
-    #[doc = ""]
-    #[doc = " \\return array of locales, terminated with a locale with a NULL language"]
-    #[doc = "         field. Will return NULL on error."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.14."]
+    #[doc = " Report the user's preferred locale.\n\n This returns an array of SDL_Locale structs, the final item zeroed out.\n When the caller is done with this array, it should call SDL_free() on the\n returned value; all the memory involved is allocated in a single block, so\n a single SDL_free() will suffice.\n\n Returned language strings are in the format xx, where 'xx' is an ISO-639\n language specifier (such as \"en\" for English, \"de\" for German, etc).\n Country strings are in the format YY, where \"YY\" is an ISO-3166 country\n code (such as \"US\" for the United States, \"CA\" for Canada, etc). Country\n might be NULL if there's no specific guidance on them (so you might get {\n \"en\", \"US\" } for American English, but { \"en\", NULL } means \"English\n language, generically\"). Language strings are never NULL, except to\n terminate the array.\n\n Please note that not all of these strings are 2 characters; some are three\n or more.\n\n The returned list of locales are in the order of the user's preference. For\n example, a German citizen that is fluent in US English and knows enough\n Japanese to navigate around Tokyo might have a list like: { \"de\", \"en_US\",\n \"jp\", NULL }. Someone from England might prefer British English (where\n \"color\" is spelled \"colour\", etc), but will settle for anything like it: {\n \"en_GB\", \"en\", NULL }.\n\n This function returns NULL on error, including when the platform does not\n supply this information at all.\n\n This might be a \"slow\" call that has to query the operating system. It's\n best to ask for this once and save the results. However, this list can\n change, usually because the user has changed a system preference outside of\n your program; SDL will send an SDL_LOCALECHANGED event in this case, if\n possible, and you can call this function again to get an updated copy of\n preferred locales.\n\n \\return array of locales, terminated with a locale with a NULL language\n         field. Will return NULL on error.\n\n \\since This function is available since SDL 2.0.14."]
     pub fn SDL_GetPreferredLocales() -> *mut SDL_Locale;
 }
 extern "C" {
-    #[doc = " Open a URL/URI in the browser or other appropriate external application."]
-    #[doc = ""]
-    #[doc = " Open a URL in a separate, system-provided application. How this works will"]
-    #[doc = " vary wildly depending on the platform. This will likely launch what makes"]
-    #[doc = " sense to handle a specific URL's protocol (a web browser for `http://`,"]
-    #[doc = " etc), but it might also be able to launch file managers for directories and"]
-    #[doc = " other things."]
-    #[doc = ""]
-    #[doc = " What happens when you open a URL varies wildly as well: your game window"]
-    #[doc = " may lose focus (and may or may not lose focus if your game was fullscreen"]
-    #[doc = " or grabbing input at the time). On mobile devices, your app will likely"]
-    #[doc = " move to the background or your process might be paused. Any given platform"]
-    #[doc = " may or may not handle a given URL."]
-    #[doc = ""]
-    #[doc = " If this is unimplemented (or simply unavailable) for a platform, this will"]
-    #[doc = " fail with an error. A successful result does not mean the URL loaded, just"]
-    #[doc = " that we launched _something_ to handle it (or at least believe we did)."]
-    #[doc = ""]
-    #[doc = " All this to say: this function can be useful, but you should definitely"]
-    #[doc = " test it on every platform you target."]
-    #[doc = ""]
-    #[doc = " \\param url A valid URL/URI to open. Use `file:///full/path/to/file` for"]
-    #[doc = "            local files, if supported."]
-    #[doc = " \\returns 0 on success, or -1 on error; call SDL_GetError() for more"]
-    #[doc = "          information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.14."]
+    #[doc = " Open a URL/URI in the browser or other appropriate external application.\n\n Open a URL in a separate, system-provided application. How this works will\n vary wildly depending on the platform. This will likely launch what makes\n sense to handle a specific URL's protocol (a web browser for `http://`,\n etc), but it might also be able to launch file managers for directories and\n other things.\n\n What happens when you open a URL varies wildly as well: your game window\n may lose focus (and may or may not lose focus if your game was fullscreen\n or grabbing input at the time). On mobile devices, your app will likely\n move to the background or your process might be paused. Any given platform\n may or may not handle a given URL.\n\n If this is unimplemented (or simply unavailable) for a platform, this will\n fail with an error. A successful result does not mean the URL loaded, just\n that we launched _something_ to handle it (or at least believe we did).\n\n All this to say: this function can be useful, but you should definitely\n test it on every platform you target.\n\n \\param url A valid URL/URI to open. Use `file:///full/path/to/file` for\n            local files, if supported.\n \\returns 0 on success, or -1 on error; call SDL_GetError() for more\n          information.\n\n \\since This function is available since SDL 2.0.14."]
     pub fn SDL_OpenURL(url: *const libc::c_char) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Initialize the SDL library."]
-    #[doc = ""]
-    #[doc = " SDL_Init() simply forwards to calling SDL_InitSubSystem(). Therefore, the"]
-    #[doc = " two may be used interchangeably. Though for readability of your code"]
-    #[doc = " SDL_InitSubSystem() might be preferred."]
-    #[doc = ""]
-    #[doc = " The file I/O (for example: SDL_RWFromFile) and threading (SDL_CreateThread)"]
-    #[doc = " subsystems are initialized by default. Message boxes"]
-    #[doc = " (SDL_ShowSimpleMessageBox) also attempt to work without initializing the"]
-    #[doc = " video subsystem, in hopes of being useful in showing an error dialog when"]
-    #[doc = " SDL_Init fails. You must specifically initialize other subsystems if you"]
-    #[doc = " use them in your application."]
-    #[doc = ""]
-    #[doc = " Logging (such as SDL_Log) works without initialization, too."]
-    #[doc = ""]
-    #[doc = " `flags` may be any of the following OR'd together:"]
-    #[doc = ""]
-    #[doc = " - `SDL_INIT_TIMER`: timer subsystem"]
-    #[doc = " - `SDL_INIT_AUDIO`: audio subsystem"]
-    #[doc = " - `SDL_INIT_VIDEO`: video subsystem; automatically initializes the events"]
-    #[doc = "   subsystem"]
-    #[doc = " - `SDL_INIT_JOYSTICK`: joystick subsystem; automatically initializes the"]
-    #[doc = "   events subsystem"]
-    #[doc = " - `SDL_INIT_HAPTIC`: haptic (force feedback) subsystem"]
-    #[doc = " - `SDL_INIT_GAMECONTROLLER`: controller subsystem; automatically"]
-    #[doc = "   initializes the joystick subsystem"]
-    #[doc = " - `SDL_INIT_EVENTS`: events subsystem"]
-    #[doc = " - `SDL_INIT_EVERYTHING`: all of the above subsystems"]
-    #[doc = " - `SDL_INIT_NOPARACHUTE`: compatibility; this flag is ignored"]
-    #[doc = ""]
-    #[doc = " Subsystem initialization is ref-counted, you must call SDL_QuitSubSystem()"]
-    #[doc = " for each SDL_InitSubSystem() to correctly shutdown a subsystem manually (or"]
-    #[doc = " call SDL_Quit() to force shutdown). If a subsystem is already loaded then"]
-    #[doc = " this call will increase the ref-count and return."]
-    #[doc = ""]
-    #[doc = " \\param flags subsystem initialization flags"]
-    #[doc = " \\returns 0 on success or a negative error code on failure; call"]
-    #[doc = "          SDL_GetError() for more information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_InitSubSystem"]
-    #[doc = " \\sa SDL_Quit"]
-    #[doc = " \\sa SDL_SetMainReady"]
-    #[doc = " \\sa SDL_WasInit"]
+    #[doc = " Initialize the SDL library.\n\n SDL_Init() simply forwards to calling SDL_InitSubSystem(). Therefore, the\n two may be used interchangeably. Though for readability of your code\n SDL_InitSubSystem() might be preferred.\n\n The file I/O (for example: SDL_RWFromFile) and threading (SDL_CreateThread)\n subsystems are initialized by default. Message boxes\n (SDL_ShowSimpleMessageBox) also attempt to work without initializing the\n video subsystem, in hopes of being useful in showing an error dialog when\n SDL_Init fails. You must specifically initialize other subsystems if you\n use them in your application.\n\n Logging (such as SDL_Log) works without initialization, too.\n\n `flags` may be any of the following OR'd together:\n\n - `SDL_INIT_TIMER`: timer subsystem\n - `SDL_INIT_AUDIO`: audio subsystem\n - `SDL_INIT_VIDEO`: video subsystem; automatically initializes the events\n   subsystem\n - `SDL_INIT_JOYSTICK`: joystick subsystem; automatically initializes the\n   events subsystem\n - `SDL_INIT_HAPTIC`: haptic (force feedback) subsystem\n - `SDL_INIT_GAMECONTROLLER`: controller subsystem; automatically\n   initializes the joystick subsystem\n - `SDL_INIT_EVENTS`: events subsystem\n - `SDL_INIT_EVERYTHING`: all of the above subsystems\n - `SDL_INIT_NOPARACHUTE`: compatibility; this flag is ignored\n\n Subsystem initialization is ref-counted, you must call SDL_QuitSubSystem()\n for each SDL_InitSubSystem() to correctly shutdown a subsystem manually (or\n call SDL_Quit() to force shutdown). If a subsystem is already loaded then\n this call will increase the ref-count and return.\n\n \\param flags subsystem initialization flags\n \\returns 0 on success or a negative error code on failure; call\n          SDL_GetError() for more information.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_InitSubSystem\n \\sa SDL_Quit\n \\sa SDL_SetMainReady\n \\sa SDL_WasInit"]
     pub fn SDL_Init(flags: Uint32) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Compatibility function to initialize the SDL library."]
-    #[doc = ""]
-    #[doc = " In SDL2, this function and SDL_Init() are interchangeable."]
-    #[doc = ""]
-    #[doc = " \\param flags any of the flags used by SDL_Init(); see SDL_Init for details."]
-    #[doc = " \\returns 0 on success or a negative error code on failure; call"]
-    #[doc = "          SDL_GetError() for more information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_Init"]
-    #[doc = " \\sa SDL_Quit"]
-    #[doc = " \\sa SDL_QuitSubSystem"]
+    #[doc = " Compatibility function to initialize the SDL library.\n\n In SDL2, this function and SDL_Init() are interchangeable.\n\n \\param flags any of the flags used by SDL_Init(); see SDL_Init for details.\n \\returns 0 on success or a negative error code on failure; call\n          SDL_GetError() for more information.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_Init\n \\sa SDL_Quit\n \\sa SDL_QuitSubSystem"]
     pub fn SDL_InitSubSystem(flags: Uint32) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Shut down specific SDL subsystems."]
-    #[doc = ""]
-    #[doc = " If you start a subsystem using a call to that subsystem's init function"]
-    #[doc = " (for example SDL_VideoInit()) instead of SDL_Init() or SDL_InitSubSystem(),"]
-    #[doc = " SDL_QuitSubSystem() and SDL_WasInit() will not work. You will need to use"]
-    #[doc = " that subsystem's quit function (SDL_VideoQuit()) directly instead. But"]
-    #[doc = " generally, you should not be using those functions directly anyhow; use"]
-    #[doc = " SDL_Init() instead."]
-    #[doc = ""]
-    #[doc = " You still need to call SDL_Quit() even if you close all open subsystems"]
-    #[doc = " with SDL_QuitSubSystem()."]
-    #[doc = ""]
-    #[doc = " \\param flags any of the flags used by SDL_Init(); see SDL_Init for details."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_InitSubSystem"]
-    #[doc = " \\sa SDL_Quit"]
+    #[doc = " Shut down specific SDL subsystems.\n\n If you start a subsystem using a call to that subsystem's init function\n (for example SDL_VideoInit()) instead of SDL_Init() or SDL_InitSubSystem(),\n SDL_QuitSubSystem() and SDL_WasInit() will not work. You will need to use\n that subsystem's quit function (SDL_VideoQuit()) directly instead. But\n generally, you should not be using those functions directly anyhow; use\n SDL_Init() instead.\n\n You still need to call SDL_Quit() even if you close all open subsystems\n with SDL_QuitSubSystem().\n\n \\param flags any of the flags used by SDL_Init(); see SDL_Init for details.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_InitSubSystem\n \\sa SDL_Quit"]
     pub fn SDL_QuitSubSystem(flags: Uint32);
 }
 extern "C" {
-    #[doc = " Get a mask of the specified subsystems which are currently initialized."]
-    #[doc = ""]
-    #[doc = " \\param flags any of the flags used by SDL_Init(); see SDL_Init for details."]
-    #[doc = " \\returns a mask of all initialized subsystems if `flags` is 0, otherwise it"]
-    #[doc = "          returns the initialization status of the specified subsystems."]
-    #[doc = ""]
-    #[doc = "          The return value does not include SDL_INIT_NOPARACHUTE."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_Init"]
-    #[doc = " \\sa SDL_InitSubSystem"]
+    #[doc = " Get a mask of the specified subsystems which are currently initialized.\n\n \\param flags any of the flags used by SDL_Init(); see SDL_Init for details.\n \\returns a mask of all initialized subsystems if `flags` is 0, otherwise it\n          returns the initialization status of the specified subsystems.\n\n          The return value does not include SDL_INIT_NOPARACHUTE.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_Init\n \\sa SDL_InitSubSystem"]
     pub fn SDL_WasInit(flags: Uint32) -> Uint32;
 }
 extern "C" {
-    #[doc = " Clean up all initialized subsystems."]
-    #[doc = ""]
-    #[doc = " You should call this function even if you have already shutdown each"]
-    #[doc = " initialized subsystem with SDL_QuitSubSystem(). It is safe to call this"]
-    #[doc = " function even in the case of errors in initialization."]
-    #[doc = ""]
-    #[doc = " If you start a subsystem using a call to that subsystem's init function"]
-    #[doc = " (for example SDL_VideoInit()) instead of SDL_Init() or SDL_InitSubSystem(),"]
-    #[doc = " then you must use that subsystem's quit function (SDL_VideoQuit()) to shut"]
-    #[doc = " it down before calling SDL_Quit(). But generally, you should not be using"]
-    #[doc = " those functions directly anyhow; use SDL_Init() instead."]
-    #[doc = ""]
-    #[doc = " You can use this function with atexit() to ensure that it is run when your"]
-    #[doc = " application is shutdown, but it is not wise to do this from a library or"]
-    #[doc = " other dynamically loaded code."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_Init"]
-    #[doc = " \\sa SDL_QuitSubSystem"]
+    #[doc = " Clean up all initialized subsystems.\n\n You should call this function even if you have already shutdown each\n initialized subsystem with SDL_QuitSubSystem(). It is safe to call this\n function even in the case of errors in initialization.\n\n If you start a subsystem using a call to that subsystem's init function\n (for example SDL_VideoInit()) instead of SDL_Init() or SDL_InitSubSystem(),\n then you must use that subsystem's quit function (SDL_VideoQuit()) to shut\n it down before calling SDL_Quit(). But generally, you should not be using\n those functions directly anyhow; use SDL_Init() instead.\n\n You can use this function with atexit() to ensure that it is run when your\n application is shutdown, but it is not wise to do this from a library or\n other dynamically loaded code.\n\n \\since This function is available since SDL 2.0.0.\n\n \\sa SDL_Init\n \\sa SDL_QuitSubSystem"]
     pub fn SDL_Quit();
 }
 pub type XID = libc::c_ulong;
@@ -25606,7 +16424,7 @@ pub type GContext = XID;
 pub type KeySym = XID;
 pub type KeyCode = libc::c_uchar;
 extern "C" {
-    pub fn _Xmblen(str: *mut libc::c_char, len: libc::c_int) -> libc::c_int;
+    pub fn _Xmblen(str_: *mut libc::c_char, len: libc::c_int) -> libc::c_int;
 }
 pub type XPointer = *mut libc::c_char;
 #[repr(C)]
@@ -25620,6 +16438,8 @@ pub struct _XExtData {
 }
 #[test]
 fn bindgen_test_layout__XExtData() {
+    const UNINIT: ::core::mem::MaybeUninit<_XExtData> = ::core::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::core::mem::size_of::<_XExtData>(),
         32usize,
@@ -25631,7 +16451,7 @@ fn bindgen_test_layout__XExtData() {
         concat!("Alignment of ", stringify!(_XExtData))
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<_XExtData>())).number as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).number) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -25641,7 +16461,7 @@ fn bindgen_test_layout__XExtData() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<_XExtData>())).next as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).next) as usize - ptr as usize },
         8usize,
         concat!(
             "Offset of field: ",
@@ -25651,7 +16471,7 @@ fn bindgen_test_layout__XExtData() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<_XExtData>())).free_private as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).free_private) as usize - ptr as usize },
         16usize,
         concat!(
             "Offset of field: ",
@@ -25661,7 +16481,7 @@ fn bindgen_test_layout__XExtData() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<_XExtData>())).private_data as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).private_data) as usize - ptr as usize },
         24usize,
         concat!(
             "Offset of field: ",
@@ -25682,6 +16502,8 @@ pub struct XExtCodes {
 }
 #[test]
 fn bindgen_test_layout_XExtCodes() {
+    const UNINIT: ::core::mem::MaybeUninit<XExtCodes> = ::core::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::core::mem::size_of::<XExtCodes>(),
         16usize,
@@ -25693,7 +16515,7 @@ fn bindgen_test_layout_XExtCodes() {
         concat!("Alignment of ", stringify!(XExtCodes))
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XExtCodes>())).extension as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).extension) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -25703,7 +16525,7 @@ fn bindgen_test_layout_XExtCodes() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XExtCodes>())).major_opcode as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).major_opcode) as usize - ptr as usize },
         4usize,
         concat!(
             "Offset of field: ",
@@ -25713,7 +16535,7 @@ fn bindgen_test_layout_XExtCodes() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XExtCodes>())).first_event as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).first_event) as usize - ptr as usize },
         8usize,
         concat!(
             "Offset of field: ",
@@ -25723,7 +16545,7 @@ fn bindgen_test_layout_XExtCodes() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XExtCodes>())).first_error as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).first_error) as usize - ptr as usize },
         12usize,
         concat!(
             "Offset of field: ",
@@ -25742,6 +16564,9 @@ pub struct XPixmapFormatValues {
 }
 #[test]
 fn bindgen_test_layout_XPixmapFormatValues() {
+    const UNINIT: ::core::mem::MaybeUninit<XPixmapFormatValues> =
+        ::core::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::core::mem::size_of::<XPixmapFormatValues>(),
         12usize,
@@ -25753,7 +16578,7 @@ fn bindgen_test_layout_XPixmapFormatValues() {
         concat!("Alignment of ", stringify!(XPixmapFormatValues))
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XPixmapFormatValues>())).depth as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).depth) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -25763,9 +16588,7 @@ fn bindgen_test_layout_XPixmapFormatValues() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::core::ptr::null::<XPixmapFormatValues>())).bits_per_pixel as *const _ as usize
-        },
+        unsafe { ::core::ptr::addr_of!((*ptr).bits_per_pixel) as usize - ptr as usize },
         4usize,
         concat!(
             "Offset of field: ",
@@ -25775,9 +16598,7 @@ fn bindgen_test_layout_XPixmapFormatValues() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::core::ptr::null::<XPixmapFormatValues>())).scanline_pad as *const _ as usize
-        },
+        unsafe { ::core::ptr::addr_of!((*ptr).scanline_pad) as usize - ptr as usize },
         8usize,
         concat!(
             "Offset of field: ",
@@ -25816,6 +16637,8 @@ pub struct XGCValues {
 }
 #[test]
 fn bindgen_test_layout_XGCValues() {
+    const UNINIT: ::core::mem::MaybeUninit<XGCValues> = ::core::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::core::mem::size_of::<XGCValues>(),
         128usize,
@@ -25827,7 +16650,7 @@ fn bindgen_test_layout_XGCValues() {
         concat!("Alignment of ", stringify!(XGCValues))
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XGCValues>())).function as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).function) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -25837,7 +16660,7 @@ fn bindgen_test_layout_XGCValues() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XGCValues>())).plane_mask as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).plane_mask) as usize - ptr as usize },
         8usize,
         concat!(
             "Offset of field: ",
@@ -25847,7 +16670,7 @@ fn bindgen_test_layout_XGCValues() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XGCValues>())).foreground as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).foreground) as usize - ptr as usize },
         16usize,
         concat!(
             "Offset of field: ",
@@ -25857,7 +16680,7 @@ fn bindgen_test_layout_XGCValues() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XGCValues>())).background as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).background) as usize - ptr as usize },
         24usize,
         concat!(
             "Offset of field: ",
@@ -25867,7 +16690,7 @@ fn bindgen_test_layout_XGCValues() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XGCValues>())).line_width as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).line_width) as usize - ptr as usize },
         32usize,
         concat!(
             "Offset of field: ",
@@ -25877,7 +16700,7 @@ fn bindgen_test_layout_XGCValues() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XGCValues>())).line_style as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).line_style) as usize - ptr as usize },
         36usize,
         concat!(
             "Offset of field: ",
@@ -25887,7 +16710,7 @@ fn bindgen_test_layout_XGCValues() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XGCValues>())).cap_style as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).cap_style) as usize - ptr as usize },
         40usize,
         concat!(
             "Offset of field: ",
@@ -25897,7 +16720,7 @@ fn bindgen_test_layout_XGCValues() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XGCValues>())).join_style as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).join_style) as usize - ptr as usize },
         44usize,
         concat!(
             "Offset of field: ",
@@ -25907,7 +16730,7 @@ fn bindgen_test_layout_XGCValues() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XGCValues>())).fill_style as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).fill_style) as usize - ptr as usize },
         48usize,
         concat!(
             "Offset of field: ",
@@ -25917,7 +16740,7 @@ fn bindgen_test_layout_XGCValues() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XGCValues>())).fill_rule as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).fill_rule) as usize - ptr as usize },
         52usize,
         concat!(
             "Offset of field: ",
@@ -25927,7 +16750,7 @@ fn bindgen_test_layout_XGCValues() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XGCValues>())).arc_mode as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).arc_mode) as usize - ptr as usize },
         56usize,
         concat!(
             "Offset of field: ",
@@ -25937,7 +16760,7 @@ fn bindgen_test_layout_XGCValues() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XGCValues>())).tile as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).tile) as usize - ptr as usize },
         64usize,
         concat!(
             "Offset of field: ",
@@ -25947,7 +16770,7 @@ fn bindgen_test_layout_XGCValues() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XGCValues>())).stipple as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).stipple) as usize - ptr as usize },
         72usize,
         concat!(
             "Offset of field: ",
@@ -25957,7 +16780,7 @@ fn bindgen_test_layout_XGCValues() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XGCValues>())).ts_x_origin as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).ts_x_origin) as usize - ptr as usize },
         80usize,
         concat!(
             "Offset of field: ",
@@ -25967,7 +16790,7 @@ fn bindgen_test_layout_XGCValues() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XGCValues>())).ts_y_origin as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).ts_y_origin) as usize - ptr as usize },
         84usize,
         concat!(
             "Offset of field: ",
@@ -25977,7 +16800,7 @@ fn bindgen_test_layout_XGCValues() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XGCValues>())).font as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).font) as usize - ptr as usize },
         88usize,
         concat!(
             "Offset of field: ",
@@ -25987,7 +16810,7 @@ fn bindgen_test_layout_XGCValues() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XGCValues>())).subwindow_mode as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).subwindow_mode) as usize - ptr as usize },
         96usize,
         concat!(
             "Offset of field: ",
@@ -25997,7 +16820,7 @@ fn bindgen_test_layout_XGCValues() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XGCValues>())).graphics_exposures as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).graphics_exposures) as usize - ptr as usize },
         100usize,
         concat!(
             "Offset of field: ",
@@ -26007,7 +16830,7 @@ fn bindgen_test_layout_XGCValues() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XGCValues>())).clip_x_origin as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).clip_x_origin) as usize - ptr as usize },
         104usize,
         concat!(
             "Offset of field: ",
@@ -26017,7 +16840,7 @@ fn bindgen_test_layout_XGCValues() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XGCValues>())).clip_y_origin as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).clip_y_origin) as usize - ptr as usize },
         108usize,
         concat!(
             "Offset of field: ",
@@ -26027,7 +16850,7 @@ fn bindgen_test_layout_XGCValues() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XGCValues>())).clip_mask as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).clip_mask) as usize - ptr as usize },
         112usize,
         concat!(
             "Offset of field: ",
@@ -26037,7 +16860,7 @@ fn bindgen_test_layout_XGCValues() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XGCValues>())).dash_offset as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).dash_offset) as usize - ptr as usize },
         120usize,
         concat!(
             "Offset of field: ",
@@ -26047,7 +16870,7 @@ fn bindgen_test_layout_XGCValues() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XGCValues>())).dashes as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).dashes) as usize - ptr as usize },
         124usize,
         concat!(
             "Offset of field: ",
@@ -26077,6 +16900,8 @@ pub struct Visual {
 }
 #[test]
 fn bindgen_test_layout_Visual() {
+    const UNINIT: ::core::mem::MaybeUninit<Visual> = ::core::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::core::mem::size_of::<Visual>(),
         56usize,
@@ -26088,7 +16913,7 @@ fn bindgen_test_layout_Visual() {
         concat!("Alignment of ", stringify!(Visual))
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<Visual>())).ext_data as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).ext_data) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -26098,7 +16923,7 @@ fn bindgen_test_layout_Visual() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<Visual>())).visualid as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).visualid) as usize - ptr as usize },
         8usize,
         concat!(
             "Offset of field: ",
@@ -26108,7 +16933,7 @@ fn bindgen_test_layout_Visual() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<Visual>())).class as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).class) as usize - ptr as usize },
         16usize,
         concat!(
             "Offset of field: ",
@@ -26118,7 +16943,7 @@ fn bindgen_test_layout_Visual() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<Visual>())).red_mask as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).red_mask) as usize - ptr as usize },
         24usize,
         concat!(
             "Offset of field: ",
@@ -26128,7 +16953,7 @@ fn bindgen_test_layout_Visual() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<Visual>())).green_mask as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).green_mask) as usize - ptr as usize },
         32usize,
         concat!(
             "Offset of field: ",
@@ -26138,7 +16963,7 @@ fn bindgen_test_layout_Visual() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<Visual>())).blue_mask as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).blue_mask) as usize - ptr as usize },
         40usize,
         concat!(
             "Offset of field: ",
@@ -26148,7 +16973,7 @@ fn bindgen_test_layout_Visual() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<Visual>())).bits_per_rgb as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).bits_per_rgb) as usize - ptr as usize },
         48usize,
         concat!(
             "Offset of field: ",
@@ -26158,7 +16983,7 @@ fn bindgen_test_layout_Visual() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<Visual>())).map_entries as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).map_entries) as usize - ptr as usize },
         52usize,
         concat!(
             "Offset of field: ",
@@ -26177,6 +17002,8 @@ pub struct Depth {
 }
 #[test]
 fn bindgen_test_layout_Depth() {
+    const UNINIT: ::core::mem::MaybeUninit<Depth> = ::core::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::core::mem::size_of::<Depth>(),
         16usize,
@@ -26188,7 +17015,7 @@ fn bindgen_test_layout_Depth() {
         concat!("Alignment of ", stringify!(Depth))
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<Depth>())).depth as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).depth) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -26198,7 +17025,7 @@ fn bindgen_test_layout_Depth() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<Depth>())).nvisuals as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).nvisuals) as usize - ptr as usize },
         4usize,
         concat!(
             "Offset of field: ",
@@ -26208,7 +17035,7 @@ fn bindgen_test_layout_Depth() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<Depth>())).visuals as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).visuals) as usize - ptr as usize },
         8usize,
         concat!(
             "Offset of field: ",
@@ -26249,6 +17076,8 @@ pub struct Screen {
 }
 #[test]
 fn bindgen_test_layout_Screen() {
+    const UNINIT: ::core::mem::MaybeUninit<Screen> = ::core::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::core::mem::size_of::<Screen>(),
         128usize,
@@ -26260,7 +17089,7 @@ fn bindgen_test_layout_Screen() {
         concat!("Alignment of ", stringify!(Screen))
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<Screen>())).ext_data as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).ext_data) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -26270,7 +17099,7 @@ fn bindgen_test_layout_Screen() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<Screen>())).display as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).display) as usize - ptr as usize },
         8usize,
         concat!(
             "Offset of field: ",
@@ -26280,7 +17109,7 @@ fn bindgen_test_layout_Screen() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<Screen>())).root as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).root) as usize - ptr as usize },
         16usize,
         concat!(
             "Offset of field: ",
@@ -26290,7 +17119,7 @@ fn bindgen_test_layout_Screen() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<Screen>())).width as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).width) as usize - ptr as usize },
         24usize,
         concat!(
             "Offset of field: ",
@@ -26300,7 +17129,7 @@ fn bindgen_test_layout_Screen() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<Screen>())).height as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).height) as usize - ptr as usize },
         28usize,
         concat!(
             "Offset of field: ",
@@ -26310,7 +17139,7 @@ fn bindgen_test_layout_Screen() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<Screen>())).mwidth as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).mwidth) as usize - ptr as usize },
         32usize,
         concat!(
             "Offset of field: ",
@@ -26320,7 +17149,7 @@ fn bindgen_test_layout_Screen() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<Screen>())).mheight as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).mheight) as usize - ptr as usize },
         36usize,
         concat!(
             "Offset of field: ",
@@ -26330,7 +17159,7 @@ fn bindgen_test_layout_Screen() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<Screen>())).ndepths as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).ndepths) as usize - ptr as usize },
         40usize,
         concat!(
             "Offset of field: ",
@@ -26340,7 +17169,7 @@ fn bindgen_test_layout_Screen() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<Screen>())).depths as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).depths) as usize - ptr as usize },
         48usize,
         concat!(
             "Offset of field: ",
@@ -26350,7 +17179,7 @@ fn bindgen_test_layout_Screen() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<Screen>())).root_depth as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).root_depth) as usize - ptr as usize },
         56usize,
         concat!(
             "Offset of field: ",
@@ -26360,7 +17189,7 @@ fn bindgen_test_layout_Screen() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<Screen>())).root_visual as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).root_visual) as usize - ptr as usize },
         64usize,
         concat!(
             "Offset of field: ",
@@ -26370,7 +17199,7 @@ fn bindgen_test_layout_Screen() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<Screen>())).default_gc as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).default_gc) as usize - ptr as usize },
         72usize,
         concat!(
             "Offset of field: ",
@@ -26380,7 +17209,7 @@ fn bindgen_test_layout_Screen() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<Screen>())).cmap as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).cmap) as usize - ptr as usize },
         80usize,
         concat!(
             "Offset of field: ",
@@ -26390,7 +17219,7 @@ fn bindgen_test_layout_Screen() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<Screen>())).white_pixel as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).white_pixel) as usize - ptr as usize },
         88usize,
         concat!(
             "Offset of field: ",
@@ -26400,7 +17229,7 @@ fn bindgen_test_layout_Screen() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<Screen>())).black_pixel as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).black_pixel) as usize - ptr as usize },
         96usize,
         concat!(
             "Offset of field: ",
@@ -26410,7 +17239,7 @@ fn bindgen_test_layout_Screen() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<Screen>())).max_maps as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).max_maps) as usize - ptr as usize },
         104usize,
         concat!(
             "Offset of field: ",
@@ -26420,7 +17249,7 @@ fn bindgen_test_layout_Screen() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<Screen>())).min_maps as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).min_maps) as usize - ptr as usize },
         108usize,
         concat!(
             "Offset of field: ",
@@ -26430,7 +17259,7 @@ fn bindgen_test_layout_Screen() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<Screen>())).backing_store as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).backing_store) as usize - ptr as usize },
         112usize,
         concat!(
             "Offset of field: ",
@@ -26440,7 +17269,7 @@ fn bindgen_test_layout_Screen() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<Screen>())).save_unders as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).save_unders) as usize - ptr as usize },
         116usize,
         concat!(
             "Offset of field: ",
@@ -26450,7 +17279,7 @@ fn bindgen_test_layout_Screen() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<Screen>())).root_input_mask as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).root_input_mask) as usize - ptr as usize },
         120usize,
         concat!(
             "Offset of field: ",
@@ -26470,6 +17299,8 @@ pub struct ScreenFormat {
 }
 #[test]
 fn bindgen_test_layout_ScreenFormat() {
+    const UNINIT: ::core::mem::MaybeUninit<ScreenFormat> = ::core::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::core::mem::size_of::<ScreenFormat>(),
         24usize,
@@ -26481,7 +17312,7 @@ fn bindgen_test_layout_ScreenFormat() {
         concat!("Alignment of ", stringify!(ScreenFormat))
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<ScreenFormat>())).ext_data as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).ext_data) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -26491,7 +17322,7 @@ fn bindgen_test_layout_ScreenFormat() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<ScreenFormat>())).depth as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).depth) as usize - ptr as usize },
         8usize,
         concat!(
             "Offset of field: ",
@@ -26501,7 +17332,7 @@ fn bindgen_test_layout_ScreenFormat() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<ScreenFormat>())).bits_per_pixel as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).bits_per_pixel) as usize - ptr as usize },
         12usize,
         concat!(
             "Offset of field: ",
@@ -26511,7 +17342,7 @@ fn bindgen_test_layout_ScreenFormat() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<ScreenFormat>())).scanline_pad as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).scanline_pad) as usize - ptr as usize },
         16usize,
         concat!(
             "Offset of field: ",
@@ -26542,6 +17373,9 @@ pub struct XSetWindowAttributes {
 }
 #[test]
 fn bindgen_test_layout_XSetWindowAttributes() {
+    const UNINIT: ::core::mem::MaybeUninit<XSetWindowAttributes> =
+        ::core::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::core::mem::size_of::<XSetWindowAttributes>(),
         112usize,
@@ -26553,9 +17387,7 @@ fn bindgen_test_layout_XSetWindowAttributes() {
         concat!("Alignment of ", stringify!(XSetWindowAttributes))
     );
     assert_eq!(
-        unsafe {
-            &(*(::core::ptr::null::<XSetWindowAttributes>())).background_pixmap as *const _ as usize
-        },
+        unsafe { ::core::ptr::addr_of!((*ptr).background_pixmap) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -26565,9 +17397,7 @@ fn bindgen_test_layout_XSetWindowAttributes() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::core::ptr::null::<XSetWindowAttributes>())).background_pixel as *const _ as usize
-        },
+        unsafe { ::core::ptr::addr_of!((*ptr).background_pixel) as usize - ptr as usize },
         8usize,
         concat!(
             "Offset of field: ",
@@ -26577,9 +17407,7 @@ fn bindgen_test_layout_XSetWindowAttributes() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::core::ptr::null::<XSetWindowAttributes>())).border_pixmap as *const _ as usize
-        },
+        unsafe { ::core::ptr::addr_of!((*ptr).border_pixmap) as usize - ptr as usize },
         16usize,
         concat!(
             "Offset of field: ",
@@ -26589,9 +17417,7 @@ fn bindgen_test_layout_XSetWindowAttributes() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::core::ptr::null::<XSetWindowAttributes>())).border_pixel as *const _ as usize
-        },
+        unsafe { ::core::ptr::addr_of!((*ptr).border_pixel) as usize - ptr as usize },
         24usize,
         concat!(
             "Offset of field: ",
@@ -26601,9 +17427,7 @@ fn bindgen_test_layout_XSetWindowAttributes() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::core::ptr::null::<XSetWindowAttributes>())).bit_gravity as *const _ as usize
-        },
+        unsafe { ::core::ptr::addr_of!((*ptr).bit_gravity) as usize - ptr as usize },
         32usize,
         concat!(
             "Offset of field: ",
@@ -26613,9 +17437,7 @@ fn bindgen_test_layout_XSetWindowAttributes() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::core::ptr::null::<XSetWindowAttributes>())).win_gravity as *const _ as usize
-        },
+        unsafe { ::core::ptr::addr_of!((*ptr).win_gravity) as usize - ptr as usize },
         36usize,
         concat!(
             "Offset of field: ",
@@ -26625,9 +17447,7 @@ fn bindgen_test_layout_XSetWindowAttributes() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::core::ptr::null::<XSetWindowAttributes>())).backing_store as *const _ as usize
-        },
+        unsafe { ::core::ptr::addr_of!((*ptr).backing_store) as usize - ptr as usize },
         40usize,
         concat!(
             "Offset of field: ",
@@ -26637,9 +17457,7 @@ fn bindgen_test_layout_XSetWindowAttributes() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::core::ptr::null::<XSetWindowAttributes>())).backing_planes as *const _ as usize
-        },
+        unsafe { ::core::ptr::addr_of!((*ptr).backing_planes) as usize - ptr as usize },
         48usize,
         concat!(
             "Offset of field: ",
@@ -26649,9 +17467,7 @@ fn bindgen_test_layout_XSetWindowAttributes() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::core::ptr::null::<XSetWindowAttributes>())).backing_pixel as *const _ as usize
-        },
+        unsafe { ::core::ptr::addr_of!((*ptr).backing_pixel) as usize - ptr as usize },
         56usize,
         concat!(
             "Offset of field: ",
@@ -26661,9 +17477,7 @@ fn bindgen_test_layout_XSetWindowAttributes() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::core::ptr::null::<XSetWindowAttributes>())).save_under as *const _ as usize
-        },
+        unsafe { ::core::ptr::addr_of!((*ptr).save_under) as usize - ptr as usize },
         64usize,
         concat!(
             "Offset of field: ",
@@ -26673,9 +17487,7 @@ fn bindgen_test_layout_XSetWindowAttributes() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::core::ptr::null::<XSetWindowAttributes>())).event_mask as *const _ as usize
-        },
+        unsafe { ::core::ptr::addr_of!((*ptr).event_mask) as usize - ptr as usize },
         72usize,
         concat!(
             "Offset of field: ",
@@ -26685,10 +17497,7 @@ fn bindgen_test_layout_XSetWindowAttributes() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::core::ptr::null::<XSetWindowAttributes>())).do_not_propagate_mask as *const _
-                as usize
-        },
+        unsafe { ::core::ptr::addr_of!((*ptr).do_not_propagate_mask) as usize - ptr as usize },
         80usize,
         concat!(
             "Offset of field: ",
@@ -26698,9 +17507,7 @@ fn bindgen_test_layout_XSetWindowAttributes() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::core::ptr::null::<XSetWindowAttributes>())).override_redirect as *const _ as usize
-        },
+        unsafe { ::core::ptr::addr_of!((*ptr).override_redirect) as usize - ptr as usize },
         88usize,
         concat!(
             "Offset of field: ",
@@ -26710,7 +17517,7 @@ fn bindgen_test_layout_XSetWindowAttributes() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XSetWindowAttributes>())).colormap as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).colormap) as usize - ptr as usize },
         96usize,
         concat!(
             "Offset of field: ",
@@ -26720,7 +17527,7 @@ fn bindgen_test_layout_XSetWindowAttributes() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XSetWindowAttributes>())).cursor as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).cursor) as usize - ptr as usize },
         104usize,
         concat!(
             "Offset of field: ",
@@ -26759,6 +17566,8 @@ pub struct XWindowAttributes {
 }
 #[test]
 fn bindgen_test_layout_XWindowAttributes() {
+    const UNINIT: ::core::mem::MaybeUninit<XWindowAttributes> = ::core::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::core::mem::size_of::<XWindowAttributes>(),
         136usize,
@@ -26770,7 +17579,7 @@ fn bindgen_test_layout_XWindowAttributes() {
         concat!("Alignment of ", stringify!(XWindowAttributes))
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XWindowAttributes>())).x as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).x) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -26780,7 +17589,7 @@ fn bindgen_test_layout_XWindowAttributes() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XWindowAttributes>())).y as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).y) as usize - ptr as usize },
         4usize,
         concat!(
             "Offset of field: ",
@@ -26790,7 +17599,7 @@ fn bindgen_test_layout_XWindowAttributes() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XWindowAttributes>())).width as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).width) as usize - ptr as usize },
         8usize,
         concat!(
             "Offset of field: ",
@@ -26800,7 +17609,7 @@ fn bindgen_test_layout_XWindowAttributes() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XWindowAttributes>())).height as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).height) as usize - ptr as usize },
         12usize,
         concat!(
             "Offset of field: ",
@@ -26810,7 +17619,7 @@ fn bindgen_test_layout_XWindowAttributes() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XWindowAttributes>())).border_width as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).border_width) as usize - ptr as usize },
         16usize,
         concat!(
             "Offset of field: ",
@@ -26820,7 +17629,7 @@ fn bindgen_test_layout_XWindowAttributes() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XWindowAttributes>())).depth as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).depth) as usize - ptr as usize },
         20usize,
         concat!(
             "Offset of field: ",
@@ -26830,7 +17639,7 @@ fn bindgen_test_layout_XWindowAttributes() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XWindowAttributes>())).visual as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).visual) as usize - ptr as usize },
         24usize,
         concat!(
             "Offset of field: ",
@@ -26840,7 +17649,7 @@ fn bindgen_test_layout_XWindowAttributes() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XWindowAttributes>())).root as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).root) as usize - ptr as usize },
         32usize,
         concat!(
             "Offset of field: ",
@@ -26850,7 +17659,7 @@ fn bindgen_test_layout_XWindowAttributes() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XWindowAttributes>())).class as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).class) as usize - ptr as usize },
         40usize,
         concat!(
             "Offset of field: ",
@@ -26860,7 +17669,7 @@ fn bindgen_test_layout_XWindowAttributes() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XWindowAttributes>())).bit_gravity as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).bit_gravity) as usize - ptr as usize },
         44usize,
         concat!(
             "Offset of field: ",
@@ -26870,7 +17679,7 @@ fn bindgen_test_layout_XWindowAttributes() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XWindowAttributes>())).win_gravity as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).win_gravity) as usize - ptr as usize },
         48usize,
         concat!(
             "Offset of field: ",
@@ -26880,9 +17689,7 @@ fn bindgen_test_layout_XWindowAttributes() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::core::ptr::null::<XWindowAttributes>())).backing_store as *const _ as usize
-        },
+        unsafe { ::core::ptr::addr_of!((*ptr).backing_store) as usize - ptr as usize },
         52usize,
         concat!(
             "Offset of field: ",
@@ -26892,9 +17699,7 @@ fn bindgen_test_layout_XWindowAttributes() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::core::ptr::null::<XWindowAttributes>())).backing_planes as *const _ as usize
-        },
+        unsafe { ::core::ptr::addr_of!((*ptr).backing_planes) as usize - ptr as usize },
         56usize,
         concat!(
             "Offset of field: ",
@@ -26904,9 +17709,7 @@ fn bindgen_test_layout_XWindowAttributes() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::core::ptr::null::<XWindowAttributes>())).backing_pixel as *const _ as usize
-        },
+        unsafe { ::core::ptr::addr_of!((*ptr).backing_pixel) as usize - ptr as usize },
         64usize,
         concat!(
             "Offset of field: ",
@@ -26916,7 +17719,7 @@ fn bindgen_test_layout_XWindowAttributes() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XWindowAttributes>())).save_under as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).save_under) as usize - ptr as usize },
         72usize,
         concat!(
             "Offset of field: ",
@@ -26926,7 +17729,7 @@ fn bindgen_test_layout_XWindowAttributes() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XWindowAttributes>())).colormap as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).colormap) as usize - ptr as usize },
         80usize,
         concat!(
             "Offset of field: ",
@@ -26936,9 +17739,7 @@ fn bindgen_test_layout_XWindowAttributes() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::core::ptr::null::<XWindowAttributes>())).map_installed as *const _ as usize
-        },
+        unsafe { ::core::ptr::addr_of!((*ptr).map_installed) as usize - ptr as usize },
         88usize,
         concat!(
             "Offset of field: ",
@@ -26948,7 +17749,7 @@ fn bindgen_test_layout_XWindowAttributes() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XWindowAttributes>())).map_state as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).map_state) as usize - ptr as usize },
         92usize,
         concat!(
             "Offset of field: ",
@@ -26958,9 +17759,7 @@ fn bindgen_test_layout_XWindowAttributes() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::core::ptr::null::<XWindowAttributes>())).all_event_masks as *const _ as usize
-        },
+        unsafe { ::core::ptr::addr_of!((*ptr).all_event_masks) as usize - ptr as usize },
         96usize,
         concat!(
             "Offset of field: ",
@@ -26970,9 +17769,7 @@ fn bindgen_test_layout_XWindowAttributes() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::core::ptr::null::<XWindowAttributes>())).your_event_mask as *const _ as usize
-        },
+        unsafe { ::core::ptr::addr_of!((*ptr).your_event_mask) as usize - ptr as usize },
         104usize,
         concat!(
             "Offset of field: ",
@@ -26982,10 +17779,7 @@ fn bindgen_test_layout_XWindowAttributes() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::core::ptr::null::<XWindowAttributes>())).do_not_propagate_mask as *const _
-                as usize
-        },
+        unsafe { ::core::ptr::addr_of!((*ptr).do_not_propagate_mask) as usize - ptr as usize },
         112usize,
         concat!(
             "Offset of field: ",
@@ -26995,9 +17789,7 @@ fn bindgen_test_layout_XWindowAttributes() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::core::ptr::null::<XWindowAttributes>())).override_redirect as *const _ as usize
-        },
+        unsafe { ::core::ptr::addr_of!((*ptr).override_redirect) as usize - ptr as usize },
         120usize,
         concat!(
             "Offset of field: ",
@@ -27007,7 +17799,7 @@ fn bindgen_test_layout_XWindowAttributes() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XWindowAttributes>())).screen as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).screen) as usize - ptr as usize },
         128usize,
         concat!(
             "Offset of field: ",
@@ -27026,6 +17818,8 @@ pub struct XHostAddress {
 }
 #[test]
 fn bindgen_test_layout_XHostAddress() {
+    const UNINIT: ::core::mem::MaybeUninit<XHostAddress> = ::core::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::core::mem::size_of::<XHostAddress>(),
         16usize,
@@ -27037,7 +17831,7 @@ fn bindgen_test_layout_XHostAddress() {
         concat!("Alignment of ", stringify!(XHostAddress))
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XHostAddress>())).family as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).family) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -27047,7 +17841,7 @@ fn bindgen_test_layout_XHostAddress() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XHostAddress>())).length as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).length) as usize - ptr as usize },
         4usize,
         concat!(
             "Offset of field: ",
@@ -27057,7 +17851,7 @@ fn bindgen_test_layout_XHostAddress() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XHostAddress>())).address as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).address) as usize - ptr as usize },
         8usize,
         concat!(
             "Offset of field: ",
@@ -27077,6 +17871,9 @@ pub struct XServerInterpretedAddress {
 }
 #[test]
 fn bindgen_test_layout_XServerInterpretedAddress() {
+    const UNINIT: ::core::mem::MaybeUninit<XServerInterpretedAddress> =
+        ::core::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::core::mem::size_of::<XServerInterpretedAddress>(),
         24usize,
@@ -27088,9 +17885,7 @@ fn bindgen_test_layout_XServerInterpretedAddress() {
         concat!("Alignment of ", stringify!(XServerInterpretedAddress))
     );
     assert_eq!(
-        unsafe {
-            &(*(::core::ptr::null::<XServerInterpretedAddress>())).typelength as *const _ as usize
-        },
+        unsafe { ::core::ptr::addr_of!((*ptr).typelength) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -27100,9 +17895,7 @@ fn bindgen_test_layout_XServerInterpretedAddress() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::core::ptr::null::<XServerInterpretedAddress>())).valuelength as *const _ as usize
-        },
+        unsafe { ::core::ptr::addr_of!((*ptr).valuelength) as usize - ptr as usize },
         4usize,
         concat!(
             "Offset of field: ",
@@ -27112,9 +17905,7 @@ fn bindgen_test_layout_XServerInterpretedAddress() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::core::ptr::null::<XServerInterpretedAddress>())).type_ as *const _ as usize
-        },
+        unsafe { ::core::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
         8usize,
         concat!(
             "Offset of field: ",
@@ -27124,9 +17915,7 @@ fn bindgen_test_layout_XServerInterpretedAddress() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::core::ptr::null::<XServerInterpretedAddress>())).value as *const _ as usize
-        },
+        unsafe { ::core::ptr::addr_of!((*ptr).value) as usize - ptr as usize },
         16usize,
         concat!(
             "Offset of field: ",
@@ -27206,6 +17995,8 @@ pub struct _XImage_funcs {
 }
 #[test]
 fn bindgen_test_layout__XImage_funcs() {
+    const UNINIT: ::core::mem::MaybeUninit<_XImage_funcs> = ::core::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::core::mem::size_of::<_XImage_funcs>(),
         48usize,
@@ -27217,7 +18008,7 @@ fn bindgen_test_layout__XImage_funcs() {
         concat!("Alignment of ", stringify!(_XImage_funcs))
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<_XImage_funcs>())).create_image as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).create_image) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -27227,7 +18018,7 @@ fn bindgen_test_layout__XImage_funcs() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<_XImage_funcs>())).destroy_image as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).destroy_image) as usize - ptr as usize },
         8usize,
         concat!(
             "Offset of field: ",
@@ -27237,7 +18028,7 @@ fn bindgen_test_layout__XImage_funcs() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<_XImage_funcs>())).get_pixel as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).get_pixel) as usize - ptr as usize },
         16usize,
         concat!(
             "Offset of field: ",
@@ -27247,7 +18038,7 @@ fn bindgen_test_layout__XImage_funcs() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<_XImage_funcs>())).put_pixel as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).put_pixel) as usize - ptr as usize },
         24usize,
         concat!(
             "Offset of field: ",
@@ -27257,7 +18048,7 @@ fn bindgen_test_layout__XImage_funcs() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<_XImage_funcs>())).sub_image as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).sub_image) as usize - ptr as usize },
         32usize,
         concat!(
             "Offset of field: ",
@@ -27267,7 +18058,7 @@ fn bindgen_test_layout__XImage_funcs() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<_XImage_funcs>())).add_pixel as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).add_pixel) as usize - ptr as usize },
         40usize,
         concat!(
             "Offset of field: ",
@@ -27279,6 +18070,8 @@ fn bindgen_test_layout__XImage_funcs() {
 }
 #[test]
 fn bindgen_test_layout__XImage() {
+    const UNINIT: ::core::mem::MaybeUninit<_XImage> = ::core::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::core::mem::size_of::<_XImage>(),
         136usize,
@@ -27290,7 +18083,7 @@ fn bindgen_test_layout__XImage() {
         concat!("Alignment of ", stringify!(_XImage))
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<_XImage>())).width as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).width) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -27300,7 +18093,7 @@ fn bindgen_test_layout__XImage() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<_XImage>())).height as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).height) as usize - ptr as usize },
         4usize,
         concat!(
             "Offset of field: ",
@@ -27310,7 +18103,7 @@ fn bindgen_test_layout__XImage() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<_XImage>())).xoffset as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).xoffset) as usize - ptr as usize },
         8usize,
         concat!(
             "Offset of field: ",
@@ -27320,7 +18113,7 @@ fn bindgen_test_layout__XImage() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<_XImage>())).format as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).format) as usize - ptr as usize },
         12usize,
         concat!(
             "Offset of field: ",
@@ -27330,7 +18123,7 @@ fn bindgen_test_layout__XImage() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<_XImage>())).data as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
         16usize,
         concat!(
             "Offset of field: ",
@@ -27340,7 +18133,7 @@ fn bindgen_test_layout__XImage() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<_XImage>())).byte_order as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).byte_order) as usize - ptr as usize },
         24usize,
         concat!(
             "Offset of field: ",
@@ -27350,7 +18143,7 @@ fn bindgen_test_layout__XImage() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<_XImage>())).bitmap_unit as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).bitmap_unit) as usize - ptr as usize },
         28usize,
         concat!(
             "Offset of field: ",
@@ -27360,7 +18153,7 @@ fn bindgen_test_layout__XImage() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<_XImage>())).bitmap_bit_order as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).bitmap_bit_order) as usize - ptr as usize },
         32usize,
         concat!(
             "Offset of field: ",
@@ -27370,7 +18163,7 @@ fn bindgen_test_layout__XImage() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<_XImage>())).bitmap_pad as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).bitmap_pad) as usize - ptr as usize },
         36usize,
         concat!(
             "Offset of field: ",
@@ -27380,7 +18173,7 @@ fn bindgen_test_layout__XImage() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<_XImage>())).depth as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).depth) as usize - ptr as usize },
         40usize,
         concat!(
             "Offset of field: ",
@@ -27390,7 +18183,7 @@ fn bindgen_test_layout__XImage() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<_XImage>())).bytes_per_line as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).bytes_per_line) as usize - ptr as usize },
         44usize,
         concat!(
             "Offset of field: ",
@@ -27400,7 +18193,7 @@ fn bindgen_test_layout__XImage() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<_XImage>())).bits_per_pixel as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).bits_per_pixel) as usize - ptr as usize },
         48usize,
         concat!(
             "Offset of field: ",
@@ -27410,7 +18203,7 @@ fn bindgen_test_layout__XImage() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<_XImage>())).red_mask as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).red_mask) as usize - ptr as usize },
         56usize,
         concat!(
             "Offset of field: ",
@@ -27420,7 +18213,7 @@ fn bindgen_test_layout__XImage() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<_XImage>())).green_mask as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).green_mask) as usize - ptr as usize },
         64usize,
         concat!(
             "Offset of field: ",
@@ -27430,7 +18223,7 @@ fn bindgen_test_layout__XImage() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<_XImage>())).blue_mask as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).blue_mask) as usize - ptr as usize },
         72usize,
         concat!(
             "Offset of field: ",
@@ -27440,7 +18233,7 @@ fn bindgen_test_layout__XImage() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<_XImage>())).obdata as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).obdata) as usize - ptr as usize },
         80usize,
         concat!(
             "Offset of field: ",
@@ -27450,7 +18243,7 @@ fn bindgen_test_layout__XImage() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<_XImage>())).f as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).f) as usize - ptr as usize },
         88usize,
         concat!(
             "Offset of field: ",
@@ -27474,6 +18267,8 @@ pub struct XWindowChanges {
 }
 #[test]
 fn bindgen_test_layout_XWindowChanges() {
+    const UNINIT: ::core::mem::MaybeUninit<XWindowChanges> = ::core::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::core::mem::size_of::<XWindowChanges>(),
         40usize,
@@ -27485,7 +18280,7 @@ fn bindgen_test_layout_XWindowChanges() {
         concat!("Alignment of ", stringify!(XWindowChanges))
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XWindowChanges>())).x as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).x) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -27495,7 +18290,7 @@ fn bindgen_test_layout_XWindowChanges() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XWindowChanges>())).y as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).y) as usize - ptr as usize },
         4usize,
         concat!(
             "Offset of field: ",
@@ -27505,7 +18300,7 @@ fn bindgen_test_layout_XWindowChanges() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XWindowChanges>())).width as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).width) as usize - ptr as usize },
         8usize,
         concat!(
             "Offset of field: ",
@@ -27515,7 +18310,7 @@ fn bindgen_test_layout_XWindowChanges() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XWindowChanges>())).height as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).height) as usize - ptr as usize },
         12usize,
         concat!(
             "Offset of field: ",
@@ -27525,7 +18320,7 @@ fn bindgen_test_layout_XWindowChanges() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XWindowChanges>())).border_width as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).border_width) as usize - ptr as usize },
         16usize,
         concat!(
             "Offset of field: ",
@@ -27535,7 +18330,7 @@ fn bindgen_test_layout_XWindowChanges() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XWindowChanges>())).sibling as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).sibling) as usize - ptr as usize },
         24usize,
         concat!(
             "Offset of field: ",
@@ -27545,7 +18340,7 @@ fn bindgen_test_layout_XWindowChanges() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XWindowChanges>())).stack_mode as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).stack_mode) as usize - ptr as usize },
         32usize,
         concat!(
             "Offset of field: ",
@@ -27567,6 +18362,8 @@ pub struct XColor {
 }
 #[test]
 fn bindgen_test_layout_XColor() {
+    const UNINIT: ::core::mem::MaybeUninit<XColor> = ::core::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::core::mem::size_of::<XColor>(),
         16usize,
@@ -27578,7 +18375,7 @@ fn bindgen_test_layout_XColor() {
         concat!("Alignment of ", stringify!(XColor))
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XColor>())).pixel as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).pixel) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -27588,7 +18385,7 @@ fn bindgen_test_layout_XColor() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XColor>())).red as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).red) as usize - ptr as usize },
         8usize,
         concat!(
             "Offset of field: ",
@@ -27598,7 +18395,7 @@ fn bindgen_test_layout_XColor() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XColor>())).green as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).green) as usize - ptr as usize },
         10usize,
         concat!(
             "Offset of field: ",
@@ -27608,7 +18405,7 @@ fn bindgen_test_layout_XColor() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XColor>())).blue as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).blue) as usize - ptr as usize },
         12usize,
         concat!(
             "Offset of field: ",
@@ -27618,7 +18415,7 @@ fn bindgen_test_layout_XColor() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XColor>())).flags as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
         14usize,
         concat!(
             "Offset of field: ",
@@ -27628,7 +18425,7 @@ fn bindgen_test_layout_XColor() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XColor>())).pad as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).pad) as usize - ptr as usize },
         15usize,
         concat!(
             "Offset of field: ",
@@ -27648,6 +18445,8 @@ pub struct XSegment {
 }
 #[test]
 fn bindgen_test_layout_XSegment() {
+    const UNINIT: ::core::mem::MaybeUninit<XSegment> = ::core::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::core::mem::size_of::<XSegment>(),
         8usize,
@@ -27659,7 +18458,7 @@ fn bindgen_test_layout_XSegment() {
         concat!("Alignment of ", stringify!(XSegment))
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XSegment>())).x1 as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).x1) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -27669,7 +18468,7 @@ fn bindgen_test_layout_XSegment() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XSegment>())).y1 as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).y1) as usize - ptr as usize },
         2usize,
         concat!(
             "Offset of field: ",
@@ -27679,7 +18478,7 @@ fn bindgen_test_layout_XSegment() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XSegment>())).x2 as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).x2) as usize - ptr as usize },
         4usize,
         concat!(
             "Offset of field: ",
@@ -27689,7 +18488,7 @@ fn bindgen_test_layout_XSegment() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XSegment>())).y2 as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).y2) as usize - ptr as usize },
         6usize,
         concat!(
             "Offset of field: ",
@@ -27707,6 +18506,8 @@ pub struct XPoint {
 }
 #[test]
 fn bindgen_test_layout_XPoint() {
+    const UNINIT: ::core::mem::MaybeUninit<XPoint> = ::core::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::core::mem::size_of::<XPoint>(),
         4usize,
@@ -27718,12 +18519,12 @@ fn bindgen_test_layout_XPoint() {
         concat!("Alignment of ", stringify!(XPoint))
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XPoint>())).x as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).x) as usize - ptr as usize },
         0usize,
         concat!("Offset of field: ", stringify!(XPoint), "::", stringify!(x))
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XPoint>())).y as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).y) as usize - ptr as usize },
         2usize,
         concat!("Offset of field: ", stringify!(XPoint), "::", stringify!(y))
     );
@@ -27738,6 +18539,8 @@ pub struct XRectangle {
 }
 #[test]
 fn bindgen_test_layout_XRectangle() {
+    const UNINIT: ::core::mem::MaybeUninit<XRectangle> = ::core::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::core::mem::size_of::<XRectangle>(),
         8usize,
@@ -27749,7 +18552,7 @@ fn bindgen_test_layout_XRectangle() {
         concat!("Alignment of ", stringify!(XRectangle))
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XRectangle>())).x as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).x) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -27759,7 +18562,7 @@ fn bindgen_test_layout_XRectangle() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XRectangle>())).y as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).y) as usize - ptr as usize },
         2usize,
         concat!(
             "Offset of field: ",
@@ -27769,7 +18572,7 @@ fn bindgen_test_layout_XRectangle() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XRectangle>())).width as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).width) as usize - ptr as usize },
         4usize,
         concat!(
             "Offset of field: ",
@@ -27779,7 +18582,7 @@ fn bindgen_test_layout_XRectangle() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XRectangle>())).height as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).height) as usize - ptr as usize },
         6usize,
         concat!(
             "Offset of field: ",
@@ -27801,6 +18604,8 @@ pub struct XArc {
 }
 #[test]
 fn bindgen_test_layout_XArc() {
+    const UNINIT: ::core::mem::MaybeUninit<XArc> = ::core::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::core::mem::size_of::<XArc>(),
         12usize,
@@ -27812,17 +18617,17 @@ fn bindgen_test_layout_XArc() {
         concat!("Alignment of ", stringify!(XArc))
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XArc>())).x as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).x) as usize - ptr as usize },
         0usize,
         concat!("Offset of field: ", stringify!(XArc), "::", stringify!(x))
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XArc>())).y as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).y) as usize - ptr as usize },
         2usize,
         concat!("Offset of field: ", stringify!(XArc), "::", stringify!(y))
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XArc>())).width as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).width) as usize - ptr as usize },
         4usize,
         concat!(
             "Offset of field: ",
@@ -27832,7 +18637,7 @@ fn bindgen_test_layout_XArc() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XArc>())).height as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).height) as usize - ptr as usize },
         6usize,
         concat!(
             "Offset of field: ",
@@ -27842,7 +18647,7 @@ fn bindgen_test_layout_XArc() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XArc>())).angle1 as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).angle1) as usize - ptr as usize },
         8usize,
         concat!(
             "Offset of field: ",
@@ -27852,7 +18657,7 @@ fn bindgen_test_layout_XArc() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XArc>())).angle2 as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).angle2) as usize - ptr as usize },
         10usize,
         concat!(
             "Offset of field: ",
@@ -27876,6 +18681,8 @@ pub struct XKeyboardControl {
 }
 #[test]
 fn bindgen_test_layout_XKeyboardControl() {
+    const UNINIT: ::core::mem::MaybeUninit<XKeyboardControl> = ::core::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::core::mem::size_of::<XKeyboardControl>(),
         32usize,
@@ -27887,9 +18694,7 @@ fn bindgen_test_layout_XKeyboardControl() {
         concat!("Alignment of ", stringify!(XKeyboardControl))
     );
     assert_eq!(
-        unsafe {
-            &(*(::core::ptr::null::<XKeyboardControl>())).key_click_percent as *const _ as usize
-        },
+        unsafe { ::core::ptr::addr_of!((*ptr).key_click_percent) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -27899,7 +18704,7 @@ fn bindgen_test_layout_XKeyboardControl() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XKeyboardControl>())).bell_percent as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).bell_percent) as usize - ptr as usize },
         4usize,
         concat!(
             "Offset of field: ",
@@ -27909,7 +18714,7 @@ fn bindgen_test_layout_XKeyboardControl() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XKeyboardControl>())).bell_pitch as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).bell_pitch) as usize - ptr as usize },
         8usize,
         concat!(
             "Offset of field: ",
@@ -27919,7 +18724,7 @@ fn bindgen_test_layout_XKeyboardControl() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XKeyboardControl>())).bell_duration as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).bell_duration) as usize - ptr as usize },
         12usize,
         concat!(
             "Offset of field: ",
@@ -27929,7 +18734,7 @@ fn bindgen_test_layout_XKeyboardControl() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XKeyboardControl>())).led as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).led) as usize - ptr as usize },
         16usize,
         concat!(
             "Offset of field: ",
@@ -27939,7 +18744,7 @@ fn bindgen_test_layout_XKeyboardControl() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XKeyboardControl>())).led_mode as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).led_mode) as usize - ptr as usize },
         20usize,
         concat!(
             "Offset of field: ",
@@ -27949,7 +18754,7 @@ fn bindgen_test_layout_XKeyboardControl() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XKeyboardControl>())).key as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).key) as usize - ptr as usize },
         24usize,
         concat!(
             "Offset of field: ",
@@ -27959,9 +18764,7 @@ fn bindgen_test_layout_XKeyboardControl() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::core::ptr::null::<XKeyboardControl>())).auto_repeat_mode as *const _ as usize
-        },
+        unsafe { ::core::ptr::addr_of!((*ptr).auto_repeat_mode) as usize - ptr as usize },
         28usize,
         concat!(
             "Offset of field: ",
@@ -27984,6 +18787,8 @@ pub struct XKeyboardState {
 }
 #[test]
 fn bindgen_test_layout_XKeyboardState() {
+    const UNINIT: ::core::mem::MaybeUninit<XKeyboardState> = ::core::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::core::mem::size_of::<XKeyboardState>(),
         64usize,
@@ -27995,9 +18800,7 @@ fn bindgen_test_layout_XKeyboardState() {
         concat!("Alignment of ", stringify!(XKeyboardState))
     );
     assert_eq!(
-        unsafe {
-            &(*(::core::ptr::null::<XKeyboardState>())).key_click_percent as *const _ as usize
-        },
+        unsafe { ::core::ptr::addr_of!((*ptr).key_click_percent) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -28007,7 +18810,7 @@ fn bindgen_test_layout_XKeyboardState() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XKeyboardState>())).bell_percent as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).bell_percent) as usize - ptr as usize },
         4usize,
         concat!(
             "Offset of field: ",
@@ -28017,7 +18820,7 @@ fn bindgen_test_layout_XKeyboardState() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XKeyboardState>())).bell_pitch as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).bell_pitch) as usize - ptr as usize },
         8usize,
         concat!(
             "Offset of field: ",
@@ -28027,7 +18830,7 @@ fn bindgen_test_layout_XKeyboardState() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XKeyboardState>())).bell_duration as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).bell_duration) as usize - ptr as usize },
         12usize,
         concat!(
             "Offset of field: ",
@@ -28037,7 +18840,7 @@ fn bindgen_test_layout_XKeyboardState() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XKeyboardState>())).led_mask as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).led_mask) as usize - ptr as usize },
         16usize,
         concat!(
             "Offset of field: ",
@@ -28047,9 +18850,7 @@ fn bindgen_test_layout_XKeyboardState() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::core::ptr::null::<XKeyboardState>())).global_auto_repeat as *const _ as usize
-        },
+        unsafe { ::core::ptr::addr_of!((*ptr).global_auto_repeat) as usize - ptr as usize },
         24usize,
         concat!(
             "Offset of field: ",
@@ -28059,7 +18860,7 @@ fn bindgen_test_layout_XKeyboardState() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XKeyboardState>())).auto_repeats as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).auto_repeats) as usize - ptr as usize },
         28usize,
         concat!(
             "Offset of field: ",
@@ -28078,6 +18879,8 @@ pub struct XTimeCoord {
 }
 #[test]
 fn bindgen_test_layout_XTimeCoord() {
+    const UNINIT: ::core::mem::MaybeUninit<XTimeCoord> = ::core::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::core::mem::size_of::<XTimeCoord>(),
         16usize,
@@ -28089,7 +18892,7 @@ fn bindgen_test_layout_XTimeCoord() {
         concat!("Alignment of ", stringify!(XTimeCoord))
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XTimeCoord>())).time as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).time) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -28099,7 +18902,7 @@ fn bindgen_test_layout_XTimeCoord() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XTimeCoord>())).x as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).x) as usize - ptr as usize },
         8usize,
         concat!(
             "Offset of field: ",
@@ -28109,7 +18912,7 @@ fn bindgen_test_layout_XTimeCoord() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XTimeCoord>())).y as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).y) as usize - ptr as usize },
         10usize,
         concat!(
             "Offset of field: ",
@@ -28127,6 +18930,8 @@ pub struct XModifierKeymap {
 }
 #[test]
 fn bindgen_test_layout_XModifierKeymap() {
+    const UNINIT: ::core::mem::MaybeUninit<XModifierKeymap> = ::core::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::core::mem::size_of::<XModifierKeymap>(),
         16usize,
@@ -28138,7 +18943,7 @@ fn bindgen_test_layout_XModifierKeymap() {
         concat!("Alignment of ", stringify!(XModifierKeymap))
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XModifierKeymap>())).max_keypermod as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).max_keypermod) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -28148,7 +18953,7 @@ fn bindgen_test_layout_XModifierKeymap() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XModifierKeymap>())).modifiermap as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).modifiermap) as usize - ptr as usize },
         8usize,
         concat!(
             "Offset of field: ",
@@ -28220,6 +19025,8 @@ pub struct _bindgen_ty_1 {
 }
 #[test]
 fn bindgen_test_layout__bindgen_ty_1() {
+    const UNINIT: ::core::mem::MaybeUninit<_bindgen_ty_1> = ::core::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::core::mem::size_of::<_bindgen_ty_1>(),
         296usize,
@@ -28231,7 +19038,7 @@ fn bindgen_test_layout__bindgen_ty_1() {
         concat!("Alignment of ", stringify!(_bindgen_ty_1))
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<_bindgen_ty_1>())).ext_data as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).ext_data) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -28241,7 +19048,7 @@ fn bindgen_test_layout__bindgen_ty_1() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<_bindgen_ty_1>())).private1 as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).private1) as usize - ptr as usize },
         8usize,
         concat!(
             "Offset of field: ",
@@ -28251,7 +19058,7 @@ fn bindgen_test_layout__bindgen_ty_1() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<_bindgen_ty_1>())).fd as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).fd) as usize - ptr as usize },
         16usize,
         concat!(
             "Offset of field: ",
@@ -28261,7 +19068,7 @@ fn bindgen_test_layout__bindgen_ty_1() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<_bindgen_ty_1>())).private2 as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).private2) as usize - ptr as usize },
         20usize,
         concat!(
             "Offset of field: ",
@@ -28271,9 +19078,7 @@ fn bindgen_test_layout__bindgen_ty_1() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::core::ptr::null::<_bindgen_ty_1>())).proto_major_version as *const _ as usize
-        },
+        unsafe { ::core::ptr::addr_of!((*ptr).proto_major_version) as usize - ptr as usize },
         24usize,
         concat!(
             "Offset of field: ",
@@ -28283,9 +19088,7 @@ fn bindgen_test_layout__bindgen_ty_1() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::core::ptr::null::<_bindgen_ty_1>())).proto_minor_version as *const _ as usize
-        },
+        unsafe { ::core::ptr::addr_of!((*ptr).proto_minor_version) as usize - ptr as usize },
         28usize,
         concat!(
             "Offset of field: ",
@@ -28295,7 +19098,7 @@ fn bindgen_test_layout__bindgen_ty_1() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<_bindgen_ty_1>())).vendor as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).vendor) as usize - ptr as usize },
         32usize,
         concat!(
             "Offset of field: ",
@@ -28305,7 +19108,7 @@ fn bindgen_test_layout__bindgen_ty_1() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<_bindgen_ty_1>())).private3 as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).private3) as usize - ptr as usize },
         40usize,
         concat!(
             "Offset of field: ",
@@ -28315,7 +19118,7 @@ fn bindgen_test_layout__bindgen_ty_1() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<_bindgen_ty_1>())).private4 as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).private4) as usize - ptr as usize },
         48usize,
         concat!(
             "Offset of field: ",
@@ -28325,7 +19128,7 @@ fn bindgen_test_layout__bindgen_ty_1() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<_bindgen_ty_1>())).private5 as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).private5) as usize - ptr as usize },
         56usize,
         concat!(
             "Offset of field: ",
@@ -28335,7 +19138,7 @@ fn bindgen_test_layout__bindgen_ty_1() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<_bindgen_ty_1>())).private6 as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).private6) as usize - ptr as usize },
         64usize,
         concat!(
             "Offset of field: ",
@@ -28345,7 +19148,7 @@ fn bindgen_test_layout__bindgen_ty_1() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<_bindgen_ty_1>())).resource_alloc as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).resource_alloc) as usize - ptr as usize },
         72usize,
         concat!(
             "Offset of field: ",
@@ -28355,7 +19158,7 @@ fn bindgen_test_layout__bindgen_ty_1() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<_bindgen_ty_1>())).byte_order as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).byte_order) as usize - ptr as usize },
         80usize,
         concat!(
             "Offset of field: ",
@@ -28365,7 +19168,7 @@ fn bindgen_test_layout__bindgen_ty_1() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<_bindgen_ty_1>())).bitmap_unit as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).bitmap_unit) as usize - ptr as usize },
         84usize,
         concat!(
             "Offset of field: ",
@@ -28375,7 +19178,7 @@ fn bindgen_test_layout__bindgen_ty_1() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<_bindgen_ty_1>())).bitmap_pad as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).bitmap_pad) as usize - ptr as usize },
         88usize,
         concat!(
             "Offset of field: ",
@@ -28385,7 +19188,7 @@ fn bindgen_test_layout__bindgen_ty_1() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<_bindgen_ty_1>())).bitmap_bit_order as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).bitmap_bit_order) as usize - ptr as usize },
         92usize,
         concat!(
             "Offset of field: ",
@@ -28395,7 +19198,7 @@ fn bindgen_test_layout__bindgen_ty_1() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<_bindgen_ty_1>())).nformats as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).nformats) as usize - ptr as usize },
         96usize,
         concat!(
             "Offset of field: ",
@@ -28405,7 +19208,7 @@ fn bindgen_test_layout__bindgen_ty_1() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<_bindgen_ty_1>())).pixmap_format as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).pixmap_format) as usize - ptr as usize },
         104usize,
         concat!(
             "Offset of field: ",
@@ -28415,7 +19218,7 @@ fn bindgen_test_layout__bindgen_ty_1() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<_bindgen_ty_1>())).private8 as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).private8) as usize - ptr as usize },
         112usize,
         concat!(
             "Offset of field: ",
@@ -28425,7 +19228,7 @@ fn bindgen_test_layout__bindgen_ty_1() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<_bindgen_ty_1>())).release as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).release) as usize - ptr as usize },
         116usize,
         concat!(
             "Offset of field: ",
@@ -28435,7 +19238,7 @@ fn bindgen_test_layout__bindgen_ty_1() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<_bindgen_ty_1>())).private9 as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).private9) as usize - ptr as usize },
         120usize,
         concat!(
             "Offset of field: ",
@@ -28445,7 +19248,7 @@ fn bindgen_test_layout__bindgen_ty_1() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<_bindgen_ty_1>())).private10 as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).private10) as usize - ptr as usize },
         128usize,
         concat!(
             "Offset of field: ",
@@ -28455,7 +19258,7 @@ fn bindgen_test_layout__bindgen_ty_1() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<_bindgen_ty_1>())).qlen as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).qlen) as usize - ptr as usize },
         136usize,
         concat!(
             "Offset of field: ",
@@ -28465,9 +19268,7 @@ fn bindgen_test_layout__bindgen_ty_1() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::core::ptr::null::<_bindgen_ty_1>())).last_request_read as *const _ as usize
-        },
+        unsafe { ::core::ptr::addr_of!((*ptr).last_request_read) as usize - ptr as usize },
         144usize,
         concat!(
             "Offset of field: ",
@@ -28477,7 +19278,7 @@ fn bindgen_test_layout__bindgen_ty_1() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<_bindgen_ty_1>())).request as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).request) as usize - ptr as usize },
         152usize,
         concat!(
             "Offset of field: ",
@@ -28487,7 +19288,7 @@ fn bindgen_test_layout__bindgen_ty_1() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<_bindgen_ty_1>())).private11 as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).private11) as usize - ptr as usize },
         160usize,
         concat!(
             "Offset of field: ",
@@ -28497,7 +19298,7 @@ fn bindgen_test_layout__bindgen_ty_1() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<_bindgen_ty_1>())).private12 as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).private12) as usize - ptr as usize },
         168usize,
         concat!(
             "Offset of field: ",
@@ -28507,7 +19308,7 @@ fn bindgen_test_layout__bindgen_ty_1() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<_bindgen_ty_1>())).private13 as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).private13) as usize - ptr as usize },
         176usize,
         concat!(
             "Offset of field: ",
@@ -28517,7 +19318,7 @@ fn bindgen_test_layout__bindgen_ty_1() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<_bindgen_ty_1>())).private14 as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).private14) as usize - ptr as usize },
         184usize,
         concat!(
             "Offset of field: ",
@@ -28527,7 +19328,7 @@ fn bindgen_test_layout__bindgen_ty_1() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<_bindgen_ty_1>())).max_request_size as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).max_request_size) as usize - ptr as usize },
         192usize,
         concat!(
             "Offset of field: ",
@@ -28537,7 +19338,7 @@ fn bindgen_test_layout__bindgen_ty_1() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<_bindgen_ty_1>())).db as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).db) as usize - ptr as usize },
         200usize,
         concat!(
             "Offset of field: ",
@@ -28547,7 +19348,7 @@ fn bindgen_test_layout__bindgen_ty_1() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<_bindgen_ty_1>())).private15 as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).private15) as usize - ptr as usize },
         208usize,
         concat!(
             "Offset of field: ",
@@ -28557,7 +19358,7 @@ fn bindgen_test_layout__bindgen_ty_1() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<_bindgen_ty_1>())).display_name as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).display_name) as usize - ptr as usize },
         216usize,
         concat!(
             "Offset of field: ",
@@ -28567,7 +19368,7 @@ fn bindgen_test_layout__bindgen_ty_1() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<_bindgen_ty_1>())).default_screen as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).default_screen) as usize - ptr as usize },
         224usize,
         concat!(
             "Offset of field: ",
@@ -28577,7 +19378,7 @@ fn bindgen_test_layout__bindgen_ty_1() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<_bindgen_ty_1>())).nscreens as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).nscreens) as usize - ptr as usize },
         228usize,
         concat!(
             "Offset of field: ",
@@ -28587,7 +19388,7 @@ fn bindgen_test_layout__bindgen_ty_1() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<_bindgen_ty_1>())).screens as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).screens) as usize - ptr as usize },
         232usize,
         concat!(
             "Offset of field: ",
@@ -28597,7 +19398,7 @@ fn bindgen_test_layout__bindgen_ty_1() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<_bindgen_ty_1>())).motion_buffer as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).motion_buffer) as usize - ptr as usize },
         240usize,
         concat!(
             "Offset of field: ",
@@ -28607,7 +19408,7 @@ fn bindgen_test_layout__bindgen_ty_1() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<_bindgen_ty_1>())).private16 as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).private16) as usize - ptr as usize },
         248usize,
         concat!(
             "Offset of field: ",
@@ -28617,7 +19418,7 @@ fn bindgen_test_layout__bindgen_ty_1() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<_bindgen_ty_1>())).min_keycode as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).min_keycode) as usize - ptr as usize },
         256usize,
         concat!(
             "Offset of field: ",
@@ -28627,7 +19428,7 @@ fn bindgen_test_layout__bindgen_ty_1() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<_bindgen_ty_1>())).max_keycode as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).max_keycode) as usize - ptr as usize },
         260usize,
         concat!(
             "Offset of field: ",
@@ -28637,7 +19438,7 @@ fn bindgen_test_layout__bindgen_ty_1() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<_bindgen_ty_1>())).private17 as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).private17) as usize - ptr as usize },
         264usize,
         concat!(
             "Offset of field: ",
@@ -28647,7 +19448,7 @@ fn bindgen_test_layout__bindgen_ty_1() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<_bindgen_ty_1>())).private18 as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).private18) as usize - ptr as usize },
         272usize,
         concat!(
             "Offset of field: ",
@@ -28657,7 +19458,7 @@ fn bindgen_test_layout__bindgen_ty_1() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<_bindgen_ty_1>())).private19 as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).private19) as usize - ptr as usize },
         280usize,
         concat!(
             "Offset of field: ",
@@ -28667,7 +19468,7 @@ fn bindgen_test_layout__bindgen_ty_1() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<_bindgen_ty_1>())).xdefaults as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).xdefaults) as usize - ptr as usize },
         288usize,
         concat!(
             "Offset of field: ",
@@ -28699,6 +19500,8 @@ pub struct XKeyEvent {
 }
 #[test]
 fn bindgen_test_layout_XKeyEvent() {
+    const UNINIT: ::core::mem::MaybeUninit<XKeyEvent> = ::core::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::core::mem::size_of::<XKeyEvent>(),
         96usize,
@@ -28710,7 +19513,7 @@ fn bindgen_test_layout_XKeyEvent() {
         concat!("Alignment of ", stringify!(XKeyEvent))
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XKeyEvent>())).type_ as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -28720,7 +19523,7 @@ fn bindgen_test_layout_XKeyEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XKeyEvent>())).serial as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).serial) as usize - ptr as usize },
         8usize,
         concat!(
             "Offset of field: ",
@@ -28730,7 +19533,7 @@ fn bindgen_test_layout_XKeyEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XKeyEvent>())).send_event as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).send_event) as usize - ptr as usize },
         16usize,
         concat!(
             "Offset of field: ",
@@ -28740,7 +19543,7 @@ fn bindgen_test_layout_XKeyEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XKeyEvent>())).display as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).display) as usize - ptr as usize },
         24usize,
         concat!(
             "Offset of field: ",
@@ -28750,7 +19553,7 @@ fn bindgen_test_layout_XKeyEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XKeyEvent>())).window as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).window) as usize - ptr as usize },
         32usize,
         concat!(
             "Offset of field: ",
@@ -28760,7 +19563,7 @@ fn bindgen_test_layout_XKeyEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XKeyEvent>())).root as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).root) as usize - ptr as usize },
         40usize,
         concat!(
             "Offset of field: ",
@@ -28770,7 +19573,7 @@ fn bindgen_test_layout_XKeyEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XKeyEvent>())).subwindow as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).subwindow) as usize - ptr as usize },
         48usize,
         concat!(
             "Offset of field: ",
@@ -28780,7 +19583,7 @@ fn bindgen_test_layout_XKeyEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XKeyEvent>())).time as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).time) as usize - ptr as usize },
         56usize,
         concat!(
             "Offset of field: ",
@@ -28790,7 +19593,7 @@ fn bindgen_test_layout_XKeyEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XKeyEvent>())).x as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).x) as usize - ptr as usize },
         64usize,
         concat!(
             "Offset of field: ",
@@ -28800,7 +19603,7 @@ fn bindgen_test_layout_XKeyEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XKeyEvent>())).y as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).y) as usize - ptr as usize },
         68usize,
         concat!(
             "Offset of field: ",
@@ -28810,7 +19613,7 @@ fn bindgen_test_layout_XKeyEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XKeyEvent>())).x_root as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).x_root) as usize - ptr as usize },
         72usize,
         concat!(
             "Offset of field: ",
@@ -28820,7 +19623,7 @@ fn bindgen_test_layout_XKeyEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XKeyEvent>())).y_root as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).y_root) as usize - ptr as usize },
         76usize,
         concat!(
             "Offset of field: ",
@@ -28830,7 +19633,7 @@ fn bindgen_test_layout_XKeyEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XKeyEvent>())).state as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).state) as usize - ptr as usize },
         80usize,
         concat!(
             "Offset of field: ",
@@ -28840,7 +19643,7 @@ fn bindgen_test_layout_XKeyEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XKeyEvent>())).keycode as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).keycode) as usize - ptr as usize },
         84usize,
         concat!(
             "Offset of field: ",
@@ -28850,7 +19653,7 @@ fn bindgen_test_layout_XKeyEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XKeyEvent>())).same_screen as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).same_screen) as usize - ptr as usize },
         88usize,
         concat!(
             "Offset of field: ",
@@ -28883,6 +19686,8 @@ pub struct XButtonEvent {
 }
 #[test]
 fn bindgen_test_layout_XButtonEvent() {
+    const UNINIT: ::core::mem::MaybeUninit<XButtonEvent> = ::core::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::core::mem::size_of::<XButtonEvent>(),
         96usize,
@@ -28894,7 +19699,7 @@ fn bindgen_test_layout_XButtonEvent() {
         concat!("Alignment of ", stringify!(XButtonEvent))
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XButtonEvent>())).type_ as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -28904,7 +19709,7 @@ fn bindgen_test_layout_XButtonEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XButtonEvent>())).serial as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).serial) as usize - ptr as usize },
         8usize,
         concat!(
             "Offset of field: ",
@@ -28914,7 +19719,7 @@ fn bindgen_test_layout_XButtonEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XButtonEvent>())).send_event as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).send_event) as usize - ptr as usize },
         16usize,
         concat!(
             "Offset of field: ",
@@ -28924,7 +19729,7 @@ fn bindgen_test_layout_XButtonEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XButtonEvent>())).display as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).display) as usize - ptr as usize },
         24usize,
         concat!(
             "Offset of field: ",
@@ -28934,7 +19739,7 @@ fn bindgen_test_layout_XButtonEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XButtonEvent>())).window as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).window) as usize - ptr as usize },
         32usize,
         concat!(
             "Offset of field: ",
@@ -28944,7 +19749,7 @@ fn bindgen_test_layout_XButtonEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XButtonEvent>())).root as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).root) as usize - ptr as usize },
         40usize,
         concat!(
             "Offset of field: ",
@@ -28954,7 +19759,7 @@ fn bindgen_test_layout_XButtonEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XButtonEvent>())).subwindow as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).subwindow) as usize - ptr as usize },
         48usize,
         concat!(
             "Offset of field: ",
@@ -28964,7 +19769,7 @@ fn bindgen_test_layout_XButtonEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XButtonEvent>())).time as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).time) as usize - ptr as usize },
         56usize,
         concat!(
             "Offset of field: ",
@@ -28974,7 +19779,7 @@ fn bindgen_test_layout_XButtonEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XButtonEvent>())).x as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).x) as usize - ptr as usize },
         64usize,
         concat!(
             "Offset of field: ",
@@ -28984,7 +19789,7 @@ fn bindgen_test_layout_XButtonEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XButtonEvent>())).y as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).y) as usize - ptr as usize },
         68usize,
         concat!(
             "Offset of field: ",
@@ -28994,7 +19799,7 @@ fn bindgen_test_layout_XButtonEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XButtonEvent>())).x_root as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).x_root) as usize - ptr as usize },
         72usize,
         concat!(
             "Offset of field: ",
@@ -29004,7 +19809,7 @@ fn bindgen_test_layout_XButtonEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XButtonEvent>())).y_root as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).y_root) as usize - ptr as usize },
         76usize,
         concat!(
             "Offset of field: ",
@@ -29014,7 +19819,7 @@ fn bindgen_test_layout_XButtonEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XButtonEvent>())).state as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).state) as usize - ptr as usize },
         80usize,
         concat!(
             "Offset of field: ",
@@ -29024,7 +19829,7 @@ fn bindgen_test_layout_XButtonEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XButtonEvent>())).button as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).button) as usize - ptr as usize },
         84usize,
         concat!(
             "Offset of field: ",
@@ -29034,7 +19839,7 @@ fn bindgen_test_layout_XButtonEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XButtonEvent>())).same_screen as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).same_screen) as usize - ptr as usize },
         88usize,
         concat!(
             "Offset of field: ",
@@ -29067,6 +19872,8 @@ pub struct XMotionEvent {
 }
 #[test]
 fn bindgen_test_layout_XMotionEvent() {
+    const UNINIT: ::core::mem::MaybeUninit<XMotionEvent> = ::core::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::core::mem::size_of::<XMotionEvent>(),
         96usize,
@@ -29078,7 +19885,7 @@ fn bindgen_test_layout_XMotionEvent() {
         concat!("Alignment of ", stringify!(XMotionEvent))
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XMotionEvent>())).type_ as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -29088,7 +19895,7 @@ fn bindgen_test_layout_XMotionEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XMotionEvent>())).serial as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).serial) as usize - ptr as usize },
         8usize,
         concat!(
             "Offset of field: ",
@@ -29098,7 +19905,7 @@ fn bindgen_test_layout_XMotionEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XMotionEvent>())).send_event as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).send_event) as usize - ptr as usize },
         16usize,
         concat!(
             "Offset of field: ",
@@ -29108,7 +19915,7 @@ fn bindgen_test_layout_XMotionEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XMotionEvent>())).display as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).display) as usize - ptr as usize },
         24usize,
         concat!(
             "Offset of field: ",
@@ -29118,7 +19925,7 @@ fn bindgen_test_layout_XMotionEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XMotionEvent>())).window as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).window) as usize - ptr as usize },
         32usize,
         concat!(
             "Offset of field: ",
@@ -29128,7 +19935,7 @@ fn bindgen_test_layout_XMotionEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XMotionEvent>())).root as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).root) as usize - ptr as usize },
         40usize,
         concat!(
             "Offset of field: ",
@@ -29138,7 +19945,7 @@ fn bindgen_test_layout_XMotionEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XMotionEvent>())).subwindow as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).subwindow) as usize - ptr as usize },
         48usize,
         concat!(
             "Offset of field: ",
@@ -29148,7 +19955,7 @@ fn bindgen_test_layout_XMotionEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XMotionEvent>())).time as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).time) as usize - ptr as usize },
         56usize,
         concat!(
             "Offset of field: ",
@@ -29158,7 +19965,7 @@ fn bindgen_test_layout_XMotionEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XMotionEvent>())).x as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).x) as usize - ptr as usize },
         64usize,
         concat!(
             "Offset of field: ",
@@ -29168,7 +19975,7 @@ fn bindgen_test_layout_XMotionEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XMotionEvent>())).y as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).y) as usize - ptr as usize },
         68usize,
         concat!(
             "Offset of field: ",
@@ -29178,7 +19985,7 @@ fn bindgen_test_layout_XMotionEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XMotionEvent>())).x_root as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).x_root) as usize - ptr as usize },
         72usize,
         concat!(
             "Offset of field: ",
@@ -29188,7 +19995,7 @@ fn bindgen_test_layout_XMotionEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XMotionEvent>())).y_root as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).y_root) as usize - ptr as usize },
         76usize,
         concat!(
             "Offset of field: ",
@@ -29198,7 +20005,7 @@ fn bindgen_test_layout_XMotionEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XMotionEvent>())).state as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).state) as usize - ptr as usize },
         80usize,
         concat!(
             "Offset of field: ",
@@ -29208,7 +20015,7 @@ fn bindgen_test_layout_XMotionEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XMotionEvent>())).is_hint as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).is_hint) as usize - ptr as usize },
         84usize,
         concat!(
             "Offset of field: ",
@@ -29218,7 +20025,7 @@ fn bindgen_test_layout_XMotionEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XMotionEvent>())).same_screen as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).same_screen) as usize - ptr as usize },
         88usize,
         concat!(
             "Offset of field: ",
@@ -29252,6 +20059,8 @@ pub struct XCrossingEvent {
 }
 #[test]
 fn bindgen_test_layout_XCrossingEvent() {
+    const UNINIT: ::core::mem::MaybeUninit<XCrossingEvent> = ::core::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::core::mem::size_of::<XCrossingEvent>(),
         104usize,
@@ -29263,7 +20072,7 @@ fn bindgen_test_layout_XCrossingEvent() {
         concat!("Alignment of ", stringify!(XCrossingEvent))
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XCrossingEvent>())).type_ as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -29273,7 +20082,7 @@ fn bindgen_test_layout_XCrossingEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XCrossingEvent>())).serial as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).serial) as usize - ptr as usize },
         8usize,
         concat!(
             "Offset of field: ",
@@ -29283,7 +20092,7 @@ fn bindgen_test_layout_XCrossingEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XCrossingEvent>())).send_event as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).send_event) as usize - ptr as usize },
         16usize,
         concat!(
             "Offset of field: ",
@@ -29293,7 +20102,7 @@ fn bindgen_test_layout_XCrossingEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XCrossingEvent>())).display as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).display) as usize - ptr as usize },
         24usize,
         concat!(
             "Offset of field: ",
@@ -29303,7 +20112,7 @@ fn bindgen_test_layout_XCrossingEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XCrossingEvent>())).window as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).window) as usize - ptr as usize },
         32usize,
         concat!(
             "Offset of field: ",
@@ -29313,7 +20122,7 @@ fn bindgen_test_layout_XCrossingEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XCrossingEvent>())).root as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).root) as usize - ptr as usize },
         40usize,
         concat!(
             "Offset of field: ",
@@ -29323,7 +20132,7 @@ fn bindgen_test_layout_XCrossingEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XCrossingEvent>())).subwindow as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).subwindow) as usize - ptr as usize },
         48usize,
         concat!(
             "Offset of field: ",
@@ -29333,7 +20142,7 @@ fn bindgen_test_layout_XCrossingEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XCrossingEvent>())).time as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).time) as usize - ptr as usize },
         56usize,
         concat!(
             "Offset of field: ",
@@ -29343,7 +20152,7 @@ fn bindgen_test_layout_XCrossingEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XCrossingEvent>())).x as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).x) as usize - ptr as usize },
         64usize,
         concat!(
             "Offset of field: ",
@@ -29353,7 +20162,7 @@ fn bindgen_test_layout_XCrossingEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XCrossingEvent>())).y as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).y) as usize - ptr as usize },
         68usize,
         concat!(
             "Offset of field: ",
@@ -29363,7 +20172,7 @@ fn bindgen_test_layout_XCrossingEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XCrossingEvent>())).x_root as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).x_root) as usize - ptr as usize },
         72usize,
         concat!(
             "Offset of field: ",
@@ -29373,7 +20182,7 @@ fn bindgen_test_layout_XCrossingEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XCrossingEvent>())).y_root as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).y_root) as usize - ptr as usize },
         76usize,
         concat!(
             "Offset of field: ",
@@ -29383,7 +20192,7 @@ fn bindgen_test_layout_XCrossingEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XCrossingEvent>())).mode as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).mode) as usize - ptr as usize },
         80usize,
         concat!(
             "Offset of field: ",
@@ -29393,7 +20202,7 @@ fn bindgen_test_layout_XCrossingEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XCrossingEvent>())).detail as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).detail) as usize - ptr as usize },
         84usize,
         concat!(
             "Offset of field: ",
@@ -29403,7 +20212,7 @@ fn bindgen_test_layout_XCrossingEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XCrossingEvent>())).same_screen as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).same_screen) as usize - ptr as usize },
         88usize,
         concat!(
             "Offset of field: ",
@@ -29413,7 +20222,7 @@ fn bindgen_test_layout_XCrossingEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XCrossingEvent>())).focus as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).focus) as usize - ptr as usize },
         92usize,
         concat!(
             "Offset of field: ",
@@ -29423,7 +20232,7 @@ fn bindgen_test_layout_XCrossingEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XCrossingEvent>())).state as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).state) as usize - ptr as usize },
         96usize,
         concat!(
             "Offset of field: ",
@@ -29448,6 +20257,8 @@ pub struct XFocusChangeEvent {
 }
 #[test]
 fn bindgen_test_layout_XFocusChangeEvent() {
+    const UNINIT: ::core::mem::MaybeUninit<XFocusChangeEvent> = ::core::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::core::mem::size_of::<XFocusChangeEvent>(),
         48usize,
@@ -29459,7 +20270,7 @@ fn bindgen_test_layout_XFocusChangeEvent() {
         concat!("Alignment of ", stringify!(XFocusChangeEvent))
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XFocusChangeEvent>())).type_ as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -29469,7 +20280,7 @@ fn bindgen_test_layout_XFocusChangeEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XFocusChangeEvent>())).serial as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).serial) as usize - ptr as usize },
         8usize,
         concat!(
             "Offset of field: ",
@@ -29479,7 +20290,7 @@ fn bindgen_test_layout_XFocusChangeEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XFocusChangeEvent>())).send_event as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).send_event) as usize - ptr as usize },
         16usize,
         concat!(
             "Offset of field: ",
@@ -29489,7 +20300,7 @@ fn bindgen_test_layout_XFocusChangeEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XFocusChangeEvent>())).display as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).display) as usize - ptr as usize },
         24usize,
         concat!(
             "Offset of field: ",
@@ -29499,7 +20310,7 @@ fn bindgen_test_layout_XFocusChangeEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XFocusChangeEvent>())).window as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).window) as usize - ptr as usize },
         32usize,
         concat!(
             "Offset of field: ",
@@ -29509,7 +20320,7 @@ fn bindgen_test_layout_XFocusChangeEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XFocusChangeEvent>())).mode as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).mode) as usize - ptr as usize },
         40usize,
         concat!(
             "Offset of field: ",
@@ -29519,7 +20330,7 @@ fn bindgen_test_layout_XFocusChangeEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XFocusChangeEvent>())).detail as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).detail) as usize - ptr as usize },
         44usize,
         concat!(
             "Offset of field: ",
@@ -29543,6 +20354,8 @@ pub struct XKeymapEvent {
 }
 #[test]
 fn bindgen_test_layout_XKeymapEvent() {
+    const UNINIT: ::core::mem::MaybeUninit<XKeymapEvent> = ::core::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::core::mem::size_of::<XKeymapEvent>(),
         72usize,
@@ -29554,7 +20367,7 @@ fn bindgen_test_layout_XKeymapEvent() {
         concat!("Alignment of ", stringify!(XKeymapEvent))
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XKeymapEvent>())).type_ as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -29564,7 +20377,7 @@ fn bindgen_test_layout_XKeymapEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XKeymapEvent>())).serial as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).serial) as usize - ptr as usize },
         8usize,
         concat!(
             "Offset of field: ",
@@ -29574,7 +20387,7 @@ fn bindgen_test_layout_XKeymapEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XKeymapEvent>())).send_event as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).send_event) as usize - ptr as usize },
         16usize,
         concat!(
             "Offset of field: ",
@@ -29584,7 +20397,7 @@ fn bindgen_test_layout_XKeymapEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XKeymapEvent>())).display as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).display) as usize - ptr as usize },
         24usize,
         concat!(
             "Offset of field: ",
@@ -29594,7 +20407,7 @@ fn bindgen_test_layout_XKeymapEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XKeymapEvent>())).window as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).window) as usize - ptr as usize },
         32usize,
         concat!(
             "Offset of field: ",
@@ -29604,7 +20417,7 @@ fn bindgen_test_layout_XKeymapEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XKeymapEvent>())).key_vector as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).key_vector) as usize - ptr as usize },
         40usize,
         concat!(
             "Offset of field: ",
@@ -29630,6 +20443,8 @@ pub struct XExposeEvent {
 }
 #[test]
 fn bindgen_test_layout_XExposeEvent() {
+    const UNINIT: ::core::mem::MaybeUninit<XExposeEvent> = ::core::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::core::mem::size_of::<XExposeEvent>(),
         64usize,
@@ -29641,7 +20456,7 @@ fn bindgen_test_layout_XExposeEvent() {
         concat!("Alignment of ", stringify!(XExposeEvent))
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XExposeEvent>())).type_ as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -29651,7 +20466,7 @@ fn bindgen_test_layout_XExposeEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XExposeEvent>())).serial as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).serial) as usize - ptr as usize },
         8usize,
         concat!(
             "Offset of field: ",
@@ -29661,7 +20476,7 @@ fn bindgen_test_layout_XExposeEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XExposeEvent>())).send_event as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).send_event) as usize - ptr as usize },
         16usize,
         concat!(
             "Offset of field: ",
@@ -29671,7 +20486,7 @@ fn bindgen_test_layout_XExposeEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XExposeEvent>())).display as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).display) as usize - ptr as usize },
         24usize,
         concat!(
             "Offset of field: ",
@@ -29681,7 +20496,7 @@ fn bindgen_test_layout_XExposeEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XExposeEvent>())).window as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).window) as usize - ptr as usize },
         32usize,
         concat!(
             "Offset of field: ",
@@ -29691,7 +20506,7 @@ fn bindgen_test_layout_XExposeEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XExposeEvent>())).x as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).x) as usize - ptr as usize },
         40usize,
         concat!(
             "Offset of field: ",
@@ -29701,7 +20516,7 @@ fn bindgen_test_layout_XExposeEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XExposeEvent>())).y as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).y) as usize - ptr as usize },
         44usize,
         concat!(
             "Offset of field: ",
@@ -29711,7 +20526,7 @@ fn bindgen_test_layout_XExposeEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XExposeEvent>())).width as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).width) as usize - ptr as usize },
         48usize,
         concat!(
             "Offset of field: ",
@@ -29721,7 +20536,7 @@ fn bindgen_test_layout_XExposeEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XExposeEvent>())).height as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).height) as usize - ptr as usize },
         52usize,
         concat!(
             "Offset of field: ",
@@ -29731,7 +20546,7 @@ fn bindgen_test_layout_XExposeEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XExposeEvent>())).count as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).count) as usize - ptr as usize },
         56usize,
         concat!(
             "Offset of field: ",
@@ -29759,6 +20574,9 @@ pub struct XGraphicsExposeEvent {
 }
 #[test]
 fn bindgen_test_layout_XGraphicsExposeEvent() {
+    const UNINIT: ::core::mem::MaybeUninit<XGraphicsExposeEvent> =
+        ::core::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::core::mem::size_of::<XGraphicsExposeEvent>(),
         72usize,
@@ -29770,7 +20588,7 @@ fn bindgen_test_layout_XGraphicsExposeEvent() {
         concat!("Alignment of ", stringify!(XGraphicsExposeEvent))
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XGraphicsExposeEvent>())).type_ as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -29780,7 +20598,7 @@ fn bindgen_test_layout_XGraphicsExposeEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XGraphicsExposeEvent>())).serial as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).serial) as usize - ptr as usize },
         8usize,
         concat!(
             "Offset of field: ",
@@ -29790,9 +20608,7 @@ fn bindgen_test_layout_XGraphicsExposeEvent() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::core::ptr::null::<XGraphicsExposeEvent>())).send_event as *const _ as usize
-        },
+        unsafe { ::core::ptr::addr_of!((*ptr).send_event) as usize - ptr as usize },
         16usize,
         concat!(
             "Offset of field: ",
@@ -29802,7 +20618,7 @@ fn bindgen_test_layout_XGraphicsExposeEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XGraphicsExposeEvent>())).display as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).display) as usize - ptr as usize },
         24usize,
         concat!(
             "Offset of field: ",
@@ -29812,7 +20628,7 @@ fn bindgen_test_layout_XGraphicsExposeEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XGraphicsExposeEvent>())).drawable as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).drawable) as usize - ptr as usize },
         32usize,
         concat!(
             "Offset of field: ",
@@ -29822,7 +20638,7 @@ fn bindgen_test_layout_XGraphicsExposeEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XGraphicsExposeEvent>())).x as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).x) as usize - ptr as usize },
         40usize,
         concat!(
             "Offset of field: ",
@@ -29832,7 +20648,7 @@ fn bindgen_test_layout_XGraphicsExposeEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XGraphicsExposeEvent>())).y as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).y) as usize - ptr as usize },
         44usize,
         concat!(
             "Offset of field: ",
@@ -29842,7 +20658,7 @@ fn bindgen_test_layout_XGraphicsExposeEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XGraphicsExposeEvent>())).width as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).width) as usize - ptr as usize },
         48usize,
         concat!(
             "Offset of field: ",
@@ -29852,7 +20668,7 @@ fn bindgen_test_layout_XGraphicsExposeEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XGraphicsExposeEvent>())).height as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).height) as usize - ptr as usize },
         52usize,
         concat!(
             "Offset of field: ",
@@ -29862,7 +20678,7 @@ fn bindgen_test_layout_XGraphicsExposeEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XGraphicsExposeEvent>())).count as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).count) as usize - ptr as usize },
         56usize,
         concat!(
             "Offset of field: ",
@@ -29872,9 +20688,7 @@ fn bindgen_test_layout_XGraphicsExposeEvent() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::core::ptr::null::<XGraphicsExposeEvent>())).major_code as *const _ as usize
-        },
+        unsafe { ::core::ptr::addr_of!((*ptr).major_code) as usize - ptr as usize },
         60usize,
         concat!(
             "Offset of field: ",
@@ -29884,9 +20698,7 @@ fn bindgen_test_layout_XGraphicsExposeEvent() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::core::ptr::null::<XGraphicsExposeEvent>())).minor_code as *const _ as usize
-        },
+        unsafe { ::core::ptr::addr_of!((*ptr).minor_code) as usize - ptr as usize },
         64usize,
         concat!(
             "Offset of field: ",
@@ -29909,6 +20721,8 @@ pub struct XNoExposeEvent {
 }
 #[test]
 fn bindgen_test_layout_XNoExposeEvent() {
+    const UNINIT: ::core::mem::MaybeUninit<XNoExposeEvent> = ::core::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::core::mem::size_of::<XNoExposeEvent>(),
         48usize,
@@ -29920,7 +20734,7 @@ fn bindgen_test_layout_XNoExposeEvent() {
         concat!("Alignment of ", stringify!(XNoExposeEvent))
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XNoExposeEvent>())).type_ as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -29930,7 +20744,7 @@ fn bindgen_test_layout_XNoExposeEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XNoExposeEvent>())).serial as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).serial) as usize - ptr as usize },
         8usize,
         concat!(
             "Offset of field: ",
@@ -29940,7 +20754,7 @@ fn bindgen_test_layout_XNoExposeEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XNoExposeEvent>())).send_event as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).send_event) as usize - ptr as usize },
         16usize,
         concat!(
             "Offset of field: ",
@@ -29950,7 +20764,7 @@ fn bindgen_test_layout_XNoExposeEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XNoExposeEvent>())).display as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).display) as usize - ptr as usize },
         24usize,
         concat!(
             "Offset of field: ",
@@ -29960,7 +20774,7 @@ fn bindgen_test_layout_XNoExposeEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XNoExposeEvent>())).drawable as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).drawable) as usize - ptr as usize },
         32usize,
         concat!(
             "Offset of field: ",
@@ -29970,7 +20784,7 @@ fn bindgen_test_layout_XNoExposeEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XNoExposeEvent>())).major_code as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).major_code) as usize - ptr as usize },
         40usize,
         concat!(
             "Offset of field: ",
@@ -29980,7 +20794,7 @@ fn bindgen_test_layout_XNoExposeEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XNoExposeEvent>())).minor_code as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).minor_code) as usize - ptr as usize },
         44usize,
         concat!(
             "Offset of field: ",
@@ -30002,6 +20816,8 @@ pub struct XVisibilityEvent {
 }
 #[test]
 fn bindgen_test_layout_XVisibilityEvent() {
+    const UNINIT: ::core::mem::MaybeUninit<XVisibilityEvent> = ::core::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::core::mem::size_of::<XVisibilityEvent>(),
         48usize,
@@ -30013,7 +20829,7 @@ fn bindgen_test_layout_XVisibilityEvent() {
         concat!("Alignment of ", stringify!(XVisibilityEvent))
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XVisibilityEvent>())).type_ as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -30023,7 +20839,7 @@ fn bindgen_test_layout_XVisibilityEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XVisibilityEvent>())).serial as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).serial) as usize - ptr as usize },
         8usize,
         concat!(
             "Offset of field: ",
@@ -30033,7 +20849,7 @@ fn bindgen_test_layout_XVisibilityEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XVisibilityEvent>())).send_event as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).send_event) as usize - ptr as usize },
         16usize,
         concat!(
             "Offset of field: ",
@@ -30043,7 +20859,7 @@ fn bindgen_test_layout_XVisibilityEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XVisibilityEvent>())).display as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).display) as usize - ptr as usize },
         24usize,
         concat!(
             "Offset of field: ",
@@ -30053,7 +20869,7 @@ fn bindgen_test_layout_XVisibilityEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XVisibilityEvent>())).window as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).window) as usize - ptr as usize },
         32usize,
         concat!(
             "Offset of field: ",
@@ -30063,7 +20879,7 @@ fn bindgen_test_layout_XVisibilityEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XVisibilityEvent>())).state as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).state) as usize - ptr as usize },
         40usize,
         concat!(
             "Offset of field: ",
@@ -30091,6 +20907,8 @@ pub struct XCreateWindowEvent {
 }
 #[test]
 fn bindgen_test_layout_XCreateWindowEvent() {
+    const UNINIT: ::core::mem::MaybeUninit<XCreateWindowEvent> = ::core::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::core::mem::size_of::<XCreateWindowEvent>(),
         72usize,
@@ -30102,7 +20920,7 @@ fn bindgen_test_layout_XCreateWindowEvent() {
         concat!("Alignment of ", stringify!(XCreateWindowEvent))
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XCreateWindowEvent>())).type_ as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -30112,7 +20930,7 @@ fn bindgen_test_layout_XCreateWindowEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XCreateWindowEvent>())).serial as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).serial) as usize - ptr as usize },
         8usize,
         concat!(
             "Offset of field: ",
@@ -30122,7 +20940,7 @@ fn bindgen_test_layout_XCreateWindowEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XCreateWindowEvent>())).send_event as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).send_event) as usize - ptr as usize },
         16usize,
         concat!(
             "Offset of field: ",
@@ -30132,7 +20950,7 @@ fn bindgen_test_layout_XCreateWindowEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XCreateWindowEvent>())).display as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).display) as usize - ptr as usize },
         24usize,
         concat!(
             "Offset of field: ",
@@ -30142,7 +20960,7 @@ fn bindgen_test_layout_XCreateWindowEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XCreateWindowEvent>())).parent as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).parent) as usize - ptr as usize },
         32usize,
         concat!(
             "Offset of field: ",
@@ -30152,7 +20970,7 @@ fn bindgen_test_layout_XCreateWindowEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XCreateWindowEvent>())).window as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).window) as usize - ptr as usize },
         40usize,
         concat!(
             "Offset of field: ",
@@ -30162,7 +20980,7 @@ fn bindgen_test_layout_XCreateWindowEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XCreateWindowEvent>())).x as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).x) as usize - ptr as usize },
         48usize,
         concat!(
             "Offset of field: ",
@@ -30172,7 +20990,7 @@ fn bindgen_test_layout_XCreateWindowEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XCreateWindowEvent>())).y as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).y) as usize - ptr as usize },
         52usize,
         concat!(
             "Offset of field: ",
@@ -30182,7 +21000,7 @@ fn bindgen_test_layout_XCreateWindowEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XCreateWindowEvent>())).width as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).width) as usize - ptr as usize },
         56usize,
         concat!(
             "Offset of field: ",
@@ -30192,7 +21010,7 @@ fn bindgen_test_layout_XCreateWindowEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XCreateWindowEvent>())).height as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).height) as usize - ptr as usize },
         60usize,
         concat!(
             "Offset of field: ",
@@ -30202,9 +21020,7 @@ fn bindgen_test_layout_XCreateWindowEvent() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::core::ptr::null::<XCreateWindowEvent>())).border_width as *const _ as usize
-        },
+        unsafe { ::core::ptr::addr_of!((*ptr).border_width) as usize - ptr as usize },
         64usize,
         concat!(
             "Offset of field: ",
@@ -30214,9 +21030,7 @@ fn bindgen_test_layout_XCreateWindowEvent() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::core::ptr::null::<XCreateWindowEvent>())).override_redirect as *const _ as usize
-        },
+        unsafe { ::core::ptr::addr_of!((*ptr).override_redirect) as usize - ptr as usize },
         68usize,
         concat!(
             "Offset of field: ",
@@ -30238,6 +21052,9 @@ pub struct XDestroyWindowEvent {
 }
 #[test]
 fn bindgen_test_layout_XDestroyWindowEvent() {
+    const UNINIT: ::core::mem::MaybeUninit<XDestroyWindowEvent> =
+        ::core::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::core::mem::size_of::<XDestroyWindowEvent>(),
         48usize,
@@ -30249,7 +21066,7 @@ fn bindgen_test_layout_XDestroyWindowEvent() {
         concat!("Alignment of ", stringify!(XDestroyWindowEvent))
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XDestroyWindowEvent>())).type_ as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -30259,7 +21076,7 @@ fn bindgen_test_layout_XDestroyWindowEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XDestroyWindowEvent>())).serial as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).serial) as usize - ptr as usize },
         8usize,
         concat!(
             "Offset of field: ",
@@ -30269,7 +21086,7 @@ fn bindgen_test_layout_XDestroyWindowEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XDestroyWindowEvent>())).send_event as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).send_event) as usize - ptr as usize },
         16usize,
         concat!(
             "Offset of field: ",
@@ -30279,7 +21096,7 @@ fn bindgen_test_layout_XDestroyWindowEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XDestroyWindowEvent>())).display as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).display) as usize - ptr as usize },
         24usize,
         concat!(
             "Offset of field: ",
@@ -30289,7 +21106,7 @@ fn bindgen_test_layout_XDestroyWindowEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XDestroyWindowEvent>())).event as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).event) as usize - ptr as usize },
         32usize,
         concat!(
             "Offset of field: ",
@@ -30299,7 +21116,7 @@ fn bindgen_test_layout_XDestroyWindowEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XDestroyWindowEvent>())).window as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).window) as usize - ptr as usize },
         40usize,
         concat!(
             "Offset of field: ",
@@ -30322,6 +21139,8 @@ pub struct XUnmapEvent {
 }
 #[test]
 fn bindgen_test_layout_XUnmapEvent() {
+    const UNINIT: ::core::mem::MaybeUninit<XUnmapEvent> = ::core::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::core::mem::size_of::<XUnmapEvent>(),
         56usize,
@@ -30333,7 +21152,7 @@ fn bindgen_test_layout_XUnmapEvent() {
         concat!("Alignment of ", stringify!(XUnmapEvent))
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XUnmapEvent>())).type_ as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -30343,7 +21162,7 @@ fn bindgen_test_layout_XUnmapEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XUnmapEvent>())).serial as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).serial) as usize - ptr as usize },
         8usize,
         concat!(
             "Offset of field: ",
@@ -30353,7 +21172,7 @@ fn bindgen_test_layout_XUnmapEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XUnmapEvent>())).send_event as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).send_event) as usize - ptr as usize },
         16usize,
         concat!(
             "Offset of field: ",
@@ -30363,7 +21182,7 @@ fn bindgen_test_layout_XUnmapEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XUnmapEvent>())).display as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).display) as usize - ptr as usize },
         24usize,
         concat!(
             "Offset of field: ",
@@ -30373,7 +21192,7 @@ fn bindgen_test_layout_XUnmapEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XUnmapEvent>())).event as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).event) as usize - ptr as usize },
         32usize,
         concat!(
             "Offset of field: ",
@@ -30383,7 +21202,7 @@ fn bindgen_test_layout_XUnmapEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XUnmapEvent>())).window as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).window) as usize - ptr as usize },
         40usize,
         concat!(
             "Offset of field: ",
@@ -30393,7 +21212,7 @@ fn bindgen_test_layout_XUnmapEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XUnmapEvent>())).from_configure as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).from_configure) as usize - ptr as usize },
         48usize,
         concat!(
             "Offset of field: ",
@@ -30416,6 +21235,8 @@ pub struct XMapEvent {
 }
 #[test]
 fn bindgen_test_layout_XMapEvent() {
+    const UNINIT: ::core::mem::MaybeUninit<XMapEvent> = ::core::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::core::mem::size_of::<XMapEvent>(),
         56usize,
@@ -30427,7 +21248,7 @@ fn bindgen_test_layout_XMapEvent() {
         concat!("Alignment of ", stringify!(XMapEvent))
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XMapEvent>())).type_ as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -30437,7 +21258,7 @@ fn bindgen_test_layout_XMapEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XMapEvent>())).serial as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).serial) as usize - ptr as usize },
         8usize,
         concat!(
             "Offset of field: ",
@@ -30447,7 +21268,7 @@ fn bindgen_test_layout_XMapEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XMapEvent>())).send_event as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).send_event) as usize - ptr as usize },
         16usize,
         concat!(
             "Offset of field: ",
@@ -30457,7 +21278,7 @@ fn bindgen_test_layout_XMapEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XMapEvent>())).display as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).display) as usize - ptr as usize },
         24usize,
         concat!(
             "Offset of field: ",
@@ -30467,7 +21288,7 @@ fn bindgen_test_layout_XMapEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XMapEvent>())).event as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).event) as usize - ptr as usize },
         32usize,
         concat!(
             "Offset of field: ",
@@ -30477,7 +21298,7 @@ fn bindgen_test_layout_XMapEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XMapEvent>())).window as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).window) as usize - ptr as usize },
         40usize,
         concat!(
             "Offset of field: ",
@@ -30487,7 +21308,7 @@ fn bindgen_test_layout_XMapEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XMapEvent>())).override_redirect as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).override_redirect) as usize - ptr as usize },
         48usize,
         concat!(
             "Offset of field: ",
@@ -30509,6 +21330,8 @@ pub struct XMapRequestEvent {
 }
 #[test]
 fn bindgen_test_layout_XMapRequestEvent() {
+    const UNINIT: ::core::mem::MaybeUninit<XMapRequestEvent> = ::core::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::core::mem::size_of::<XMapRequestEvent>(),
         48usize,
@@ -30520,7 +21343,7 @@ fn bindgen_test_layout_XMapRequestEvent() {
         concat!("Alignment of ", stringify!(XMapRequestEvent))
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XMapRequestEvent>())).type_ as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -30530,7 +21353,7 @@ fn bindgen_test_layout_XMapRequestEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XMapRequestEvent>())).serial as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).serial) as usize - ptr as usize },
         8usize,
         concat!(
             "Offset of field: ",
@@ -30540,7 +21363,7 @@ fn bindgen_test_layout_XMapRequestEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XMapRequestEvent>())).send_event as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).send_event) as usize - ptr as usize },
         16usize,
         concat!(
             "Offset of field: ",
@@ -30550,7 +21373,7 @@ fn bindgen_test_layout_XMapRequestEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XMapRequestEvent>())).display as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).display) as usize - ptr as usize },
         24usize,
         concat!(
             "Offset of field: ",
@@ -30560,7 +21383,7 @@ fn bindgen_test_layout_XMapRequestEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XMapRequestEvent>())).parent as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).parent) as usize - ptr as usize },
         32usize,
         concat!(
             "Offset of field: ",
@@ -30570,7 +21393,7 @@ fn bindgen_test_layout_XMapRequestEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XMapRequestEvent>())).window as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).window) as usize - ptr as usize },
         40usize,
         concat!(
             "Offset of field: ",
@@ -30596,6 +21419,8 @@ pub struct XReparentEvent {
 }
 #[test]
 fn bindgen_test_layout_XReparentEvent() {
+    const UNINIT: ::core::mem::MaybeUninit<XReparentEvent> = ::core::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::core::mem::size_of::<XReparentEvent>(),
         72usize,
@@ -30607,7 +21432,7 @@ fn bindgen_test_layout_XReparentEvent() {
         concat!("Alignment of ", stringify!(XReparentEvent))
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XReparentEvent>())).type_ as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -30617,7 +21442,7 @@ fn bindgen_test_layout_XReparentEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XReparentEvent>())).serial as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).serial) as usize - ptr as usize },
         8usize,
         concat!(
             "Offset of field: ",
@@ -30627,7 +21452,7 @@ fn bindgen_test_layout_XReparentEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XReparentEvent>())).send_event as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).send_event) as usize - ptr as usize },
         16usize,
         concat!(
             "Offset of field: ",
@@ -30637,7 +21462,7 @@ fn bindgen_test_layout_XReparentEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XReparentEvent>())).display as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).display) as usize - ptr as usize },
         24usize,
         concat!(
             "Offset of field: ",
@@ -30647,7 +21472,7 @@ fn bindgen_test_layout_XReparentEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XReparentEvent>())).event as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).event) as usize - ptr as usize },
         32usize,
         concat!(
             "Offset of field: ",
@@ -30657,7 +21482,7 @@ fn bindgen_test_layout_XReparentEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XReparentEvent>())).window as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).window) as usize - ptr as usize },
         40usize,
         concat!(
             "Offset of field: ",
@@ -30667,7 +21492,7 @@ fn bindgen_test_layout_XReparentEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XReparentEvent>())).parent as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).parent) as usize - ptr as usize },
         48usize,
         concat!(
             "Offset of field: ",
@@ -30677,7 +21502,7 @@ fn bindgen_test_layout_XReparentEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XReparentEvent>())).x as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).x) as usize - ptr as usize },
         56usize,
         concat!(
             "Offset of field: ",
@@ -30687,7 +21512,7 @@ fn bindgen_test_layout_XReparentEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XReparentEvent>())).y as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).y) as usize - ptr as usize },
         60usize,
         concat!(
             "Offset of field: ",
@@ -30697,9 +21522,7 @@ fn bindgen_test_layout_XReparentEvent() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::core::ptr::null::<XReparentEvent>())).override_redirect as *const _ as usize
-        },
+        unsafe { ::core::ptr::addr_of!((*ptr).override_redirect) as usize - ptr as usize },
         64usize,
         concat!(
             "Offset of field: ",
@@ -30728,6 +21551,8 @@ pub struct XConfigureEvent {
 }
 #[test]
 fn bindgen_test_layout_XConfigureEvent() {
+    const UNINIT: ::core::mem::MaybeUninit<XConfigureEvent> = ::core::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::core::mem::size_of::<XConfigureEvent>(),
         88usize,
@@ -30739,7 +21564,7 @@ fn bindgen_test_layout_XConfigureEvent() {
         concat!("Alignment of ", stringify!(XConfigureEvent))
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XConfigureEvent>())).type_ as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -30749,7 +21574,7 @@ fn bindgen_test_layout_XConfigureEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XConfigureEvent>())).serial as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).serial) as usize - ptr as usize },
         8usize,
         concat!(
             "Offset of field: ",
@@ -30759,7 +21584,7 @@ fn bindgen_test_layout_XConfigureEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XConfigureEvent>())).send_event as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).send_event) as usize - ptr as usize },
         16usize,
         concat!(
             "Offset of field: ",
@@ -30769,7 +21594,7 @@ fn bindgen_test_layout_XConfigureEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XConfigureEvent>())).display as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).display) as usize - ptr as usize },
         24usize,
         concat!(
             "Offset of field: ",
@@ -30779,7 +21604,7 @@ fn bindgen_test_layout_XConfigureEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XConfigureEvent>())).event as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).event) as usize - ptr as usize },
         32usize,
         concat!(
             "Offset of field: ",
@@ -30789,7 +21614,7 @@ fn bindgen_test_layout_XConfigureEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XConfigureEvent>())).window as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).window) as usize - ptr as usize },
         40usize,
         concat!(
             "Offset of field: ",
@@ -30799,7 +21624,7 @@ fn bindgen_test_layout_XConfigureEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XConfigureEvent>())).x as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).x) as usize - ptr as usize },
         48usize,
         concat!(
             "Offset of field: ",
@@ -30809,7 +21634,7 @@ fn bindgen_test_layout_XConfigureEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XConfigureEvent>())).y as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).y) as usize - ptr as usize },
         52usize,
         concat!(
             "Offset of field: ",
@@ -30819,7 +21644,7 @@ fn bindgen_test_layout_XConfigureEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XConfigureEvent>())).width as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).width) as usize - ptr as usize },
         56usize,
         concat!(
             "Offset of field: ",
@@ -30829,7 +21654,7 @@ fn bindgen_test_layout_XConfigureEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XConfigureEvent>())).height as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).height) as usize - ptr as usize },
         60usize,
         concat!(
             "Offset of field: ",
@@ -30839,7 +21664,7 @@ fn bindgen_test_layout_XConfigureEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XConfigureEvent>())).border_width as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).border_width) as usize - ptr as usize },
         64usize,
         concat!(
             "Offset of field: ",
@@ -30849,7 +21674,7 @@ fn bindgen_test_layout_XConfigureEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XConfigureEvent>())).above as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).above) as usize - ptr as usize },
         72usize,
         concat!(
             "Offset of field: ",
@@ -30859,9 +21684,7 @@ fn bindgen_test_layout_XConfigureEvent() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::core::ptr::null::<XConfigureEvent>())).override_redirect as *const _ as usize
-        },
+        unsafe { ::core::ptr::addr_of!((*ptr).override_redirect) as usize - ptr as usize },
         80usize,
         concat!(
             "Offset of field: ",
@@ -30885,6 +21708,8 @@ pub struct XGravityEvent {
 }
 #[test]
 fn bindgen_test_layout_XGravityEvent() {
+    const UNINIT: ::core::mem::MaybeUninit<XGravityEvent> = ::core::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::core::mem::size_of::<XGravityEvent>(),
         56usize,
@@ -30896,7 +21721,7 @@ fn bindgen_test_layout_XGravityEvent() {
         concat!("Alignment of ", stringify!(XGravityEvent))
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XGravityEvent>())).type_ as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -30906,7 +21731,7 @@ fn bindgen_test_layout_XGravityEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XGravityEvent>())).serial as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).serial) as usize - ptr as usize },
         8usize,
         concat!(
             "Offset of field: ",
@@ -30916,7 +21741,7 @@ fn bindgen_test_layout_XGravityEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XGravityEvent>())).send_event as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).send_event) as usize - ptr as usize },
         16usize,
         concat!(
             "Offset of field: ",
@@ -30926,7 +21751,7 @@ fn bindgen_test_layout_XGravityEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XGravityEvent>())).display as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).display) as usize - ptr as usize },
         24usize,
         concat!(
             "Offset of field: ",
@@ -30936,7 +21761,7 @@ fn bindgen_test_layout_XGravityEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XGravityEvent>())).event as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).event) as usize - ptr as usize },
         32usize,
         concat!(
             "Offset of field: ",
@@ -30946,7 +21771,7 @@ fn bindgen_test_layout_XGravityEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XGravityEvent>())).window as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).window) as usize - ptr as usize },
         40usize,
         concat!(
             "Offset of field: ",
@@ -30956,7 +21781,7 @@ fn bindgen_test_layout_XGravityEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XGravityEvent>())).x as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).x) as usize - ptr as usize },
         48usize,
         concat!(
             "Offset of field: ",
@@ -30966,7 +21791,7 @@ fn bindgen_test_layout_XGravityEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XGravityEvent>())).y as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).y) as usize - ptr as usize },
         52usize,
         concat!(
             "Offset of field: ",
@@ -30989,6 +21814,9 @@ pub struct XResizeRequestEvent {
 }
 #[test]
 fn bindgen_test_layout_XResizeRequestEvent() {
+    const UNINIT: ::core::mem::MaybeUninit<XResizeRequestEvent> =
+        ::core::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::core::mem::size_of::<XResizeRequestEvent>(),
         48usize,
@@ -31000,7 +21828,7 @@ fn bindgen_test_layout_XResizeRequestEvent() {
         concat!("Alignment of ", stringify!(XResizeRequestEvent))
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XResizeRequestEvent>())).type_ as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -31010,7 +21838,7 @@ fn bindgen_test_layout_XResizeRequestEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XResizeRequestEvent>())).serial as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).serial) as usize - ptr as usize },
         8usize,
         concat!(
             "Offset of field: ",
@@ -31020,7 +21848,7 @@ fn bindgen_test_layout_XResizeRequestEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XResizeRequestEvent>())).send_event as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).send_event) as usize - ptr as usize },
         16usize,
         concat!(
             "Offset of field: ",
@@ -31030,7 +21858,7 @@ fn bindgen_test_layout_XResizeRequestEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XResizeRequestEvent>())).display as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).display) as usize - ptr as usize },
         24usize,
         concat!(
             "Offset of field: ",
@@ -31040,7 +21868,7 @@ fn bindgen_test_layout_XResizeRequestEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XResizeRequestEvent>())).window as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).window) as usize - ptr as usize },
         32usize,
         concat!(
             "Offset of field: ",
@@ -31050,7 +21878,7 @@ fn bindgen_test_layout_XResizeRequestEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XResizeRequestEvent>())).width as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).width) as usize - ptr as usize },
         40usize,
         concat!(
             "Offset of field: ",
@@ -31060,7 +21888,7 @@ fn bindgen_test_layout_XResizeRequestEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XResizeRequestEvent>())).height as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).height) as usize - ptr as usize },
         44usize,
         concat!(
             "Offset of field: ",
@@ -31090,6 +21918,9 @@ pub struct XConfigureRequestEvent {
 }
 #[test]
 fn bindgen_test_layout_XConfigureRequestEvent() {
+    const UNINIT: ::core::mem::MaybeUninit<XConfigureRequestEvent> =
+        ::core::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::core::mem::size_of::<XConfigureRequestEvent>(),
         96usize,
@@ -31101,7 +21932,7 @@ fn bindgen_test_layout_XConfigureRequestEvent() {
         concat!("Alignment of ", stringify!(XConfigureRequestEvent))
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XConfigureRequestEvent>())).type_ as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -31111,7 +21942,7 @@ fn bindgen_test_layout_XConfigureRequestEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XConfigureRequestEvent>())).serial as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).serial) as usize - ptr as usize },
         8usize,
         concat!(
             "Offset of field: ",
@@ -31121,9 +21952,7 @@ fn bindgen_test_layout_XConfigureRequestEvent() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::core::ptr::null::<XConfigureRequestEvent>())).send_event as *const _ as usize
-        },
+        unsafe { ::core::ptr::addr_of!((*ptr).send_event) as usize - ptr as usize },
         16usize,
         concat!(
             "Offset of field: ",
@@ -31133,7 +21962,7 @@ fn bindgen_test_layout_XConfigureRequestEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XConfigureRequestEvent>())).display as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).display) as usize - ptr as usize },
         24usize,
         concat!(
             "Offset of field: ",
@@ -31143,7 +21972,7 @@ fn bindgen_test_layout_XConfigureRequestEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XConfigureRequestEvent>())).parent as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).parent) as usize - ptr as usize },
         32usize,
         concat!(
             "Offset of field: ",
@@ -31153,7 +21982,7 @@ fn bindgen_test_layout_XConfigureRequestEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XConfigureRequestEvent>())).window as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).window) as usize - ptr as usize },
         40usize,
         concat!(
             "Offset of field: ",
@@ -31163,7 +21992,7 @@ fn bindgen_test_layout_XConfigureRequestEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XConfigureRequestEvent>())).x as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).x) as usize - ptr as usize },
         48usize,
         concat!(
             "Offset of field: ",
@@ -31173,7 +22002,7 @@ fn bindgen_test_layout_XConfigureRequestEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XConfigureRequestEvent>())).y as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).y) as usize - ptr as usize },
         52usize,
         concat!(
             "Offset of field: ",
@@ -31183,7 +22012,7 @@ fn bindgen_test_layout_XConfigureRequestEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XConfigureRequestEvent>())).width as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).width) as usize - ptr as usize },
         56usize,
         concat!(
             "Offset of field: ",
@@ -31193,7 +22022,7 @@ fn bindgen_test_layout_XConfigureRequestEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XConfigureRequestEvent>())).height as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).height) as usize - ptr as usize },
         60usize,
         concat!(
             "Offset of field: ",
@@ -31203,9 +22032,7 @@ fn bindgen_test_layout_XConfigureRequestEvent() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::core::ptr::null::<XConfigureRequestEvent>())).border_width as *const _ as usize
-        },
+        unsafe { ::core::ptr::addr_of!((*ptr).border_width) as usize - ptr as usize },
         64usize,
         concat!(
             "Offset of field: ",
@@ -31215,7 +22042,7 @@ fn bindgen_test_layout_XConfigureRequestEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XConfigureRequestEvent>())).above as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).above) as usize - ptr as usize },
         72usize,
         concat!(
             "Offset of field: ",
@@ -31225,7 +22052,7 @@ fn bindgen_test_layout_XConfigureRequestEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XConfigureRequestEvent>())).detail as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).detail) as usize - ptr as usize },
         80usize,
         concat!(
             "Offset of field: ",
@@ -31235,9 +22062,7 @@ fn bindgen_test_layout_XConfigureRequestEvent() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::core::ptr::null::<XConfigureRequestEvent>())).value_mask as *const _ as usize
-        },
+        unsafe { ::core::ptr::addr_of!((*ptr).value_mask) as usize - ptr as usize },
         88usize,
         concat!(
             "Offset of field: ",
@@ -31260,6 +22085,8 @@ pub struct XCirculateEvent {
 }
 #[test]
 fn bindgen_test_layout_XCirculateEvent() {
+    const UNINIT: ::core::mem::MaybeUninit<XCirculateEvent> = ::core::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::core::mem::size_of::<XCirculateEvent>(),
         56usize,
@@ -31271,7 +22098,7 @@ fn bindgen_test_layout_XCirculateEvent() {
         concat!("Alignment of ", stringify!(XCirculateEvent))
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XCirculateEvent>())).type_ as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -31281,7 +22108,7 @@ fn bindgen_test_layout_XCirculateEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XCirculateEvent>())).serial as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).serial) as usize - ptr as usize },
         8usize,
         concat!(
             "Offset of field: ",
@@ -31291,7 +22118,7 @@ fn bindgen_test_layout_XCirculateEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XCirculateEvent>())).send_event as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).send_event) as usize - ptr as usize },
         16usize,
         concat!(
             "Offset of field: ",
@@ -31301,7 +22128,7 @@ fn bindgen_test_layout_XCirculateEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XCirculateEvent>())).display as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).display) as usize - ptr as usize },
         24usize,
         concat!(
             "Offset of field: ",
@@ -31311,7 +22138,7 @@ fn bindgen_test_layout_XCirculateEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XCirculateEvent>())).event as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).event) as usize - ptr as usize },
         32usize,
         concat!(
             "Offset of field: ",
@@ -31321,7 +22148,7 @@ fn bindgen_test_layout_XCirculateEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XCirculateEvent>())).window as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).window) as usize - ptr as usize },
         40usize,
         concat!(
             "Offset of field: ",
@@ -31331,7 +22158,7 @@ fn bindgen_test_layout_XCirculateEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XCirculateEvent>())).place as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).place) as usize - ptr as usize },
         48usize,
         concat!(
             "Offset of field: ",
@@ -31354,6 +22181,9 @@ pub struct XCirculateRequestEvent {
 }
 #[test]
 fn bindgen_test_layout_XCirculateRequestEvent() {
+    const UNINIT: ::core::mem::MaybeUninit<XCirculateRequestEvent> =
+        ::core::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::core::mem::size_of::<XCirculateRequestEvent>(),
         56usize,
@@ -31365,7 +22195,7 @@ fn bindgen_test_layout_XCirculateRequestEvent() {
         concat!("Alignment of ", stringify!(XCirculateRequestEvent))
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XCirculateRequestEvent>())).type_ as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -31375,7 +22205,7 @@ fn bindgen_test_layout_XCirculateRequestEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XCirculateRequestEvent>())).serial as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).serial) as usize - ptr as usize },
         8usize,
         concat!(
             "Offset of field: ",
@@ -31385,9 +22215,7 @@ fn bindgen_test_layout_XCirculateRequestEvent() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::core::ptr::null::<XCirculateRequestEvent>())).send_event as *const _ as usize
-        },
+        unsafe { ::core::ptr::addr_of!((*ptr).send_event) as usize - ptr as usize },
         16usize,
         concat!(
             "Offset of field: ",
@@ -31397,7 +22225,7 @@ fn bindgen_test_layout_XCirculateRequestEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XCirculateRequestEvent>())).display as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).display) as usize - ptr as usize },
         24usize,
         concat!(
             "Offset of field: ",
@@ -31407,7 +22235,7 @@ fn bindgen_test_layout_XCirculateRequestEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XCirculateRequestEvent>())).parent as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).parent) as usize - ptr as usize },
         32usize,
         concat!(
             "Offset of field: ",
@@ -31417,7 +22245,7 @@ fn bindgen_test_layout_XCirculateRequestEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XCirculateRequestEvent>())).window as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).window) as usize - ptr as usize },
         40usize,
         concat!(
             "Offset of field: ",
@@ -31427,7 +22255,7 @@ fn bindgen_test_layout_XCirculateRequestEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XCirculateRequestEvent>())).place as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).place) as usize - ptr as usize },
         48usize,
         concat!(
             "Offset of field: ",
@@ -31451,6 +22279,8 @@ pub struct XPropertyEvent {
 }
 #[test]
 fn bindgen_test_layout_XPropertyEvent() {
+    const UNINIT: ::core::mem::MaybeUninit<XPropertyEvent> = ::core::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::core::mem::size_of::<XPropertyEvent>(),
         64usize,
@@ -31462,7 +22292,7 @@ fn bindgen_test_layout_XPropertyEvent() {
         concat!("Alignment of ", stringify!(XPropertyEvent))
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XPropertyEvent>())).type_ as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -31472,7 +22302,7 @@ fn bindgen_test_layout_XPropertyEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XPropertyEvent>())).serial as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).serial) as usize - ptr as usize },
         8usize,
         concat!(
             "Offset of field: ",
@@ -31482,7 +22312,7 @@ fn bindgen_test_layout_XPropertyEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XPropertyEvent>())).send_event as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).send_event) as usize - ptr as usize },
         16usize,
         concat!(
             "Offset of field: ",
@@ -31492,7 +22322,7 @@ fn bindgen_test_layout_XPropertyEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XPropertyEvent>())).display as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).display) as usize - ptr as usize },
         24usize,
         concat!(
             "Offset of field: ",
@@ -31502,7 +22332,7 @@ fn bindgen_test_layout_XPropertyEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XPropertyEvent>())).window as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).window) as usize - ptr as usize },
         32usize,
         concat!(
             "Offset of field: ",
@@ -31512,7 +22342,7 @@ fn bindgen_test_layout_XPropertyEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XPropertyEvent>())).atom as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).atom) as usize - ptr as usize },
         40usize,
         concat!(
             "Offset of field: ",
@@ -31522,7 +22352,7 @@ fn bindgen_test_layout_XPropertyEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XPropertyEvent>())).time as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).time) as usize - ptr as usize },
         48usize,
         concat!(
             "Offset of field: ",
@@ -31532,7 +22362,7 @@ fn bindgen_test_layout_XPropertyEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XPropertyEvent>())).state as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).state) as usize - ptr as usize },
         56usize,
         concat!(
             "Offset of field: ",
@@ -31555,6 +22385,9 @@ pub struct XSelectionClearEvent {
 }
 #[test]
 fn bindgen_test_layout_XSelectionClearEvent() {
+    const UNINIT: ::core::mem::MaybeUninit<XSelectionClearEvent> =
+        ::core::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::core::mem::size_of::<XSelectionClearEvent>(),
         56usize,
@@ -31566,7 +22399,7 @@ fn bindgen_test_layout_XSelectionClearEvent() {
         concat!("Alignment of ", stringify!(XSelectionClearEvent))
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XSelectionClearEvent>())).type_ as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -31576,7 +22409,7 @@ fn bindgen_test_layout_XSelectionClearEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XSelectionClearEvent>())).serial as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).serial) as usize - ptr as usize },
         8usize,
         concat!(
             "Offset of field: ",
@@ -31586,9 +22419,7 @@ fn bindgen_test_layout_XSelectionClearEvent() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::core::ptr::null::<XSelectionClearEvent>())).send_event as *const _ as usize
-        },
+        unsafe { ::core::ptr::addr_of!((*ptr).send_event) as usize - ptr as usize },
         16usize,
         concat!(
             "Offset of field: ",
@@ -31598,7 +22429,7 @@ fn bindgen_test_layout_XSelectionClearEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XSelectionClearEvent>())).display as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).display) as usize - ptr as usize },
         24usize,
         concat!(
             "Offset of field: ",
@@ -31608,7 +22439,7 @@ fn bindgen_test_layout_XSelectionClearEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XSelectionClearEvent>())).window as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).window) as usize - ptr as usize },
         32usize,
         concat!(
             "Offset of field: ",
@@ -31618,7 +22449,7 @@ fn bindgen_test_layout_XSelectionClearEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XSelectionClearEvent>())).selection as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).selection) as usize - ptr as usize },
         40usize,
         concat!(
             "Offset of field: ",
@@ -31628,7 +22459,7 @@ fn bindgen_test_layout_XSelectionClearEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XSelectionClearEvent>())).time as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).time) as usize - ptr as usize },
         48usize,
         concat!(
             "Offset of field: ",
@@ -31654,6 +22485,9 @@ pub struct XSelectionRequestEvent {
 }
 #[test]
 fn bindgen_test_layout_XSelectionRequestEvent() {
+    const UNINIT: ::core::mem::MaybeUninit<XSelectionRequestEvent> =
+        ::core::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::core::mem::size_of::<XSelectionRequestEvent>(),
         80usize,
@@ -31665,7 +22499,7 @@ fn bindgen_test_layout_XSelectionRequestEvent() {
         concat!("Alignment of ", stringify!(XSelectionRequestEvent))
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XSelectionRequestEvent>())).type_ as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -31675,7 +22509,7 @@ fn bindgen_test_layout_XSelectionRequestEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XSelectionRequestEvent>())).serial as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).serial) as usize - ptr as usize },
         8usize,
         concat!(
             "Offset of field: ",
@@ -31685,9 +22519,7 @@ fn bindgen_test_layout_XSelectionRequestEvent() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::core::ptr::null::<XSelectionRequestEvent>())).send_event as *const _ as usize
-        },
+        unsafe { ::core::ptr::addr_of!((*ptr).send_event) as usize - ptr as usize },
         16usize,
         concat!(
             "Offset of field: ",
@@ -31697,7 +22529,7 @@ fn bindgen_test_layout_XSelectionRequestEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XSelectionRequestEvent>())).display as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).display) as usize - ptr as usize },
         24usize,
         concat!(
             "Offset of field: ",
@@ -31707,7 +22539,7 @@ fn bindgen_test_layout_XSelectionRequestEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XSelectionRequestEvent>())).owner as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).owner) as usize - ptr as usize },
         32usize,
         concat!(
             "Offset of field: ",
@@ -31717,9 +22549,7 @@ fn bindgen_test_layout_XSelectionRequestEvent() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::core::ptr::null::<XSelectionRequestEvent>())).requestor as *const _ as usize
-        },
+        unsafe { ::core::ptr::addr_of!((*ptr).requestor) as usize - ptr as usize },
         40usize,
         concat!(
             "Offset of field: ",
@@ -31729,9 +22559,7 @@ fn bindgen_test_layout_XSelectionRequestEvent() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::core::ptr::null::<XSelectionRequestEvent>())).selection as *const _ as usize
-        },
+        unsafe { ::core::ptr::addr_of!((*ptr).selection) as usize - ptr as usize },
         48usize,
         concat!(
             "Offset of field: ",
@@ -31741,7 +22569,7 @@ fn bindgen_test_layout_XSelectionRequestEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XSelectionRequestEvent>())).target as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).target) as usize - ptr as usize },
         56usize,
         concat!(
             "Offset of field: ",
@@ -31751,9 +22579,7 @@ fn bindgen_test_layout_XSelectionRequestEvent() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::core::ptr::null::<XSelectionRequestEvent>())).property as *const _ as usize
-        },
+        unsafe { ::core::ptr::addr_of!((*ptr).property) as usize - ptr as usize },
         64usize,
         concat!(
             "Offset of field: ",
@@ -31763,7 +22589,7 @@ fn bindgen_test_layout_XSelectionRequestEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XSelectionRequestEvent>())).time as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).time) as usize - ptr as usize },
         72usize,
         concat!(
             "Offset of field: ",
@@ -31788,6 +22614,8 @@ pub struct XSelectionEvent {
 }
 #[test]
 fn bindgen_test_layout_XSelectionEvent() {
+    const UNINIT: ::core::mem::MaybeUninit<XSelectionEvent> = ::core::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::core::mem::size_of::<XSelectionEvent>(),
         72usize,
@@ -31799,7 +22627,7 @@ fn bindgen_test_layout_XSelectionEvent() {
         concat!("Alignment of ", stringify!(XSelectionEvent))
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XSelectionEvent>())).type_ as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -31809,7 +22637,7 @@ fn bindgen_test_layout_XSelectionEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XSelectionEvent>())).serial as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).serial) as usize - ptr as usize },
         8usize,
         concat!(
             "Offset of field: ",
@@ -31819,7 +22647,7 @@ fn bindgen_test_layout_XSelectionEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XSelectionEvent>())).send_event as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).send_event) as usize - ptr as usize },
         16usize,
         concat!(
             "Offset of field: ",
@@ -31829,7 +22657,7 @@ fn bindgen_test_layout_XSelectionEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XSelectionEvent>())).display as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).display) as usize - ptr as usize },
         24usize,
         concat!(
             "Offset of field: ",
@@ -31839,7 +22667,7 @@ fn bindgen_test_layout_XSelectionEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XSelectionEvent>())).requestor as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).requestor) as usize - ptr as usize },
         32usize,
         concat!(
             "Offset of field: ",
@@ -31849,7 +22677,7 @@ fn bindgen_test_layout_XSelectionEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XSelectionEvent>())).selection as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).selection) as usize - ptr as usize },
         40usize,
         concat!(
             "Offset of field: ",
@@ -31859,7 +22687,7 @@ fn bindgen_test_layout_XSelectionEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XSelectionEvent>())).target as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).target) as usize - ptr as usize },
         48usize,
         concat!(
             "Offset of field: ",
@@ -31869,7 +22697,7 @@ fn bindgen_test_layout_XSelectionEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XSelectionEvent>())).property as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).property) as usize - ptr as usize },
         56usize,
         concat!(
             "Offset of field: ",
@@ -31879,7 +22707,7 @@ fn bindgen_test_layout_XSelectionEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XSelectionEvent>())).time as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).time) as usize - ptr as usize },
         64usize,
         concat!(
             "Offset of field: ",
@@ -31903,6 +22731,8 @@ pub struct XColormapEvent {
 }
 #[test]
 fn bindgen_test_layout_XColormapEvent() {
+    const UNINIT: ::core::mem::MaybeUninit<XColormapEvent> = ::core::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::core::mem::size_of::<XColormapEvent>(),
         56usize,
@@ -31914,7 +22744,7 @@ fn bindgen_test_layout_XColormapEvent() {
         concat!("Alignment of ", stringify!(XColormapEvent))
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XColormapEvent>())).type_ as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -31924,7 +22754,7 @@ fn bindgen_test_layout_XColormapEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XColormapEvent>())).serial as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).serial) as usize - ptr as usize },
         8usize,
         concat!(
             "Offset of field: ",
@@ -31934,7 +22764,7 @@ fn bindgen_test_layout_XColormapEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XColormapEvent>())).send_event as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).send_event) as usize - ptr as usize },
         16usize,
         concat!(
             "Offset of field: ",
@@ -31944,7 +22774,7 @@ fn bindgen_test_layout_XColormapEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XColormapEvent>())).display as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).display) as usize - ptr as usize },
         24usize,
         concat!(
             "Offset of field: ",
@@ -31954,7 +22784,7 @@ fn bindgen_test_layout_XColormapEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XColormapEvent>())).window as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).window) as usize - ptr as usize },
         32usize,
         concat!(
             "Offset of field: ",
@@ -31964,7 +22794,7 @@ fn bindgen_test_layout_XColormapEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XColormapEvent>())).colormap as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).colormap) as usize - ptr as usize },
         40usize,
         concat!(
             "Offset of field: ",
@@ -31974,7 +22804,7 @@ fn bindgen_test_layout_XColormapEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XColormapEvent>())).new as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).new) as usize - ptr as usize },
         48usize,
         concat!(
             "Offset of field: ",
@@ -31984,7 +22814,7 @@ fn bindgen_test_layout_XColormapEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XColormapEvent>())).state as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).state) as usize - ptr as usize },
         52usize,
         concat!(
             "Offset of field: ",
@@ -32012,10 +22842,12 @@ pub union XClientMessageEvent__bindgen_ty_1 {
     pub b: [libc::c_char; 20usize],
     pub s: [libc::c_short; 10usize],
     pub l: [libc::c_long; 5usize],
-    _bindgen_union_align: [u64; 5usize],
 }
 #[test]
 fn bindgen_test_layout_XClientMessageEvent__bindgen_ty_1() {
+    const UNINIT: ::core::mem::MaybeUninit<XClientMessageEvent__bindgen_ty_1> =
+        ::core::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::core::mem::size_of::<XClientMessageEvent__bindgen_ty_1>(),
         40usize,
@@ -32030,9 +22862,7 @@ fn bindgen_test_layout_XClientMessageEvent__bindgen_ty_1() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::core::ptr::null::<XClientMessageEvent__bindgen_ty_1>())).b as *const _ as usize
-        },
+        unsafe { ::core::ptr::addr_of!((*ptr).b) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -32042,9 +22872,7 @@ fn bindgen_test_layout_XClientMessageEvent__bindgen_ty_1() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::core::ptr::null::<XClientMessageEvent__bindgen_ty_1>())).s as *const _ as usize
-        },
+        unsafe { ::core::ptr::addr_of!((*ptr).s) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -32054,9 +22882,7 @@ fn bindgen_test_layout_XClientMessageEvent__bindgen_ty_1() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::core::ptr::null::<XClientMessageEvent__bindgen_ty_1>())).l as *const _ as usize
-        },
+        unsafe { ::core::ptr::addr_of!((*ptr).l) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -32068,6 +22894,9 @@ fn bindgen_test_layout_XClientMessageEvent__bindgen_ty_1() {
 }
 #[test]
 fn bindgen_test_layout_XClientMessageEvent() {
+    const UNINIT: ::core::mem::MaybeUninit<XClientMessageEvent> =
+        ::core::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::core::mem::size_of::<XClientMessageEvent>(),
         96usize,
@@ -32079,7 +22908,7 @@ fn bindgen_test_layout_XClientMessageEvent() {
         concat!("Alignment of ", stringify!(XClientMessageEvent))
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XClientMessageEvent>())).type_ as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -32089,7 +22918,7 @@ fn bindgen_test_layout_XClientMessageEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XClientMessageEvent>())).serial as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).serial) as usize - ptr as usize },
         8usize,
         concat!(
             "Offset of field: ",
@@ -32099,7 +22928,7 @@ fn bindgen_test_layout_XClientMessageEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XClientMessageEvent>())).send_event as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).send_event) as usize - ptr as usize },
         16usize,
         concat!(
             "Offset of field: ",
@@ -32109,7 +22938,7 @@ fn bindgen_test_layout_XClientMessageEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XClientMessageEvent>())).display as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).display) as usize - ptr as usize },
         24usize,
         concat!(
             "Offset of field: ",
@@ -32119,7 +22948,7 @@ fn bindgen_test_layout_XClientMessageEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XClientMessageEvent>())).window as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).window) as usize - ptr as usize },
         32usize,
         concat!(
             "Offset of field: ",
@@ -32129,9 +22958,7 @@ fn bindgen_test_layout_XClientMessageEvent() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::core::ptr::null::<XClientMessageEvent>())).message_type as *const _ as usize
-        },
+        unsafe { ::core::ptr::addr_of!((*ptr).message_type) as usize - ptr as usize },
         40usize,
         concat!(
             "Offset of field: ",
@@ -32141,7 +22968,7 @@ fn bindgen_test_layout_XClientMessageEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XClientMessageEvent>())).format as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).format) as usize - ptr as usize },
         48usize,
         concat!(
             "Offset of field: ",
@@ -32151,7 +22978,7 @@ fn bindgen_test_layout_XClientMessageEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XClientMessageEvent>())).data as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
         56usize,
         concat!(
             "Offset of field: ",
@@ -32175,6 +23002,8 @@ pub struct XMappingEvent {
 }
 #[test]
 fn bindgen_test_layout_XMappingEvent() {
+    const UNINIT: ::core::mem::MaybeUninit<XMappingEvent> = ::core::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::core::mem::size_of::<XMappingEvent>(),
         56usize,
@@ -32186,7 +23015,7 @@ fn bindgen_test_layout_XMappingEvent() {
         concat!("Alignment of ", stringify!(XMappingEvent))
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XMappingEvent>())).type_ as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -32196,7 +23025,7 @@ fn bindgen_test_layout_XMappingEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XMappingEvent>())).serial as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).serial) as usize - ptr as usize },
         8usize,
         concat!(
             "Offset of field: ",
@@ -32206,7 +23035,7 @@ fn bindgen_test_layout_XMappingEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XMappingEvent>())).send_event as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).send_event) as usize - ptr as usize },
         16usize,
         concat!(
             "Offset of field: ",
@@ -32216,7 +23045,7 @@ fn bindgen_test_layout_XMappingEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XMappingEvent>())).display as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).display) as usize - ptr as usize },
         24usize,
         concat!(
             "Offset of field: ",
@@ -32226,7 +23055,7 @@ fn bindgen_test_layout_XMappingEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XMappingEvent>())).window as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).window) as usize - ptr as usize },
         32usize,
         concat!(
             "Offset of field: ",
@@ -32236,7 +23065,7 @@ fn bindgen_test_layout_XMappingEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XMappingEvent>())).request as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).request) as usize - ptr as usize },
         40usize,
         concat!(
             "Offset of field: ",
@@ -32246,7 +23075,7 @@ fn bindgen_test_layout_XMappingEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XMappingEvent>())).first_keycode as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).first_keycode) as usize - ptr as usize },
         44usize,
         concat!(
             "Offset of field: ",
@@ -32256,7 +23085,7 @@ fn bindgen_test_layout_XMappingEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XMappingEvent>())).count as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).count) as usize - ptr as usize },
         48usize,
         concat!(
             "Offset of field: ",
@@ -32279,6 +23108,8 @@ pub struct XErrorEvent {
 }
 #[test]
 fn bindgen_test_layout_XErrorEvent() {
+    const UNINIT: ::core::mem::MaybeUninit<XErrorEvent> = ::core::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::core::mem::size_of::<XErrorEvent>(),
         40usize,
@@ -32290,7 +23121,7 @@ fn bindgen_test_layout_XErrorEvent() {
         concat!("Alignment of ", stringify!(XErrorEvent))
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XErrorEvent>())).type_ as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -32300,7 +23131,7 @@ fn bindgen_test_layout_XErrorEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XErrorEvent>())).display as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).display) as usize - ptr as usize },
         8usize,
         concat!(
             "Offset of field: ",
@@ -32310,7 +23141,7 @@ fn bindgen_test_layout_XErrorEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XErrorEvent>())).resourceid as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).resourceid) as usize - ptr as usize },
         16usize,
         concat!(
             "Offset of field: ",
@@ -32320,7 +23151,7 @@ fn bindgen_test_layout_XErrorEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XErrorEvent>())).serial as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).serial) as usize - ptr as usize },
         24usize,
         concat!(
             "Offset of field: ",
@@ -32330,7 +23161,7 @@ fn bindgen_test_layout_XErrorEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XErrorEvent>())).error_code as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).error_code) as usize - ptr as usize },
         32usize,
         concat!(
             "Offset of field: ",
@@ -32340,7 +23171,7 @@ fn bindgen_test_layout_XErrorEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XErrorEvent>())).request_code as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).request_code) as usize - ptr as usize },
         33usize,
         concat!(
             "Offset of field: ",
@@ -32350,7 +23181,7 @@ fn bindgen_test_layout_XErrorEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XErrorEvent>())).minor_code as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).minor_code) as usize - ptr as usize },
         34usize,
         concat!(
             "Offset of field: ",
@@ -32371,6 +23202,8 @@ pub struct XAnyEvent {
 }
 #[test]
 fn bindgen_test_layout_XAnyEvent() {
+    const UNINIT: ::core::mem::MaybeUninit<XAnyEvent> = ::core::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::core::mem::size_of::<XAnyEvent>(),
         40usize,
@@ -32382,7 +23215,7 @@ fn bindgen_test_layout_XAnyEvent() {
         concat!("Alignment of ", stringify!(XAnyEvent))
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XAnyEvent>())).type_ as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -32392,7 +23225,7 @@ fn bindgen_test_layout_XAnyEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XAnyEvent>())).serial as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).serial) as usize - ptr as usize },
         8usize,
         concat!(
             "Offset of field: ",
@@ -32402,7 +23235,7 @@ fn bindgen_test_layout_XAnyEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XAnyEvent>())).send_event as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).send_event) as usize - ptr as usize },
         16usize,
         concat!(
             "Offset of field: ",
@@ -32412,7 +23245,7 @@ fn bindgen_test_layout_XAnyEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XAnyEvent>())).display as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).display) as usize - ptr as usize },
         24usize,
         concat!(
             "Offset of field: ",
@@ -32422,7 +23255,7 @@ fn bindgen_test_layout_XAnyEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XAnyEvent>())).window as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).window) as usize - ptr as usize },
         32usize,
         concat!(
             "Offset of field: ",
@@ -32444,6 +23277,8 @@ pub struct XGenericEvent {
 }
 #[test]
 fn bindgen_test_layout_XGenericEvent() {
+    const UNINIT: ::core::mem::MaybeUninit<XGenericEvent> = ::core::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::core::mem::size_of::<XGenericEvent>(),
         40usize,
@@ -32455,7 +23290,7 @@ fn bindgen_test_layout_XGenericEvent() {
         concat!("Alignment of ", stringify!(XGenericEvent))
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XGenericEvent>())).type_ as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -32465,7 +23300,7 @@ fn bindgen_test_layout_XGenericEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XGenericEvent>())).serial as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).serial) as usize - ptr as usize },
         8usize,
         concat!(
             "Offset of field: ",
@@ -32475,7 +23310,7 @@ fn bindgen_test_layout_XGenericEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XGenericEvent>())).send_event as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).send_event) as usize - ptr as usize },
         16usize,
         concat!(
             "Offset of field: ",
@@ -32485,7 +23320,7 @@ fn bindgen_test_layout_XGenericEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XGenericEvent>())).display as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).display) as usize - ptr as usize },
         24usize,
         concat!(
             "Offset of field: ",
@@ -32495,7 +23330,7 @@ fn bindgen_test_layout_XGenericEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XGenericEvent>())).extension as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).extension) as usize - ptr as usize },
         32usize,
         concat!(
             "Offset of field: ",
@@ -32505,7 +23340,7 @@ fn bindgen_test_layout_XGenericEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XGenericEvent>())).evtype as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).evtype) as usize - ptr as usize },
         36usize,
         concat!(
             "Offset of field: ",
@@ -32529,6 +23364,9 @@ pub struct XGenericEventCookie {
 }
 #[test]
 fn bindgen_test_layout_XGenericEventCookie() {
+    const UNINIT: ::core::mem::MaybeUninit<XGenericEventCookie> =
+        ::core::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::core::mem::size_of::<XGenericEventCookie>(),
         56usize,
@@ -32540,7 +23378,7 @@ fn bindgen_test_layout_XGenericEventCookie() {
         concat!("Alignment of ", stringify!(XGenericEventCookie))
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XGenericEventCookie>())).type_ as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -32550,7 +23388,7 @@ fn bindgen_test_layout_XGenericEventCookie() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XGenericEventCookie>())).serial as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).serial) as usize - ptr as usize },
         8usize,
         concat!(
             "Offset of field: ",
@@ -32560,7 +23398,7 @@ fn bindgen_test_layout_XGenericEventCookie() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XGenericEventCookie>())).send_event as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).send_event) as usize - ptr as usize },
         16usize,
         concat!(
             "Offset of field: ",
@@ -32570,7 +23408,7 @@ fn bindgen_test_layout_XGenericEventCookie() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XGenericEventCookie>())).display as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).display) as usize - ptr as usize },
         24usize,
         concat!(
             "Offset of field: ",
@@ -32580,7 +23418,7 @@ fn bindgen_test_layout_XGenericEventCookie() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XGenericEventCookie>())).extension as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).extension) as usize - ptr as usize },
         32usize,
         concat!(
             "Offset of field: ",
@@ -32590,7 +23428,7 @@ fn bindgen_test_layout_XGenericEventCookie() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XGenericEventCookie>())).evtype as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).evtype) as usize - ptr as usize },
         36usize,
         concat!(
             "Offset of field: ",
@@ -32600,7 +23438,7 @@ fn bindgen_test_layout_XGenericEventCookie() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XGenericEventCookie>())).cookie as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).cookie) as usize - ptr as usize },
         40usize,
         concat!(
             "Offset of field: ",
@@ -32610,7 +23448,7 @@ fn bindgen_test_layout_XGenericEventCookie() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XGenericEventCookie>())).data as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
         48usize,
         concat!(
             "Offset of field: ",
@@ -32658,10 +23496,11 @@ pub union _XEvent {
     pub xgeneric: XGenericEvent,
     pub xcookie: XGenericEventCookie,
     pub pad: [libc::c_long; 24usize],
-    _bindgen_union_align: [u64; 24usize],
 }
 #[test]
 fn bindgen_test_layout__XEvent() {
+    const UNINIT: ::core::mem::MaybeUninit<_XEvent> = ::core::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::core::mem::size_of::<_XEvent>(),
         192usize,
@@ -32673,7 +23512,7 @@ fn bindgen_test_layout__XEvent() {
         concat!("Alignment of ", stringify!(_XEvent))
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<_XEvent>())).type_ as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -32683,7 +23522,7 @@ fn bindgen_test_layout__XEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<_XEvent>())).xany as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).xany) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -32693,7 +23532,7 @@ fn bindgen_test_layout__XEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<_XEvent>())).xkey as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).xkey) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -32703,7 +23542,7 @@ fn bindgen_test_layout__XEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<_XEvent>())).xbutton as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).xbutton) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -32713,7 +23552,7 @@ fn bindgen_test_layout__XEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<_XEvent>())).xmotion as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).xmotion) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -32723,7 +23562,7 @@ fn bindgen_test_layout__XEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<_XEvent>())).xcrossing as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).xcrossing) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -32733,7 +23572,7 @@ fn bindgen_test_layout__XEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<_XEvent>())).xfocus as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).xfocus) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -32743,7 +23582,7 @@ fn bindgen_test_layout__XEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<_XEvent>())).xexpose as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).xexpose) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -32753,7 +23592,7 @@ fn bindgen_test_layout__XEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<_XEvent>())).xgraphicsexpose as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).xgraphicsexpose) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -32763,7 +23602,7 @@ fn bindgen_test_layout__XEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<_XEvent>())).xnoexpose as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).xnoexpose) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -32773,7 +23612,7 @@ fn bindgen_test_layout__XEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<_XEvent>())).xvisibility as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).xvisibility) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -32783,7 +23622,7 @@ fn bindgen_test_layout__XEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<_XEvent>())).xcreatewindow as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).xcreatewindow) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -32793,7 +23632,7 @@ fn bindgen_test_layout__XEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<_XEvent>())).xdestroywindow as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).xdestroywindow) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -32803,7 +23642,7 @@ fn bindgen_test_layout__XEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<_XEvent>())).xunmap as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).xunmap) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -32813,7 +23652,7 @@ fn bindgen_test_layout__XEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<_XEvent>())).xmap as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).xmap) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -32823,7 +23662,7 @@ fn bindgen_test_layout__XEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<_XEvent>())).xmaprequest as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).xmaprequest) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -32833,7 +23672,7 @@ fn bindgen_test_layout__XEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<_XEvent>())).xreparent as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).xreparent) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -32843,7 +23682,7 @@ fn bindgen_test_layout__XEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<_XEvent>())).xconfigure as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).xconfigure) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -32853,7 +23692,7 @@ fn bindgen_test_layout__XEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<_XEvent>())).xgravity as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).xgravity) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -32863,7 +23702,7 @@ fn bindgen_test_layout__XEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<_XEvent>())).xresizerequest as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).xresizerequest) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -32873,7 +23712,7 @@ fn bindgen_test_layout__XEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<_XEvent>())).xconfigurerequest as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).xconfigurerequest) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -32883,7 +23722,7 @@ fn bindgen_test_layout__XEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<_XEvent>())).xcirculate as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).xcirculate) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -32893,7 +23732,7 @@ fn bindgen_test_layout__XEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<_XEvent>())).xcirculaterequest as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).xcirculaterequest) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -32903,7 +23742,7 @@ fn bindgen_test_layout__XEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<_XEvent>())).xproperty as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).xproperty) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -32913,7 +23752,7 @@ fn bindgen_test_layout__XEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<_XEvent>())).xselectionclear as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).xselectionclear) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -32923,7 +23762,7 @@ fn bindgen_test_layout__XEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<_XEvent>())).xselectionrequest as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).xselectionrequest) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -32933,7 +23772,7 @@ fn bindgen_test_layout__XEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<_XEvent>())).xselection as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).xselection) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -32943,7 +23782,7 @@ fn bindgen_test_layout__XEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<_XEvent>())).xcolormap as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).xcolormap) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -32953,7 +23792,7 @@ fn bindgen_test_layout__XEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<_XEvent>())).xclient as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).xclient) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -32963,7 +23802,7 @@ fn bindgen_test_layout__XEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<_XEvent>())).xmapping as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).xmapping) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -32973,7 +23812,7 @@ fn bindgen_test_layout__XEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<_XEvent>())).xerror as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).xerror) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -32983,7 +23822,7 @@ fn bindgen_test_layout__XEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<_XEvent>())).xkeymap as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).xkeymap) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -32993,7 +23832,7 @@ fn bindgen_test_layout__XEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<_XEvent>())).xgeneric as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).xgeneric) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -33003,7 +23842,7 @@ fn bindgen_test_layout__XEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<_XEvent>())).xcookie as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).xcookie) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -33013,7 +23852,7 @@ fn bindgen_test_layout__XEvent() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<_XEvent>())).pad as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).pad) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -33036,6 +23875,8 @@ pub struct XCharStruct {
 }
 #[test]
 fn bindgen_test_layout_XCharStruct() {
+    const UNINIT: ::core::mem::MaybeUninit<XCharStruct> = ::core::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::core::mem::size_of::<XCharStruct>(),
         12usize,
@@ -33047,7 +23888,7 @@ fn bindgen_test_layout_XCharStruct() {
         concat!("Alignment of ", stringify!(XCharStruct))
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XCharStruct>())).lbearing as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).lbearing) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -33057,7 +23898,7 @@ fn bindgen_test_layout_XCharStruct() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XCharStruct>())).rbearing as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).rbearing) as usize - ptr as usize },
         2usize,
         concat!(
             "Offset of field: ",
@@ -33067,7 +23908,7 @@ fn bindgen_test_layout_XCharStruct() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XCharStruct>())).width as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).width) as usize - ptr as usize },
         4usize,
         concat!(
             "Offset of field: ",
@@ -33077,7 +23918,7 @@ fn bindgen_test_layout_XCharStruct() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XCharStruct>())).ascent as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).ascent) as usize - ptr as usize },
         6usize,
         concat!(
             "Offset of field: ",
@@ -33087,7 +23928,7 @@ fn bindgen_test_layout_XCharStruct() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XCharStruct>())).descent as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).descent) as usize - ptr as usize },
         8usize,
         concat!(
             "Offset of field: ",
@@ -33097,7 +23938,7 @@ fn bindgen_test_layout_XCharStruct() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XCharStruct>())).attributes as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).attributes) as usize - ptr as usize },
         10usize,
         concat!(
             "Offset of field: ",
@@ -33115,6 +23956,8 @@ pub struct XFontProp {
 }
 #[test]
 fn bindgen_test_layout_XFontProp() {
+    const UNINIT: ::core::mem::MaybeUninit<XFontProp> = ::core::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::core::mem::size_of::<XFontProp>(),
         16usize,
@@ -33126,7 +23969,7 @@ fn bindgen_test_layout_XFontProp() {
         concat!("Alignment of ", stringify!(XFontProp))
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XFontProp>())).name as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).name) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -33136,7 +23979,7 @@ fn bindgen_test_layout_XFontProp() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XFontProp>())).card32 as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).card32) as usize - ptr as usize },
         8usize,
         concat!(
             "Offset of field: ",
@@ -33168,6 +24011,8 @@ pub struct XFontStruct {
 }
 #[test]
 fn bindgen_test_layout_XFontStruct() {
+    const UNINIT: ::core::mem::MaybeUninit<XFontStruct> = ::core::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::core::mem::size_of::<XFontStruct>(),
         96usize,
@@ -33179,7 +24024,7 @@ fn bindgen_test_layout_XFontStruct() {
         concat!("Alignment of ", stringify!(XFontStruct))
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XFontStruct>())).ext_data as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).ext_data) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -33189,7 +24034,7 @@ fn bindgen_test_layout_XFontStruct() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XFontStruct>())).fid as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).fid) as usize - ptr as usize },
         8usize,
         concat!(
             "Offset of field: ",
@@ -33199,7 +24044,7 @@ fn bindgen_test_layout_XFontStruct() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XFontStruct>())).direction as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).direction) as usize - ptr as usize },
         16usize,
         concat!(
             "Offset of field: ",
@@ -33209,7 +24054,7 @@ fn bindgen_test_layout_XFontStruct() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XFontStruct>())).min_char_or_byte2 as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).min_char_or_byte2) as usize - ptr as usize },
         20usize,
         concat!(
             "Offset of field: ",
@@ -33219,7 +24064,7 @@ fn bindgen_test_layout_XFontStruct() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XFontStruct>())).max_char_or_byte2 as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).max_char_or_byte2) as usize - ptr as usize },
         24usize,
         concat!(
             "Offset of field: ",
@@ -33229,7 +24074,7 @@ fn bindgen_test_layout_XFontStruct() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XFontStruct>())).min_byte1 as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).min_byte1) as usize - ptr as usize },
         28usize,
         concat!(
             "Offset of field: ",
@@ -33239,7 +24084,7 @@ fn bindgen_test_layout_XFontStruct() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XFontStruct>())).max_byte1 as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).max_byte1) as usize - ptr as usize },
         32usize,
         concat!(
             "Offset of field: ",
@@ -33249,7 +24094,7 @@ fn bindgen_test_layout_XFontStruct() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XFontStruct>())).all_chars_exist as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).all_chars_exist) as usize - ptr as usize },
         36usize,
         concat!(
             "Offset of field: ",
@@ -33259,7 +24104,7 @@ fn bindgen_test_layout_XFontStruct() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XFontStruct>())).default_char as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).default_char) as usize - ptr as usize },
         40usize,
         concat!(
             "Offset of field: ",
@@ -33269,7 +24114,7 @@ fn bindgen_test_layout_XFontStruct() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XFontStruct>())).n_properties as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).n_properties) as usize - ptr as usize },
         44usize,
         concat!(
             "Offset of field: ",
@@ -33279,7 +24124,7 @@ fn bindgen_test_layout_XFontStruct() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XFontStruct>())).properties as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).properties) as usize - ptr as usize },
         48usize,
         concat!(
             "Offset of field: ",
@@ -33289,7 +24134,7 @@ fn bindgen_test_layout_XFontStruct() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XFontStruct>())).min_bounds as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).min_bounds) as usize - ptr as usize },
         56usize,
         concat!(
             "Offset of field: ",
@@ -33299,7 +24144,7 @@ fn bindgen_test_layout_XFontStruct() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XFontStruct>())).max_bounds as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).max_bounds) as usize - ptr as usize },
         68usize,
         concat!(
             "Offset of field: ",
@@ -33309,7 +24154,7 @@ fn bindgen_test_layout_XFontStruct() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XFontStruct>())).per_char as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).per_char) as usize - ptr as usize },
         80usize,
         concat!(
             "Offset of field: ",
@@ -33319,7 +24164,7 @@ fn bindgen_test_layout_XFontStruct() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XFontStruct>())).ascent as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).ascent) as usize - ptr as usize },
         88usize,
         concat!(
             "Offset of field: ",
@@ -33329,7 +24174,7 @@ fn bindgen_test_layout_XFontStruct() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XFontStruct>())).descent as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).descent) as usize - ptr as usize },
         92usize,
         concat!(
             "Offset of field: ",
@@ -33349,6 +24194,8 @@ pub struct XTextItem {
 }
 #[test]
 fn bindgen_test_layout_XTextItem() {
+    const UNINIT: ::core::mem::MaybeUninit<XTextItem> = ::core::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::core::mem::size_of::<XTextItem>(),
         24usize,
@@ -33360,7 +24207,7 @@ fn bindgen_test_layout_XTextItem() {
         concat!("Alignment of ", stringify!(XTextItem))
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XTextItem>())).chars as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).chars) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -33370,7 +24217,7 @@ fn bindgen_test_layout_XTextItem() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XTextItem>())).nchars as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).nchars) as usize - ptr as usize },
         8usize,
         concat!(
             "Offset of field: ",
@@ -33380,7 +24227,7 @@ fn bindgen_test_layout_XTextItem() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XTextItem>())).delta as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).delta) as usize - ptr as usize },
         12usize,
         concat!(
             "Offset of field: ",
@@ -33390,7 +24237,7 @@ fn bindgen_test_layout_XTextItem() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XTextItem>())).font as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).font) as usize - ptr as usize },
         16usize,
         concat!(
             "Offset of field: ",
@@ -33408,6 +24255,8 @@ pub struct XChar2b {
 }
 #[test]
 fn bindgen_test_layout_XChar2b() {
+    const UNINIT: ::core::mem::MaybeUninit<XChar2b> = ::core::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::core::mem::size_of::<XChar2b>(),
         2usize,
@@ -33419,7 +24268,7 @@ fn bindgen_test_layout_XChar2b() {
         concat!("Alignment of ", stringify!(XChar2b))
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XChar2b>())).byte1 as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).byte1) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -33429,7 +24278,7 @@ fn bindgen_test_layout_XChar2b() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XChar2b>())).byte2 as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).byte2) as usize - ptr as usize },
         1usize,
         concat!(
             "Offset of field: ",
@@ -33449,6 +24298,8 @@ pub struct XTextItem16 {
 }
 #[test]
 fn bindgen_test_layout_XTextItem16() {
+    const UNINIT: ::core::mem::MaybeUninit<XTextItem16> = ::core::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::core::mem::size_of::<XTextItem16>(),
         24usize,
@@ -33460,7 +24311,7 @@ fn bindgen_test_layout_XTextItem16() {
         concat!("Alignment of ", stringify!(XTextItem16))
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XTextItem16>())).chars as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).chars) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -33470,7 +24321,7 @@ fn bindgen_test_layout_XTextItem16() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XTextItem16>())).nchars as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).nchars) as usize - ptr as usize },
         8usize,
         concat!(
             "Offset of field: ",
@@ -33480,7 +24331,7 @@ fn bindgen_test_layout_XTextItem16() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XTextItem16>())).delta as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).delta) as usize - ptr as usize },
         12usize,
         concat!(
             "Offset of field: ",
@@ -33490,7 +24341,7 @@ fn bindgen_test_layout_XTextItem16() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XTextItem16>())).font as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).font) as usize - ptr as usize },
         16usize,
         concat!(
             "Offset of field: ",
@@ -33509,10 +24360,11 @@ pub union XEDataObject {
     pub screen: *mut Screen,
     pub pixmap_format: *mut ScreenFormat,
     pub font: *mut XFontStruct,
-    _bindgen_union_align: u64,
 }
 #[test]
 fn bindgen_test_layout_XEDataObject() {
+    const UNINIT: ::core::mem::MaybeUninit<XEDataObject> = ::core::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::core::mem::size_of::<XEDataObject>(),
         8usize,
@@ -33524,7 +24376,7 @@ fn bindgen_test_layout_XEDataObject() {
         concat!("Alignment of ", stringify!(XEDataObject))
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XEDataObject>())).display as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).display) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -33534,7 +24386,7 @@ fn bindgen_test_layout_XEDataObject() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XEDataObject>())).gc as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).gc) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -33544,7 +24396,7 @@ fn bindgen_test_layout_XEDataObject() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XEDataObject>())).visual as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).visual) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -33554,7 +24406,7 @@ fn bindgen_test_layout_XEDataObject() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XEDataObject>())).screen as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).screen) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -33564,7 +24416,7 @@ fn bindgen_test_layout_XEDataObject() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XEDataObject>())).pixmap_format as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).pixmap_format) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -33574,7 +24426,7 @@ fn bindgen_test_layout_XEDataObject() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XEDataObject>())).font as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).font) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -33592,6 +24444,8 @@ pub struct XFontSetExtents {
 }
 #[test]
 fn bindgen_test_layout_XFontSetExtents() {
+    const UNINIT: ::core::mem::MaybeUninit<XFontSetExtents> = ::core::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::core::mem::size_of::<XFontSetExtents>(),
         16usize,
@@ -33603,7 +24457,7 @@ fn bindgen_test_layout_XFontSetExtents() {
         concat!("Alignment of ", stringify!(XFontSetExtents))
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XFontSetExtents>())).max_ink_extent as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).max_ink_extent) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -33613,9 +24467,7 @@ fn bindgen_test_layout_XFontSetExtents() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::core::ptr::null::<XFontSetExtents>())).max_logical_extent as *const _ as usize
-        },
+        unsafe { ::core::ptr::addr_of!((*ptr).max_logical_extent) as usize - ptr as usize },
         8usize,
         concat!(
             "Offset of field: ",
@@ -33648,6 +24500,8 @@ pub struct XmbTextItem {
 }
 #[test]
 fn bindgen_test_layout_XmbTextItem() {
+    const UNINIT: ::core::mem::MaybeUninit<XmbTextItem> = ::core::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::core::mem::size_of::<XmbTextItem>(),
         24usize,
@@ -33659,7 +24513,7 @@ fn bindgen_test_layout_XmbTextItem() {
         concat!("Alignment of ", stringify!(XmbTextItem))
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XmbTextItem>())).chars as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).chars) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -33669,7 +24523,7 @@ fn bindgen_test_layout_XmbTextItem() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XmbTextItem>())).nchars as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).nchars) as usize - ptr as usize },
         8usize,
         concat!(
             "Offset of field: ",
@@ -33679,7 +24533,7 @@ fn bindgen_test_layout_XmbTextItem() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XmbTextItem>())).delta as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).delta) as usize - ptr as usize },
         12usize,
         concat!(
             "Offset of field: ",
@@ -33689,7 +24543,7 @@ fn bindgen_test_layout_XmbTextItem() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XmbTextItem>())).font_set as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).font_set) as usize - ptr as usize },
         16usize,
         concat!(
             "Offset of field: ",
@@ -33709,6 +24563,8 @@ pub struct XwcTextItem {
 }
 #[test]
 fn bindgen_test_layout_XwcTextItem() {
+    const UNINIT: ::core::mem::MaybeUninit<XwcTextItem> = ::core::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::core::mem::size_of::<XwcTextItem>(),
         24usize,
@@ -33720,7 +24576,7 @@ fn bindgen_test_layout_XwcTextItem() {
         concat!("Alignment of ", stringify!(XwcTextItem))
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XwcTextItem>())).chars as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).chars) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -33730,7 +24586,7 @@ fn bindgen_test_layout_XwcTextItem() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XwcTextItem>())).nchars as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).nchars) as usize - ptr as usize },
         8usize,
         concat!(
             "Offset of field: ",
@@ -33740,7 +24596,7 @@ fn bindgen_test_layout_XwcTextItem() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XwcTextItem>())).delta as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).delta) as usize - ptr as usize },
         12usize,
         concat!(
             "Offset of field: ",
@@ -33750,7 +24606,7 @@ fn bindgen_test_layout_XwcTextItem() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XwcTextItem>())).font_set as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).font_set) as usize - ptr as usize },
         16usize,
         concat!(
             "Offset of field: ",
@@ -33768,6 +24624,8 @@ pub struct XOMCharSetList {
 }
 #[test]
 fn bindgen_test_layout_XOMCharSetList() {
+    const UNINIT: ::core::mem::MaybeUninit<XOMCharSetList> = ::core::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::core::mem::size_of::<XOMCharSetList>(),
         16usize,
@@ -33779,7 +24637,7 @@ fn bindgen_test_layout_XOMCharSetList() {
         concat!("Alignment of ", stringify!(XOMCharSetList))
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XOMCharSetList>())).charset_count as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).charset_count) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -33789,7 +24647,7 @@ fn bindgen_test_layout_XOMCharSetList() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XOMCharSetList>())).charset_list as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).charset_list) as usize - ptr as usize },
         8usize,
         concat!(
             "Offset of field: ",
@@ -33800,7 +24658,7 @@ fn bindgen_test_layout_XOMCharSetList() {
     );
 }
 #[repr(u32)]
-#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
+#[derive(Copy, Clone, Hash, PartialEq, Eq)]
 pub enum XOrientation {
     XOMOrientation_LTR_TTB = 0,
     XOMOrientation_RTL_TTB = 1,
@@ -33816,6 +24674,8 @@ pub struct XOMOrientation {
 }
 #[test]
 fn bindgen_test_layout_XOMOrientation() {
+    const UNINIT: ::core::mem::MaybeUninit<XOMOrientation> = ::core::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::core::mem::size_of::<XOMOrientation>(),
         16usize,
@@ -33827,7 +24687,7 @@ fn bindgen_test_layout_XOMOrientation() {
         concat!("Alignment of ", stringify!(XOMOrientation))
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XOMOrientation>())).num_orientation as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).num_orientation) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -33837,7 +24697,7 @@ fn bindgen_test_layout_XOMOrientation() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XOMOrientation>())).orientation as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).orientation) as usize - ptr as usize },
         8usize,
         concat!(
             "Offset of field: ",
@@ -33856,6 +24716,8 @@ pub struct XOMFontInfo {
 }
 #[test]
 fn bindgen_test_layout_XOMFontInfo() {
+    const UNINIT: ::core::mem::MaybeUninit<XOMFontInfo> = ::core::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::core::mem::size_of::<XOMFontInfo>(),
         24usize,
@@ -33867,7 +24729,7 @@ fn bindgen_test_layout_XOMFontInfo() {
         concat!("Alignment of ", stringify!(XOMFontInfo))
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XOMFontInfo>())).num_font as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).num_font) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -33877,7 +24739,7 @@ fn bindgen_test_layout_XOMFontInfo() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XOMFontInfo>())).font_struct_list as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).font_struct_list) as usize - ptr as usize },
         8usize,
         concat!(
             "Offset of field: ",
@@ -33887,7 +24749,7 @@ fn bindgen_test_layout_XOMFontInfo() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XOMFontInfo>())).font_name_list as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).font_name_list) as usize - ptr as usize },
         16usize,
         concat!(
             "Offset of field: ",
@@ -33926,6 +24788,8 @@ pub struct XIMStyles {
 }
 #[test]
 fn bindgen_test_layout_XIMStyles() {
+    const UNINIT: ::core::mem::MaybeUninit<XIMStyles> = ::core::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::core::mem::size_of::<XIMStyles>(),
         16usize,
@@ -33937,7 +24801,7 @@ fn bindgen_test_layout_XIMStyles() {
         concat!("Alignment of ", stringify!(XIMStyles))
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XIMStyles>())).count_styles as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).count_styles) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -33947,7 +24811,7 @@ fn bindgen_test_layout_XIMStyles() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XIMStyles>())).supported_styles as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).supported_styles) as usize - ptr as usize },
         8usize,
         concat!(
             "Offset of field: ",
@@ -33966,6 +24830,8 @@ pub struct XIMCallback {
 }
 #[test]
 fn bindgen_test_layout_XIMCallback() {
+    const UNINIT: ::core::mem::MaybeUninit<XIMCallback> = ::core::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::core::mem::size_of::<XIMCallback>(),
         16usize,
@@ -33977,7 +24843,7 @@ fn bindgen_test_layout_XIMCallback() {
         concat!("Alignment of ", stringify!(XIMCallback))
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XIMCallback>())).client_data as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).client_data) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -33987,7 +24853,7 @@ fn bindgen_test_layout_XIMCallback() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XIMCallback>())).callback as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).callback) as usize - ptr as usize },
         8usize,
         concat!(
             "Offset of field: ",
@@ -34005,6 +24871,8 @@ pub struct XICCallback {
 }
 #[test]
 fn bindgen_test_layout_XICCallback() {
+    const UNINIT: ::core::mem::MaybeUninit<XICCallback> = ::core::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::core::mem::size_of::<XICCallback>(),
         16usize,
@@ -34016,7 +24884,7 @@ fn bindgen_test_layout_XICCallback() {
         concat!("Alignment of ", stringify!(XICCallback))
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XICCallback>())).client_data as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).client_data) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -34026,7 +24894,7 @@ fn bindgen_test_layout_XICCallback() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XICCallback>())).callback as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).callback) as usize - ptr as usize },
         8usize,
         concat!(
             "Offset of field: ",
@@ -34050,10 +24918,12 @@ pub struct _XIMText {
 pub union _XIMText__bindgen_ty_1 {
     pub multi_byte: *mut libc::c_char,
     pub wide_char: *mut wchar_t,
-    _bindgen_union_align: u64,
 }
 #[test]
 fn bindgen_test_layout__XIMText__bindgen_ty_1() {
+    const UNINIT: ::core::mem::MaybeUninit<_XIMText__bindgen_ty_1> =
+        ::core::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::core::mem::size_of::<_XIMText__bindgen_ty_1>(),
         8usize,
@@ -34065,9 +24935,7 @@ fn bindgen_test_layout__XIMText__bindgen_ty_1() {
         concat!("Alignment of ", stringify!(_XIMText__bindgen_ty_1))
     );
     assert_eq!(
-        unsafe {
-            &(*(::core::ptr::null::<_XIMText__bindgen_ty_1>())).multi_byte as *const _ as usize
-        },
+        unsafe { ::core::ptr::addr_of!((*ptr).multi_byte) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -34077,9 +24945,7 @@ fn bindgen_test_layout__XIMText__bindgen_ty_1() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::core::ptr::null::<_XIMText__bindgen_ty_1>())).wide_char as *const _ as usize
-        },
+        unsafe { ::core::ptr::addr_of!((*ptr).wide_char) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -34091,6 +24957,8 @@ fn bindgen_test_layout__XIMText__bindgen_ty_1() {
 }
 #[test]
 fn bindgen_test_layout__XIMText() {
+    const UNINIT: ::core::mem::MaybeUninit<_XIMText> = ::core::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::core::mem::size_of::<_XIMText>(),
         32usize,
@@ -34102,7 +24970,7 @@ fn bindgen_test_layout__XIMText() {
         concat!("Alignment of ", stringify!(_XIMText))
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<_XIMText>())).length as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).length) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -34112,7 +24980,7 @@ fn bindgen_test_layout__XIMText() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<_XIMText>())).feedback as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).feedback) as usize - ptr as usize },
         8usize,
         concat!(
             "Offset of field: ",
@@ -34122,7 +24990,7 @@ fn bindgen_test_layout__XIMText() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<_XIMText>())).encoding_is_wchar as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).encoding_is_wchar) as usize - ptr as usize },
         16usize,
         concat!(
             "Offset of field: ",
@@ -34132,7 +25000,7 @@ fn bindgen_test_layout__XIMText() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<_XIMText>())).string as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).string) as usize - ptr as usize },
         24usize,
         concat!(
             "Offset of field: ",
@@ -34151,6 +25019,9 @@ pub struct _XIMPreeditStateNotifyCallbackStruct {
 }
 #[test]
 fn bindgen_test_layout__XIMPreeditStateNotifyCallbackStruct() {
+    const UNINIT: ::core::mem::MaybeUninit<_XIMPreeditStateNotifyCallbackStruct> =
+        ::core::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::core::mem::size_of::<_XIMPreeditStateNotifyCallbackStruct>(),
         8usize,
@@ -34168,10 +25039,7 @@ fn bindgen_test_layout__XIMPreeditStateNotifyCallbackStruct() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::core::ptr::null::<_XIMPreeditStateNotifyCallbackStruct>())).state as *const _
-                as usize
-        },
+        unsafe { ::core::ptr::addr_of!((*ptr).state) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -34197,10 +25065,12 @@ pub struct _XIMStringConversionText {
 pub union _XIMStringConversionText__bindgen_ty_1 {
     pub mbs: *mut libc::c_char,
     pub wcs: *mut wchar_t,
-    _bindgen_union_align: u64,
 }
 #[test]
 fn bindgen_test_layout__XIMStringConversionText__bindgen_ty_1() {
+    const UNINIT: ::core::mem::MaybeUninit<_XIMStringConversionText__bindgen_ty_1> =
+        ::core::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::core::mem::size_of::<_XIMStringConversionText__bindgen_ty_1>(),
         8usize,
@@ -34218,10 +25088,7 @@ fn bindgen_test_layout__XIMStringConversionText__bindgen_ty_1() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::core::ptr::null::<_XIMStringConversionText__bindgen_ty_1>())).mbs as *const _
-                as usize
-        },
+        unsafe { ::core::ptr::addr_of!((*ptr).mbs) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -34231,10 +25098,7 @@ fn bindgen_test_layout__XIMStringConversionText__bindgen_ty_1() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::core::ptr::null::<_XIMStringConversionText__bindgen_ty_1>())).wcs as *const _
-                as usize
-        },
+        unsafe { ::core::ptr::addr_of!((*ptr).wcs) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -34246,6 +25110,9 @@ fn bindgen_test_layout__XIMStringConversionText__bindgen_ty_1() {
 }
 #[test]
 fn bindgen_test_layout__XIMStringConversionText() {
+    const UNINIT: ::core::mem::MaybeUninit<_XIMStringConversionText> =
+        ::core::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::core::mem::size_of::<_XIMStringConversionText>(),
         32usize,
@@ -34257,9 +25124,7 @@ fn bindgen_test_layout__XIMStringConversionText() {
         concat!("Alignment of ", stringify!(_XIMStringConversionText))
     );
     assert_eq!(
-        unsafe {
-            &(*(::core::ptr::null::<_XIMStringConversionText>())).length as *const _ as usize
-        },
+        unsafe { ::core::ptr::addr_of!((*ptr).length) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -34269,9 +25134,7 @@ fn bindgen_test_layout__XIMStringConversionText() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::core::ptr::null::<_XIMStringConversionText>())).feedback as *const _ as usize
-        },
+        unsafe { ::core::ptr::addr_of!((*ptr).feedback) as usize - ptr as usize },
         8usize,
         concat!(
             "Offset of field: ",
@@ -34281,10 +25144,7 @@ fn bindgen_test_layout__XIMStringConversionText() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::core::ptr::null::<_XIMStringConversionText>())).encoding_is_wchar as *const _
-                as usize
-        },
+        unsafe { ::core::ptr::addr_of!((*ptr).encoding_is_wchar) as usize - ptr as usize },
         16usize,
         concat!(
             "Offset of field: ",
@@ -34294,9 +25154,7 @@ fn bindgen_test_layout__XIMStringConversionText() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::core::ptr::null::<_XIMStringConversionText>())).string as *const _ as usize
-        },
+        unsafe { ::core::ptr::addr_of!((*ptr).string) as usize - ptr as usize },
         24usize,
         concat!(
             "Offset of field: ",
@@ -34311,7 +25169,7 @@ pub type XIMStringConversionPosition = libc::c_ushort;
 pub type XIMStringConversionType = libc::c_ushort;
 pub type XIMStringConversionOperation = libc::c_ushort;
 #[repr(u32)]
-#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
+#[derive(Copy, Clone, Hash, PartialEq, Eq)]
 pub enum XIMCaretDirection {
     XIMForwardChar = 0,
     XIMBackwardChar = 1,
@@ -34337,6 +25195,9 @@ pub struct _XIMStringConversionCallbackStruct {
 }
 #[test]
 fn bindgen_test_layout__XIMStringConversionCallbackStruct() {
+    const UNINIT: ::core::mem::MaybeUninit<_XIMStringConversionCallbackStruct> =
+        ::core::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::core::mem::size_of::<_XIMStringConversionCallbackStruct>(),
         24usize,
@@ -34351,10 +25212,7 @@ fn bindgen_test_layout__XIMStringConversionCallbackStruct() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::core::ptr::null::<_XIMStringConversionCallbackStruct>())).position as *const _
-                as usize
-        },
+        unsafe { ::core::ptr::addr_of!((*ptr).position) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -34364,10 +25222,7 @@ fn bindgen_test_layout__XIMStringConversionCallbackStruct() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::core::ptr::null::<_XIMStringConversionCallbackStruct>())).direction as *const _
-                as usize
-        },
+        unsafe { ::core::ptr::addr_of!((*ptr).direction) as usize - ptr as usize },
         4usize,
         concat!(
             "Offset of field: ",
@@ -34377,10 +25232,7 @@ fn bindgen_test_layout__XIMStringConversionCallbackStruct() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::core::ptr::null::<_XIMStringConversionCallbackStruct>())).operation as *const _
-                as usize
-        },
+        unsafe { ::core::ptr::addr_of!((*ptr).operation) as usize - ptr as usize },
         8usize,
         concat!(
             "Offset of field: ",
@@ -34390,10 +25242,7 @@ fn bindgen_test_layout__XIMStringConversionCallbackStruct() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::core::ptr::null::<_XIMStringConversionCallbackStruct>())).factor as *const _
-                as usize
-        },
+        unsafe { ::core::ptr::addr_of!((*ptr).factor) as usize - ptr as usize },
         10usize,
         concat!(
             "Offset of field: ",
@@ -34403,10 +25252,7 @@ fn bindgen_test_layout__XIMStringConversionCallbackStruct() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::core::ptr::null::<_XIMStringConversionCallbackStruct>())).text as *const _
-                as usize
-        },
+        unsafe { ::core::ptr::addr_of!((*ptr).text) as usize - ptr as usize },
         16usize,
         concat!(
             "Offset of field: ",
@@ -34427,6 +25273,9 @@ pub struct _XIMPreeditDrawCallbackStruct {
 }
 #[test]
 fn bindgen_test_layout__XIMPreeditDrawCallbackStruct() {
+    const UNINIT: ::core::mem::MaybeUninit<_XIMPreeditDrawCallbackStruct> =
+        ::core::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::core::mem::size_of::<_XIMPreeditDrawCallbackStruct>(),
         24usize,
@@ -34438,9 +25287,7 @@ fn bindgen_test_layout__XIMPreeditDrawCallbackStruct() {
         concat!("Alignment of ", stringify!(_XIMPreeditDrawCallbackStruct))
     );
     assert_eq!(
-        unsafe {
-            &(*(::core::ptr::null::<_XIMPreeditDrawCallbackStruct>())).caret as *const _ as usize
-        },
+        unsafe { ::core::ptr::addr_of!((*ptr).caret) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -34450,10 +25297,7 @@ fn bindgen_test_layout__XIMPreeditDrawCallbackStruct() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::core::ptr::null::<_XIMPreeditDrawCallbackStruct>())).chg_first as *const _
-                as usize
-        },
+        unsafe { ::core::ptr::addr_of!((*ptr).chg_first) as usize - ptr as usize },
         4usize,
         concat!(
             "Offset of field: ",
@@ -34463,10 +25307,7 @@ fn bindgen_test_layout__XIMPreeditDrawCallbackStruct() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::core::ptr::null::<_XIMPreeditDrawCallbackStruct>())).chg_length as *const _
-                as usize
-        },
+        unsafe { ::core::ptr::addr_of!((*ptr).chg_length) as usize - ptr as usize },
         8usize,
         concat!(
             "Offset of field: ",
@@ -34476,9 +25317,7 @@ fn bindgen_test_layout__XIMPreeditDrawCallbackStruct() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::core::ptr::null::<_XIMPreeditDrawCallbackStruct>())).text as *const _ as usize
-        },
+        unsafe { ::core::ptr::addr_of!((*ptr).text) as usize - ptr as usize },
         16usize,
         concat!(
             "Offset of field: ",
@@ -34490,7 +25329,7 @@ fn bindgen_test_layout__XIMPreeditDrawCallbackStruct() {
 }
 pub type XIMPreeditDrawCallbackStruct = _XIMPreeditDrawCallbackStruct;
 #[repr(u32)]
-#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
+#[derive(Copy, Clone, Hash, PartialEq, Eq)]
 pub enum XIMCaretStyle {
     XIMIsInvisible = 0,
     XIMIsPrimary = 1,
@@ -34505,6 +25344,9 @@ pub struct _XIMPreeditCaretCallbackStruct {
 }
 #[test]
 fn bindgen_test_layout__XIMPreeditCaretCallbackStruct() {
+    const UNINIT: ::core::mem::MaybeUninit<_XIMPreeditCaretCallbackStruct> =
+        ::core::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::core::mem::size_of::<_XIMPreeditCaretCallbackStruct>(),
         12usize,
@@ -34516,10 +25358,7 @@ fn bindgen_test_layout__XIMPreeditCaretCallbackStruct() {
         concat!("Alignment of ", stringify!(_XIMPreeditCaretCallbackStruct))
     );
     assert_eq!(
-        unsafe {
-            &(*(::core::ptr::null::<_XIMPreeditCaretCallbackStruct>())).position as *const _
-                as usize
-        },
+        unsafe { ::core::ptr::addr_of!((*ptr).position) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -34529,10 +25368,7 @@ fn bindgen_test_layout__XIMPreeditCaretCallbackStruct() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::core::ptr::null::<_XIMPreeditCaretCallbackStruct>())).direction as *const _
-                as usize
-        },
+        unsafe { ::core::ptr::addr_of!((*ptr).direction) as usize - ptr as usize },
         4usize,
         concat!(
             "Offset of field: ",
@@ -34542,9 +25378,7 @@ fn bindgen_test_layout__XIMPreeditCaretCallbackStruct() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::core::ptr::null::<_XIMPreeditCaretCallbackStruct>())).style as *const _ as usize
-        },
+        unsafe { ::core::ptr::addr_of!((*ptr).style) as usize - ptr as usize },
         8usize,
         concat!(
             "Offset of field: ",
@@ -34556,7 +25390,7 @@ fn bindgen_test_layout__XIMPreeditCaretCallbackStruct() {
 }
 pub type XIMPreeditCaretCallbackStruct = _XIMPreeditCaretCallbackStruct;
 #[repr(u32)]
-#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
+#[derive(Copy, Clone, Hash, PartialEq, Eq)]
 pub enum XIMStatusDataType {
     XIMTextType = 0,
     XIMBitmapType = 1,
@@ -34572,10 +25406,12 @@ pub struct _XIMStatusDrawCallbackStruct {
 pub union _XIMStatusDrawCallbackStruct__bindgen_ty_1 {
     pub text: *mut XIMText,
     pub bitmap: Pixmap,
-    _bindgen_union_align: u64,
 }
 #[test]
 fn bindgen_test_layout__XIMStatusDrawCallbackStruct__bindgen_ty_1() {
+    const UNINIT: ::core::mem::MaybeUninit<_XIMStatusDrawCallbackStruct__bindgen_ty_1> =
+        ::core::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::core::mem::size_of::<_XIMStatusDrawCallbackStruct__bindgen_ty_1>(),
         8usize,
@@ -34593,10 +25429,7 @@ fn bindgen_test_layout__XIMStatusDrawCallbackStruct__bindgen_ty_1() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::core::ptr::null::<_XIMStatusDrawCallbackStruct__bindgen_ty_1>())).text as *const _
-                as usize
-        },
+        unsafe { ::core::ptr::addr_of!((*ptr).text) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -34606,10 +25439,7 @@ fn bindgen_test_layout__XIMStatusDrawCallbackStruct__bindgen_ty_1() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::core::ptr::null::<_XIMStatusDrawCallbackStruct__bindgen_ty_1>())).bitmap
-                as *const _ as usize
-        },
+        unsafe { ::core::ptr::addr_of!((*ptr).bitmap) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -34621,6 +25451,9 @@ fn bindgen_test_layout__XIMStatusDrawCallbackStruct__bindgen_ty_1() {
 }
 #[test]
 fn bindgen_test_layout__XIMStatusDrawCallbackStruct() {
+    const UNINIT: ::core::mem::MaybeUninit<_XIMStatusDrawCallbackStruct> =
+        ::core::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::core::mem::size_of::<_XIMStatusDrawCallbackStruct>(),
         16usize,
@@ -34632,9 +25465,7 @@ fn bindgen_test_layout__XIMStatusDrawCallbackStruct() {
         concat!("Alignment of ", stringify!(_XIMStatusDrawCallbackStruct))
     );
     assert_eq!(
-        unsafe {
-            &(*(::core::ptr::null::<_XIMStatusDrawCallbackStruct>())).type_ as *const _ as usize
-        },
+        unsafe { ::core::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -34644,9 +25475,7 @@ fn bindgen_test_layout__XIMStatusDrawCallbackStruct() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::core::ptr::null::<_XIMStatusDrawCallbackStruct>())).data as *const _ as usize
-        },
+        unsafe { ::core::ptr::addr_of!((*ptr).data) as usize - ptr as usize },
         8usize,
         concat!(
             "Offset of field: ",
@@ -34666,6 +25495,8 @@ pub struct _XIMHotKeyTrigger {
 }
 #[test]
 fn bindgen_test_layout__XIMHotKeyTrigger() {
+    const UNINIT: ::core::mem::MaybeUninit<_XIMHotKeyTrigger> = ::core::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::core::mem::size_of::<_XIMHotKeyTrigger>(),
         16usize,
@@ -34677,7 +25508,7 @@ fn bindgen_test_layout__XIMHotKeyTrigger() {
         concat!("Alignment of ", stringify!(_XIMHotKeyTrigger))
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<_XIMHotKeyTrigger>())).keysym as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).keysym) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -34687,7 +25518,7 @@ fn bindgen_test_layout__XIMHotKeyTrigger() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<_XIMHotKeyTrigger>())).modifier as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).modifier) as usize - ptr as usize },
         8usize,
         concat!(
             "Offset of field: ",
@@ -34697,9 +25528,7 @@ fn bindgen_test_layout__XIMHotKeyTrigger() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::core::ptr::null::<_XIMHotKeyTrigger>())).modifier_mask as *const _ as usize
-        },
+        unsafe { ::core::ptr::addr_of!((*ptr).modifier_mask) as usize - ptr as usize },
         12usize,
         concat!(
             "Offset of field: ",
@@ -34718,6 +25547,8 @@ pub struct _XIMHotKeyTriggers {
 }
 #[test]
 fn bindgen_test_layout__XIMHotKeyTriggers() {
+    const UNINIT: ::core::mem::MaybeUninit<_XIMHotKeyTriggers> = ::core::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::core::mem::size_of::<_XIMHotKeyTriggers>(),
         16usize,
@@ -34729,7 +25560,7 @@ fn bindgen_test_layout__XIMHotKeyTriggers() {
         concat!("Alignment of ", stringify!(_XIMHotKeyTriggers))
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<_XIMHotKeyTriggers>())).num_hot_key as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).num_hot_key) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -34739,7 +25570,7 @@ fn bindgen_test_layout__XIMHotKeyTriggers() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<_XIMHotKeyTriggers>())).key as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).key) as usize - ptr as usize },
         8usize,
         concat!(
             "Offset of field: ",
@@ -34759,6 +25590,8 @@ pub struct XIMValuesList {
 }
 #[test]
 fn bindgen_test_layout_XIMValuesList() {
+    const UNINIT: ::core::mem::MaybeUninit<XIMValuesList> = ::core::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::core::mem::size_of::<XIMValuesList>(),
         16usize,
@@ -34770,7 +25603,7 @@ fn bindgen_test_layout_XIMValuesList() {
         concat!("Alignment of ", stringify!(XIMValuesList))
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XIMValuesList>())).count_values as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).count_values) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -34780,7 +25613,7 @@ fn bindgen_test_layout_XIMValuesList() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<XIMValuesList>())).supported_values as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).supported_values) as usize - ptr as usize },
         8usize,
         concat!(
             "Offset of field: ",
@@ -35136,6 +25969,9 @@ extern "C" {
 extern "C" {
     pub fn XInitThreads() -> libc::c_int;
 }
+extern "C" {
+    pub fn XFreeThreads() -> libc::c_int;
+}
 extern "C" {
     pub fn XLockDisplay(arg1: *mut Display);
 }
@@ -37257,7 +28093,7 @@ extern "C" {
 }
 #[repr(u32)]
 #[doc = "  These are the various supported windowing subsystems"]
-#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
+#[derive(Copy, Clone, Hash, PartialEq, Eq)]
 pub enum SDL_SYSWM_TYPE {
     SDL_SYSWM_UNKNOWN = 0,
     SDL_SYSWM_WINDOWS = 1,
@@ -37288,7 +28124,6 @@ pub struct SDL_SysWMmsg {
 pub union SDL_SysWMmsg__bindgen_ty_1 {
     pub x11: SDL_SysWMmsg__bindgen_ty_1__bindgen_ty_1,
     pub dummy: libc::c_int,
-    _bindgen_union_align: [u64; 24usize],
 }
 #[repr(C)]
 #[derive(Copy, Clone)]
@@ -37297,6 +28132,9 @@ pub struct SDL_SysWMmsg__bindgen_ty_1__bindgen_ty_1 {
 }
 #[test]
 fn bindgen_test_layout_SDL_SysWMmsg__bindgen_ty_1__bindgen_ty_1() {
+    const UNINIT: ::core::mem::MaybeUninit<SDL_SysWMmsg__bindgen_ty_1__bindgen_ty_1> =
+        ::core::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::core::mem::size_of::<SDL_SysWMmsg__bindgen_ty_1__bindgen_ty_1>(),
         192usize,
@@ -37314,10 +28152,7 @@ fn bindgen_test_layout_SDL_SysWMmsg__bindgen_ty_1__bindgen_ty_1() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::core::ptr::null::<SDL_SysWMmsg__bindgen_ty_1__bindgen_ty_1>())).event as *const _
-                as usize
-        },
+        unsafe { ::core::ptr::addr_of!((*ptr).event) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -37329,6 +28164,9 @@ fn bindgen_test_layout_SDL_SysWMmsg__bindgen_ty_1__bindgen_ty_1() {
 }
 #[test]
 fn bindgen_test_layout_SDL_SysWMmsg__bindgen_ty_1() {
+    const UNINIT: ::core::mem::MaybeUninit<SDL_SysWMmsg__bindgen_ty_1> =
+        ::core::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::core::mem::size_of::<SDL_SysWMmsg__bindgen_ty_1>(),
         192usize,
@@ -37340,7 +28178,7 @@ fn bindgen_test_layout_SDL_SysWMmsg__bindgen_ty_1() {
         concat!("Alignment of ", stringify!(SDL_SysWMmsg__bindgen_ty_1))
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_SysWMmsg__bindgen_ty_1>())).x11 as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).x11) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -37350,9 +28188,7 @@ fn bindgen_test_layout_SDL_SysWMmsg__bindgen_ty_1() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::core::ptr::null::<SDL_SysWMmsg__bindgen_ty_1>())).dummy as *const _ as usize
-        },
+        unsafe { ::core::ptr::addr_of!((*ptr).dummy) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -37364,6 +28200,8 @@ fn bindgen_test_layout_SDL_SysWMmsg__bindgen_ty_1() {
 }
 #[test]
 fn bindgen_test_layout_SDL_SysWMmsg() {
+    const UNINIT: ::core::mem::MaybeUninit<SDL_SysWMmsg> = ::core::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::core::mem::size_of::<SDL_SysWMmsg>(),
         200usize,
@@ -37375,7 +28213,7 @@ fn bindgen_test_layout_SDL_SysWMmsg() {
         concat!("Alignment of ", stringify!(SDL_SysWMmsg))
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_SysWMmsg>())).version as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).version) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -37385,7 +28223,7 @@ fn bindgen_test_layout_SDL_SysWMmsg() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_SysWMmsg>())).subsystem as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).subsystem) as usize - ptr as usize },
         4usize,
         concat!(
             "Offset of field: ",
@@ -37395,7 +28233,7 @@ fn bindgen_test_layout_SDL_SysWMmsg() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_SysWMmsg>())).msg as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).msg) as usize - ptr as usize },
         8usize,
         concat!(
             "Offset of field: ",
@@ -37405,12 +28243,7 @@ fn bindgen_test_layout_SDL_SysWMmsg() {
         )
     );
 }
-#[doc = "  \\brief SDL_syswm.h"]
-#[doc = ""]
-#[doc = "  Your application has access to a special type of event ::SDL_SYSWMEVENT,"]
-#[doc = "  which contains window-manager specific information and arrives whenever"]
-#[doc = "  an unhandled window event occurs.  This event is ignored by default, but"]
-#[doc = "  you can enable it with SDL_EventState()."]
+#[doc = "  \\brief SDL_syswm.h\n\n  Your application has access to a special type of event ::SDL_SYSWMEVENT,\n  which contains window-manager specific information and arrives whenever\n  an unhandled window event occurs.  This event is ignored by default, but\n  you can enable it with SDL_EventState()."]
 #[repr(C)]
 #[derive(Copy, Clone)]
 pub struct SDL_SysWMinfo {
@@ -37424,7 +28257,6 @@ pub union SDL_SysWMinfo__bindgen_ty_1 {
     pub x11: SDL_SysWMinfo__bindgen_ty_1__bindgen_ty_1,
     pub wl: SDL_SysWMinfo__bindgen_ty_1__bindgen_ty_2,
     pub dummy: [Uint8; 64usize],
-    _bindgen_union_align: [u64; 8usize],
 }
 #[repr(C)]
 #[derive(Copy, Clone)]
@@ -37436,6 +28268,9 @@ pub struct SDL_SysWMinfo__bindgen_ty_1__bindgen_ty_1 {
 }
 #[test]
 fn bindgen_test_layout_SDL_SysWMinfo__bindgen_ty_1__bindgen_ty_1() {
+    const UNINIT: ::core::mem::MaybeUninit<SDL_SysWMinfo__bindgen_ty_1__bindgen_ty_1> =
+        ::core::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::core::mem::size_of::<SDL_SysWMinfo__bindgen_ty_1__bindgen_ty_1>(),
         16usize,
@@ -37453,10 +28288,7 @@ fn bindgen_test_layout_SDL_SysWMinfo__bindgen_ty_1__bindgen_ty_1() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::core::ptr::null::<SDL_SysWMinfo__bindgen_ty_1__bindgen_ty_1>())).display
-                as *const _ as usize
-        },
+        unsafe { ::core::ptr::addr_of!((*ptr).display) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -37466,10 +28298,7 @@ fn bindgen_test_layout_SDL_SysWMinfo__bindgen_ty_1__bindgen_ty_1() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::core::ptr::null::<SDL_SysWMinfo__bindgen_ty_1__bindgen_ty_1>())).window
-                as *const _ as usize
-        },
+        unsafe { ::core::ptr::addr_of!((*ptr).window) as usize - ptr as usize },
         8usize,
         concat!(
             "Offset of field: ",
@@ -37494,12 +28323,19 @@ pub struct SDL_SysWMinfo__bindgen_ty_1__bindgen_ty_2 {
     pub xdg_surface: *mut xdg_surface,
     #[doc = "< Wayland xdg toplevel role"]
     pub xdg_toplevel: *mut xdg_toplevel,
+    #[doc = "< Wayland xdg popup role"]
+    pub xdg_popup: *mut xdg_popup,
+    #[doc = "< Wayland xdg positioner, for popup"]
+    pub xdg_positioner: *mut xdg_positioner,
 }
 #[test]
 fn bindgen_test_layout_SDL_SysWMinfo__bindgen_ty_1__bindgen_ty_2() {
+    const UNINIT: ::core::mem::MaybeUninit<SDL_SysWMinfo__bindgen_ty_1__bindgen_ty_2> =
+        ::core::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::core::mem::size_of::<SDL_SysWMinfo__bindgen_ty_1__bindgen_ty_2>(),
-        48usize,
+        64usize,
         concat!(
             "Size of: ",
             stringify!(SDL_SysWMinfo__bindgen_ty_1__bindgen_ty_2)
@@ -37514,10 +28350,7 @@ fn bindgen_test_layout_SDL_SysWMinfo__bindgen_ty_1__bindgen_ty_2() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::core::ptr::null::<SDL_SysWMinfo__bindgen_ty_1__bindgen_ty_2>())).display
-                as *const _ as usize
-        },
+        unsafe { ::core::ptr::addr_of!((*ptr).display) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -37527,10 +28360,7 @@ fn bindgen_test_layout_SDL_SysWMinfo__bindgen_ty_1__bindgen_ty_2() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::core::ptr::null::<SDL_SysWMinfo__bindgen_ty_1__bindgen_ty_2>())).surface
-                as *const _ as usize
-        },
+        unsafe { ::core::ptr::addr_of!((*ptr).surface) as usize - ptr as usize },
         8usize,
         concat!(
             "Offset of field: ",
@@ -37540,10 +28370,7 @@ fn bindgen_test_layout_SDL_SysWMinfo__bindgen_ty_1__bindgen_ty_2() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::core::ptr::null::<SDL_SysWMinfo__bindgen_ty_1__bindgen_ty_2>())).shell_surface
-                as *const _ as usize
-        },
+        unsafe { ::core::ptr::addr_of!((*ptr).shell_surface) as usize - ptr as usize },
         16usize,
         concat!(
             "Offset of field: ",
@@ -37553,10 +28380,7 @@ fn bindgen_test_layout_SDL_SysWMinfo__bindgen_ty_1__bindgen_ty_2() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::core::ptr::null::<SDL_SysWMinfo__bindgen_ty_1__bindgen_ty_2>())).egl_window
-                as *const _ as usize
-        },
+        unsafe { ::core::ptr::addr_of!((*ptr).egl_window) as usize - ptr as usize },
         24usize,
         concat!(
             "Offset of field: ",
@@ -37566,10 +28390,7 @@ fn bindgen_test_layout_SDL_SysWMinfo__bindgen_ty_1__bindgen_ty_2() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::core::ptr::null::<SDL_SysWMinfo__bindgen_ty_1__bindgen_ty_2>())).xdg_surface
-                as *const _ as usize
-        },
+        unsafe { ::core::ptr::addr_of!((*ptr).xdg_surface) as usize - ptr as usize },
         32usize,
         concat!(
             "Offset of field: ",
@@ -37579,10 +28400,7 @@ fn bindgen_test_layout_SDL_SysWMinfo__bindgen_ty_1__bindgen_ty_2() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::core::ptr::null::<SDL_SysWMinfo__bindgen_ty_1__bindgen_ty_2>())).xdg_toplevel
-                as *const _ as usize
-        },
+        unsafe { ::core::ptr::addr_of!((*ptr).xdg_toplevel) as usize - ptr as usize },
         40usize,
         concat!(
             "Offset of field: ",
@@ -37591,9 +28409,32 @@ fn bindgen_test_layout_SDL_SysWMinfo__bindgen_ty_1__bindgen_ty_2() {
             stringify!(xdg_toplevel)
         )
     );
+    assert_eq!(
+        unsafe { ::core::ptr::addr_of!((*ptr).xdg_popup) as usize - ptr as usize },
+        48usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(SDL_SysWMinfo__bindgen_ty_1__bindgen_ty_2),
+            "::",
+            stringify!(xdg_popup)
+        )
+    );
+    assert_eq!(
+        unsafe { ::core::ptr::addr_of!((*ptr).xdg_positioner) as usize - ptr as usize },
+        56usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(SDL_SysWMinfo__bindgen_ty_1__bindgen_ty_2),
+            "::",
+            stringify!(xdg_positioner)
+        )
+    );
 }
 #[test]
 fn bindgen_test_layout_SDL_SysWMinfo__bindgen_ty_1() {
+    const UNINIT: ::core::mem::MaybeUninit<SDL_SysWMinfo__bindgen_ty_1> =
+        ::core::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::core::mem::size_of::<SDL_SysWMinfo__bindgen_ty_1>(),
         64usize,
@@ -37605,9 +28446,7 @@ fn bindgen_test_layout_SDL_SysWMinfo__bindgen_ty_1() {
         concat!("Alignment of ", stringify!(SDL_SysWMinfo__bindgen_ty_1))
     );
     assert_eq!(
-        unsafe {
-            &(*(::core::ptr::null::<SDL_SysWMinfo__bindgen_ty_1>())).x11 as *const _ as usize
-        },
+        unsafe { ::core::ptr::addr_of!((*ptr).x11) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -37617,7 +28456,7 @@ fn bindgen_test_layout_SDL_SysWMinfo__bindgen_ty_1() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_SysWMinfo__bindgen_ty_1>())).wl as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).wl) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -37627,9 +28466,7 @@ fn bindgen_test_layout_SDL_SysWMinfo__bindgen_ty_1() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::core::ptr::null::<SDL_SysWMinfo__bindgen_ty_1>())).dummy as *const _ as usize
-        },
+        unsafe { ::core::ptr::addr_of!((*ptr).dummy) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -37641,6 +28478,8 @@ fn bindgen_test_layout_SDL_SysWMinfo__bindgen_ty_1() {
 }
 #[test]
 fn bindgen_test_layout_SDL_SysWMinfo() {
+    const UNINIT: ::core::mem::MaybeUninit<SDL_SysWMinfo> = ::core::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::core::mem::size_of::<SDL_SysWMinfo>(),
         72usize,
@@ -37652,7 +28491,7 @@ fn bindgen_test_layout_SDL_SysWMinfo() {
         concat!("Alignment of ", stringify!(SDL_SysWMinfo))
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_SysWMinfo>())).version as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).version) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -37662,7 +28501,7 @@ fn bindgen_test_layout_SDL_SysWMinfo() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_SysWMinfo>())).subsystem as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).subsystem) as usize - ptr as usize },
         4usize,
         concat!(
             "Offset of field: ",
@@ -37672,7 +28511,7 @@ fn bindgen_test_layout_SDL_SysWMinfo() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<SDL_SysWMinfo>())).info as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).info) as usize - ptr as usize },
         8usize,
         concat!(
             "Offset of field: ",
@@ -37683,21 +28522,7 @@ fn bindgen_test_layout_SDL_SysWMinfo() {
     );
 }
 extern "C" {
-    #[doc = " Get driver-specific information about a window."]
-    #[doc = ""]
-    #[doc = " You must include SDL_syswm.h for the declaration of SDL_SysWMinfo."]
-    #[doc = ""]
-    #[doc = " The caller must initialize the `info` structure's version by using"]
-    #[doc = " `SDL_VERSION(&info.version)`, and then this function will fill in the rest"]
-    #[doc = " of the structure with information about the given window."]
-    #[doc = ""]
-    #[doc = " \\param window the window about which information is being requested"]
-    #[doc = " \\param info an SDL_SysWMinfo structure filled in with window information"]
-    #[doc = " \\returns SDL_TRUE if the function is implemented and the `version` member"]
-    #[doc = "          of the `info` struct is valid, or SDL_FALSE if the information"]
-    #[doc = "          could not be retrieved; call SDL_GetError() for more information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.0."]
+    #[doc = " Get driver-specific information about a window.\n\n You must include SDL_syswm.h for the declaration of SDL_SysWMinfo.\n\n The caller must initialize the `info` structure's version by using\n `SDL_VERSION(&info.version)`, and then this function will fill in the rest\n of the structure with information about the given window.\n\n \\param window the window about which information is being requested\n \\param info an SDL_SysWMinfo structure filled in with window information\n \\returns SDL_TRUE if the function is implemented and the `version` member\n          of the `info` struct is valid, or SDL_FALSE if the information\n          could not be retrieved; call SDL_GetError() for more information.\n\n \\since This function is available since SDL 2.0.0."]
     pub fn SDL_GetWindowWMInfo(window: *mut SDL_Window, info: *mut SDL_SysWMinfo) -> SDL_bool;
 }
 #[repr(C)]
@@ -37713,93 +28538,19 @@ pub struct VkSurfaceKHR_T {
 pub type SDL_vulkanInstance = VkInstance;
 pub type SDL_vulkanSurface = VkSurfaceKHR;
 extern "C" {
-    #[doc = " Dynamically load the Vulkan loader library."]
-    #[doc = ""]
-    #[doc = " This should be called after initializing the video driver, but before"]
-    #[doc = " creating any Vulkan windows. If no Vulkan loader library is loaded, the"]
-    #[doc = " default library will be loaded upon creation of the first Vulkan window."]
-    #[doc = ""]
-    #[doc = " It is fairly common for Vulkan applications to link with libvulkan instead"]
-    #[doc = " of explicitly loading it at run time. This will work with SDL provided the"]
-    #[doc = " application links to a dynamic library and both it and SDL use the same"]
-    #[doc = " search path."]
-    #[doc = ""]
-    #[doc = " If you specify a non-NULL `path`, an application should retrieve all of the"]
-    #[doc = " Vulkan functions it uses from the dynamic library using"]
-    #[doc = " SDL_Vulkan_GetVkGetInstanceProcAddr unless you can guarantee `path` points"]
-    #[doc = " to the same vulkan loader library the application linked to."]
-    #[doc = ""]
-    #[doc = " On Apple devices, if `path` is NULL, SDL will attempt to find the"]
-    #[doc = " `vkGetInstanceProcAddr` address within all the Mach-O images of the current"]
-    #[doc = " process. This is because it is fairly common for Vulkan applications to"]
-    #[doc = " link with libvulkan (and historically MoltenVK was provided as a static"]
-    #[doc = " library). If it is not found, on macOS, SDL will attempt to load"]
-    #[doc = " `vulkan.framework/vulkan`, `libvulkan.1.dylib`,"]
-    #[doc = " `MoltenVK.framework/MoltenVK`, and `libMoltenVK.dylib`, in that order. On"]
-    #[doc = " iOS, SDL will attempt to load `libMoltenVK.dylib`. Applications using a"]
-    #[doc = " dynamic framework or .dylib must ensure it is included in its application"]
-    #[doc = " bundle."]
-    #[doc = ""]
-    #[doc = " On non-Apple devices, application linking with a static libvulkan is not"]
-    #[doc = " supported. Either do not link to the Vulkan loader or link to a dynamic"]
-    #[doc = " library version."]
-    #[doc = ""]
-    #[doc = " \\param path The platform dependent Vulkan loader library name or NULL"]
-    #[doc = " \\returns 0 on success or -1 if the library couldn't be loaded; call"]
-    #[doc = "          SDL_GetError() for more information."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.6."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_Vulkan_GetVkInstanceProcAddr"]
-    #[doc = " \\sa SDL_Vulkan_UnloadLibrary"]
+    #[doc = " Dynamically load the Vulkan loader library.\n\n This should be called after initializing the video driver, but before\n creating any Vulkan windows. If no Vulkan loader library is loaded, the\n default library will be loaded upon creation of the first Vulkan window.\n\n It is fairly common for Vulkan applications to link with libvulkan instead\n of explicitly loading it at run time. This will work with SDL provided the\n application links to a dynamic library and both it and SDL use the same\n search path.\n\n If you specify a non-NULL `path`, an application should retrieve all of the\n Vulkan functions it uses from the dynamic library using\n SDL_Vulkan_GetVkGetInstanceProcAddr unless you can guarantee `path` points\n to the same vulkan loader library the application linked to.\n\n On Apple devices, if `path` is NULL, SDL will attempt to find the\n `vkGetInstanceProcAddr` address within all the Mach-O images of the current\n process. This is because it is fairly common for Vulkan applications to\n link with libvulkan (and historically MoltenVK was provided as a static\n library). If it is not found, on macOS, SDL will attempt to load\n `vulkan.framework/vulkan`, `libvulkan.1.dylib`,\n `MoltenVK.framework/MoltenVK`, and `libMoltenVK.dylib`, in that order. On\n iOS, SDL will attempt to load `libMoltenVK.dylib`. Applications using a\n dynamic framework or .dylib must ensure it is included in its application\n bundle.\n\n On non-Apple devices, application linking with a static libvulkan is not\n supported. Either do not link to the Vulkan loader or link to a dynamic\n library version.\n\n \\param path The platform dependent Vulkan loader library name or NULL\n \\returns 0 on success or -1 if the library couldn't be loaded; call\n          SDL_GetError() for more information.\n\n \\since This function is available since SDL 2.0.6.\n\n \\sa SDL_Vulkan_GetVkInstanceProcAddr\n \\sa SDL_Vulkan_UnloadLibrary"]
     pub fn SDL_Vulkan_LoadLibrary(path: *const libc::c_char) -> libc::c_int;
 }
 extern "C" {
-    #[doc = " Get the address of the `vkGetInstanceProcAddr` function."]
-    #[doc = ""]
-    #[doc = " This should be called after either calling SDL_Vulkan_LoadLibrary() or"]
-    #[doc = " creating an SDL_Window with the `SDL_WINDOW_VULKAN` flag."]
-    #[doc = ""]
-    #[doc = " \\returns the function pointer for `vkGetInstanceProcAddr` or NULL on error."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.6."]
+    #[doc = " Get the address of the `vkGetInstanceProcAddr` function.\n\n This should be called after either calling SDL_Vulkan_LoadLibrary() or\n creating an SDL_Window with the `SDL_WINDOW_VULKAN` flag.\n\n \\returns the function pointer for `vkGetInstanceProcAddr` or NULL on error.\n\n \\since This function is available since SDL 2.0.6."]
     pub fn SDL_Vulkan_GetVkGetInstanceProcAddr() -> *mut libc::c_void;
 }
 extern "C" {
-    #[doc = " Unload the Vulkan library previously loaded by SDL_Vulkan_LoadLibrary()"]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.6."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_Vulkan_LoadLibrary"]
+    #[doc = " Unload the Vulkan library previously loaded by SDL_Vulkan_LoadLibrary()\n\n \\since This function is available since SDL 2.0.6.\n\n \\sa SDL_Vulkan_LoadLibrary"]
     pub fn SDL_Vulkan_UnloadLibrary();
 }
 extern "C" {
-    #[doc = " Get the names of the Vulkan instance extensions needed to create a surface"]
-    #[doc = " with SDL_Vulkan_CreateSurface."]
-    #[doc = ""]
-    #[doc = " If `pNames` is NULL, then the number of required Vulkan instance extensions"]
-    #[doc = " is returned in `pCount`. Otherwise, `pCount` must point to a variable set"]
-    #[doc = " to the number of elements in the `pNames` array, and on return the variable"]
-    #[doc = " is overwritten with the number of names actually written to `pNames`. If"]
-    #[doc = " `pCount` is less than the number of required extensions, at most `pCount`"]
-    #[doc = " structures will be written. If `pCount` is smaller than the number of"]
-    #[doc = " required extensions, SDL_FALSE will be returned instead of SDL_TRUE, to"]
-    #[doc = " indicate that not all the required extensions were returned."]
-    #[doc = ""]
-    #[doc = " The `window` parameter is currently needed to be valid as of SDL 2.0.8,"]
-    #[doc = " however, this parameter will likely be removed in future releases"]
-    #[doc = ""]
-    #[doc = " \\param window A window for which the required Vulkan instance extensions"]
-    #[doc = "               should be retrieved (will be deprecated in a future release)"]
-    #[doc = " \\param pCount A pointer to an unsigned int corresponding to the number of"]
-    #[doc = "               extensions to be returned"]
-    #[doc = " \\param pNames NULL or a pointer to an array to be filled with required"]
-    #[doc = "               Vulkan instance extensions"]
-    #[doc = " \\returns SDL_TRUE on success, SDL_FALSE on error."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.6."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_Vulkan_CreateSurface"]
+    #[doc = " Get the names of the Vulkan instance extensions needed to create a surface\n with SDL_Vulkan_CreateSurface.\n\n If `pNames` is NULL, then the number of required Vulkan instance extensions\n is returned in `pCount`. Otherwise, `pCount` must point to a variable set\n to the number of elements in the `pNames` array, and on return the variable\n is overwritten with the number of names actually written to `pNames`. If\n `pCount` is less than the number of required extensions, at most `pCount`\n structures will be written. If `pCount` is smaller than the number of\n required extensions, SDL_FALSE will be returned instead of SDL_TRUE, to\n indicate that not all the required extensions were returned.\n\n The `window` parameter is currently needed to be valid as of SDL 2.0.8,\n however, this parameter will likely be removed in future releases\n\n \\param window A window for which the required Vulkan instance extensions\n               should be retrieved (will be deprecated in a future release)\n \\param pCount A pointer to an unsigned int corresponding to the number of\n               extensions to be returned\n \\param pNames NULL or a pointer to an array to be filled with required\n               Vulkan instance extensions\n \\returns SDL_TRUE on success, SDL_FALSE on error.\n\n \\since This function is available since SDL 2.0.6.\n\n \\sa SDL_Vulkan_CreateSurface"]
     pub fn SDL_Vulkan_GetInstanceExtensions(
         window: *mut SDL_Window,
         pCount: *mut libc::c_uint,
@@ -37807,22 +28558,7 @@ extern "C" {
     ) -> SDL_bool;
 }
 extern "C" {
-    #[doc = " Create a Vulkan rendering surface for a window."]
-    #[doc = ""]
-    #[doc = " The `window` must have been created with the `SDL_WINDOW_VULKAN` flag and"]
-    #[doc = " `instance` must have been created with extensions returned by"]
-    #[doc = " SDL_Vulkan_GetInstanceExtensions() enabled."]
-    #[doc = ""]
-    #[doc = " \\param window The window to which to attach the Vulkan surface"]
-    #[doc = " \\param instance The Vulkan instance handle"]
-    #[doc = " \\param surface A pointer to a VkSurfaceKHR handle to output the newly"]
-    #[doc = "                created surface"]
-    #[doc = " \\returns SDL_TRUE on success, SDL_FALSE on error."]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.6."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_Vulkan_GetInstanceExtensions"]
-    #[doc = " \\sa SDL_Vulkan_GetDrawableSize"]
+    #[doc = " Create a Vulkan rendering surface for a window.\n\n The `window` must have been created with the `SDL_WINDOW_VULKAN` flag and\n `instance` must have been created with extensions returned by\n SDL_Vulkan_GetInstanceExtensions() enabled.\n\n \\param window The window to which to attach the Vulkan surface\n \\param instance The Vulkan instance handle\n \\param surface A pointer to a VkSurfaceKHR handle to output the newly\n                created surface\n \\returns SDL_TRUE on success, SDL_FALSE on error.\n\n \\since This function is available since SDL 2.0.6.\n\n \\sa SDL_Vulkan_GetInstanceExtensions\n \\sa SDL_Vulkan_GetDrawableSize"]
     pub fn SDL_Vulkan_CreateSurface(
         window: *mut SDL_Window,
         instance: VkInstance,
@@ -37830,22 +28566,7 @@ extern "C" {
     ) -> SDL_bool;
 }
 extern "C" {
-    #[doc = " Get the size of the window's underlying drawable dimensions in pixels."]
-    #[doc = ""]
-    #[doc = " This may differ from SDL_GetWindowSize() if we're rendering to a high-DPI"]
-    #[doc = " drawable, i.e. the window was created with `SDL_WINDOW_ALLOW_HIGHDPI` on a"]
-    #[doc = " platform with high-DPI support (Apple calls this \"Retina\"), and not"]
-    #[doc = " disabled by the `SDL_HINT_VIDEO_HIGHDPI_DISABLED` hint."]
-    #[doc = ""]
-    #[doc = " \\param window an SDL_Window for which the size is to be queried"]
-    #[doc = " \\param w Pointer to the variable to write the width to or NULL"]
-    #[doc = " \\param h Pointer to the variable to write the height to or NULL"]
-    #[doc = ""]
-    #[doc = " \\since This function is available since SDL 2.0.6."]
-    #[doc = ""]
-    #[doc = " \\sa SDL_GetWindowSize"]
-    #[doc = " \\sa SDL_CreateWindow"]
-    #[doc = " \\sa SDL_Vulkan_CreateSurface"]
+    #[doc = " Get the size of the window's underlying drawable dimensions in pixels.\n\n This may differ from SDL_GetWindowSize() if we're rendering to a high-DPI\n drawable, i.e. the window was created with `SDL_WINDOW_ALLOW_HIGHDPI` on a\n platform with high-DPI support (Apple calls this \"Retina\"), and not\n disabled by the `SDL_HINT_VIDEO_HIGHDPI_DISABLED` hint.\n\n \\param window an SDL_Window for which the size is to be queried\n \\param w Pointer to the variable to write the width to or NULL\n \\param h Pointer to the variable to write the height to or NULL\n\n \\since This function is available since SDL 2.0.6.\n\n \\sa SDL_GetWindowSize\n \\sa SDL_CreateWindow\n \\sa SDL_Vulkan_CreateSurface"]
     pub fn SDL_Vulkan_GetDrawableSize(
         window: *mut SDL_Window,
         w: *mut libc::c_int,
@@ -37867,6 +28588,8 @@ pub struct __va_list_tag {
 }
 #[test]
 fn bindgen_test_layout___va_list_tag() {
+    const UNINIT: ::core::mem::MaybeUninit<__va_list_tag> = ::core::mem::MaybeUninit::uninit();
+    let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::core::mem::size_of::<__va_list_tag>(),
         24usize,
@@ -37878,7 +28601,7 @@ fn bindgen_test_layout___va_list_tag() {
         concat!("Alignment of ", stringify!(__va_list_tag))
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<__va_list_tag>())).gp_offset as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).gp_offset) as usize - ptr as usize },
         0usize,
         concat!(
             "Offset of field: ",
@@ -37888,7 +28611,7 @@ fn bindgen_test_layout___va_list_tag() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<__va_list_tag>())).fp_offset as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).fp_offset) as usize - ptr as usize },
         4usize,
         concat!(
             "Offset of field: ",
@@ -37898,9 +28621,7 @@ fn bindgen_test_layout___va_list_tag() {
         )
     );
     assert_eq!(
-        unsafe {
-            &(*(::core::ptr::null::<__va_list_tag>())).overflow_arg_area as *const _ as usize
-        },
+        unsafe { ::core::ptr::addr_of!((*ptr).overflow_arg_area) as usize - ptr as usize },
         8usize,
         concat!(
             "Offset of field: ",
@@ -37910,7 +28631,7 @@ fn bindgen_test_layout___va_list_tag() {
         )
     );
     assert_eq!(
-        unsafe { &(*(::core::ptr::null::<__va_list_tag>())).reg_save_area as *const _ as usize },
+        unsafe { ::core::ptr::addr_of!((*ptr).reg_save_area) as usize - ptr as usize },
         16usize,
         concat!(
             "Offset of field: ",
@@ -37920,12 +28641,6 @@ fn bindgen_test_layout___va_list_tag() {
         )
     );
 }
-#[doc = "< Private"]
-#[repr(C)]
-#[derive(Copy, Clone)]
-pub struct SDL_BlitMap {
-    pub _address: u8,
-}
 #[doc = "< Wayland display"]
 #[repr(C)]
 #[derive(Copy, Clone)]
@@ -37956,3 +28671,15 @@ pub struct xdg_surface {
 pub struct xdg_toplevel {
     pub _address: u8,
 }
+#[doc = "< Wayland xdg popup role"]
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct xdg_popup {
+    pub _address: u8,
+}
+#[doc = "< Wayland xdg positioner, for popup"]
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct xdg_positioner {
+    pub _address: u8,
+}
diff --git a/src/sdl2/event.rs b/src/sdl2/event.rs
index e1f882de96..6ad9c0fd79 100644
--- a/src/sdl2/event.rs
+++ b/src/sdl2/event.rs
@@ -669,11 +669,19 @@ pub enum Event {
         timestamp: u32,
         window_id: u32,
         which: u32,
+        /// How much did we scroll in X, with integer precision
         x: i32,
+        /// How much did we scroll in Y, with integer precision
         y: i32,
         direction: MouseWheelDirection,
+        /// How much did we scroll in X, with floating precision (added in 2.0.18)
         precise_x: f32,
+        /// How much did we scroll in Y, with floating precision (added in 2.0.18)
         precise_y: f32,
+        /// The X position of the mouse from the window's origin
+        mouse_x: i32,
+        /// The X position of the mouse from the window's origin
+        mouse_y: i32,
     },
 
     JoyAxisMotion {
@@ -1205,6 +1213,8 @@ impl Event {
                 direction,
                 precise_x,
                 precise_y,
+                mouse_x,
+                mouse_y,
             } => {
                 let event = sys::SDL_MouseWheelEvent {
                     type_: SDL_EventType::SDL_MOUSEWHEEL as u32,
@@ -1216,6 +1226,8 @@ impl Event {
                     direction: direction.to_ll(),
                     preciseX: precise_x,
                     preciseY: precise_y,
+                    mouseX: mouse_x,
+                    mouseY: mouse_y,
                 };
                 unsafe {
                     ptr::copy(&event, ret.as_mut_ptr() as *mut sys::SDL_MouseWheelEvent, 1);
@@ -1680,6 +1692,8 @@ impl Event {
                         direction: mouse::MouseWheelDirection::from_ll(event.direction),
                         precise_x: event.preciseX,
                         precise_y: event.preciseY,
+                        mouse_x: event.mouseX,
+                        mouse_y: event.mouseY,
                     }
                 }
 
@@ -2356,6 +2370,8 @@ impl Event {
     ///     precise_y: 0.0,
     ///     x: 0,
     ///     y: 0,
+    ///     mouse_x: 0,
+    ///     mouse_y: 0,
     ///     direction: MouseWheelDirection::Normal,
     /// };
     /// assert!(ev.is_mouse());
@@ -2375,6 +2391,34 @@ impl Event {
         }
     }
 
+    /// Returns `true` if this mouse event is coming from touch.
+    ///
+    /// If used on any other kind of event, non-mouse related, this returns `false`.
+    pub fn is_touch(&self) -> bool {
+        // FIXME: Use a constant from sdl2-sys when bindgen will be fixed (see https://github.com/Rust-SDL2/rust-sdl2/issues/1265)
+        const SDL_TOUCH_MOUSEID: u32 = 0xFFFFFFFF;
+
+        match self {
+            Self::MouseMotion {
+                which: SDL_TOUCH_MOUSEID,
+                ..
+            }
+            | Self::MouseButtonDown {
+                which: SDL_TOUCH_MOUSEID,
+                ..
+            }
+            | Self::MouseButtonUp {
+                which: SDL_TOUCH_MOUSEID,
+                ..
+            }
+            | Self::MouseWheel {
+                which: SDL_TOUCH_MOUSEID,
+                ..
+            } => true,
+            _ => false,
+        }
+    }
+
     /// Returns `true` if this is a controller event.
     ///
     /// # Example
@@ -2925,6 +2969,8 @@ mod test {
                 direction: MouseWheelDirection::Flipped,
                 precise_x: 1.6,
                 precise_y: 2.7,
+                mouse_x: 0,
+                mouse_y: 5,
             };
             let e2 = Event::from_ll(e.clone().to_ll().unwrap());
             assert_eq!(e, e2);
diff --git a/src/sdl2/joystick.rs b/src/sdl2/joystick.rs
index 222a0c4dea..5fe317ae5e 100644
--- a/src/sdl2/joystick.rs
+++ b/src/sdl2/joystick.rs
@@ -118,7 +118,7 @@ impl PowerLevel {
             SDL_JoystickPowerLevel::SDL_JOYSTICK_POWER_MEDIUM => PowerLevel::Medium,
             SDL_JoystickPowerLevel::SDL_JOYSTICK_POWER_FULL => PowerLevel::Full,
             SDL_JoystickPowerLevel::SDL_JOYSTICK_POWER_WIRED => PowerLevel::Wired,
-            _ => panic!("Unexpected power level: {:?}", raw),
+            _ => panic!("Unexpected power level: {}", raw as i32),
         }
     }
 
diff --git a/src/sdl2/raw_window_handle.rs b/src/sdl2/raw_window_handle.rs
index 91c0b3c6a9..7ed209a1e6 100644
--- a/src/sdl2/raw_window_handle.rs
+++ b/src/sdl2/raw_window_handle.rs
@@ -1,8 +1,8 @@
 extern crate raw_window_handle;
 
 use self::raw_window_handle::{
-    RawDisplayHandle, RawWindowHandle,
-    HasWindowHandle, HasDisplayHandle, DisplayHandle, WindowHandle, HandleError
+    DisplayHandle, HandleError, HasDisplayHandle, HasWindowHandle, RawDisplayHandle,
+    RawWindowHandle, WindowHandle,
 };
 use crate::{sys::SDL_Window, video::Window};
 
@@ -16,7 +16,7 @@ impl HasWindowHandle for Window {
             use self::raw_window_handle::WebWindowHandle;
             let handle = WebWindowHandle::new(1);
             let handle = RawWindowHandle::Web(handle);
-            let handle = unsafe{WindowHandle::borrow_raw(handle)};
+            let handle = unsafe { WindowHandle::borrow_raw(handle) };
             return Ok(handle);
         }
 
@@ -50,7 +50,7 @@ impl HasWindowHandle for Window {
                 handle.hinstance = hinstance;
 
                 let handle = RawWindowHandle::Win32(handle);
-                let handle = unsafe {WindowHandle::borrow_raw(handle)};
+                let handle = unsafe { WindowHandle::borrow_raw(handle) };
                 Ok(handle)
             }
             #[cfg(target_os = "windows")]
@@ -67,7 +67,7 @@ impl HasWindowHandle for Window {
                 };
                 let handle = WinRtWindowHandle::new(core_window);
                 let handle = RawWindowHandle::WinRt(handle);
-                let handle = unsafe {WindowHandle::borrow_raw(handle)};
+                let handle = unsafe { WindowHandle::borrow_raw(handle) };
 
                 Ok(handle)
             }
@@ -81,21 +81,18 @@ impl HasWindowHandle for Window {
             SDL_SYSWM_WAYLAND => {
                 use self::raw_window_handle::WaylandWindowHandle;
 
-                let surf = unsafe {wm_info.info.wl}.surface as *mut libc::c_void;
+                let surf = unsafe { wm_info.info.wl }.surface as *mut libc::c_void;
                 let surf = core::ptr::NonNull::<libc::c_void>::new(surf);
 
                 match surf {
                     Some(surf) => {
                         let handle = WaylandWindowHandle::new(surf);
                         let handle = RawWindowHandle::Wayland(handle);
-                        let handle = unsafe {WindowHandle::borrow_raw(handle)};
+                        let handle = unsafe { WindowHandle::borrow_raw(handle) };
                         Ok(handle)
                     }
-                    None => {
-                        Err(HandleError::Unavailable)
-                    }
+                    None => Err(HandleError::Unavailable),
                 }
-
             }
             #[cfg(any(
                 target_os = "linux",
@@ -110,7 +107,7 @@ impl HasWindowHandle for Window {
                 let window = unsafe { wm_info.info.x11 }.window;
                 let xlib_handle = XlibWindowHandle::new(window);
                 let raw_handle = RawWindowHandle::Xlib(xlib_handle);
-                let handle = unsafe{WindowHandle::borrow_raw(raw_handle)};
+                let handle = unsafe { WindowHandle::borrow_raw(raw_handle) };
 
                 Ok(handle)
             }
@@ -125,10 +122,10 @@ impl HasWindowHandle for Window {
                         panic!("metal_view not initialized, please call WindowBuilder::metal_view() when building the window");
                     }
                 };
-                
+
                 let handle = AppKitWindowHandle::new(ns_view);
                 let handle = RawWindowHandle::AppKit(handle);
-                let handle = unsafe {WindowHandle::borrow_raw(handle)};
+                let handle = unsafe { WindowHandle::borrow_raw(handle) };
 
                 Ok(handle)
             }
@@ -150,15 +147,14 @@ impl HasWindowHandle for Window {
                 // Someone with an IOS device please test
                 let handle = UiKitWindowHandle::new(ui_window);
                 let handle = RawWindowHandle::UiKit(handle);
-                let handle = unsafe {WindowHandle::borrow_raw(handle)};
+                let handle = unsafe { WindowHandle::borrow_raw(handle) };
                 Ok(handle)
             }
             #[cfg(any(target_os = "android"))]
             SDL_SYSWM_ANDROID => {
                 use self::raw_window_handle::AndroidNdkWindowHandle;
 
-                let a_native_window =
-                    unsafe { wm_info.info.android }.window as *mut libc::c_void;
+                let a_native_window = unsafe { wm_info.info.android }.window as *mut libc::c_void;
                 let a_native_window = core::ptr::NonNull::<libc::c_void>::new(a_native_window);
                 let a_native_window = match a_native_window {
                     Some(anw) => anw,
@@ -168,7 +164,7 @@ impl HasWindowHandle for Window {
                 };
                 let handle = AndroidNdkWindowHandle::new(a_native_window);
                 let handle = RawWindowHandle::AndroidNdk(handle);
-                let handle = unsafe{WindowHandle::borrow_raw(handle)};
+                let handle = unsafe { WindowHandle::borrow_raw(handle) };
                 Ok(handle)
             }
             x => {
@@ -195,7 +191,7 @@ impl HasDisplayHandle for Window {
             use self::raw_window_handle::WebDisplayHandle;
             let handle = WebDisplayHandle::new();
             let handle = RawDisplayHandle::Web(handle);
-            let handle = unsafe{DisplayHandle::borrow_raw(handle)};
+            let handle = unsafe { DisplayHandle::borrow_raw(handle) };
             return Ok(handle);
         }
 
@@ -217,7 +213,7 @@ impl HasDisplayHandle for Window {
 
                 let handle = WindowsDisplayHandle::new();
                 let handle = RawDisplayHandle::Windows(handle);
-                let handle = unsafe {DisplayHandle::borrow_raw(handle)};
+                let handle = unsafe { DisplayHandle::borrow_raw(handle) };
 
                 Ok(handle)
             }
@@ -237,12 +233,10 @@ impl HasDisplayHandle for Window {
                     Some(display) => {
                         let mut handle = WaylandDisplayHandle::new(display);
                         let handle = RawDisplayHandle::Wayland(handle);
-                        let handle = unsafe{DisplayHandle::borrow_raw(handle)};
+                        let handle = unsafe { DisplayHandle::borrow_raw(handle) };
                         Ok(handle)
                     }
-                    None => {
-                        Err(HandleError::Unavailable)
-                    }
+                    None => Err(HandleError::Unavailable),
                 }
             }
             #[cfg(any(
@@ -260,7 +254,7 @@ impl HasDisplayHandle for Window {
                 let window = unsafe { wm_info.info.x11 }.window as i32;
                 let handle = XlibDisplayHandle::new(display, window);
                 let handle = RawDisplayHandle::Xlib(handle);
-                let handle = unsafe {DisplayHandle::borrow_raw(handle)};
+                let handle = unsafe { DisplayHandle::borrow_raw(handle) };
 
                 Ok(handle)
             }
@@ -269,7 +263,7 @@ impl HasDisplayHandle for Window {
                 use self::raw_window_handle::AppKitDisplayHandle;
                 let handle = AppKitDisplayHandle::new();
                 let handle = RawDisplayHandle::AppKit(handle);
-                let handle = unsafe {DisplayHandle::borrow_raw(handle)};
+                let handle = unsafe { DisplayHandle::borrow_raw(handle) };
                 Ok(handle)
             }
             #[cfg(any(target_os = "ios"))]
@@ -278,7 +272,7 @@ impl HasDisplayHandle for Window {
 
                 let handle = UiKitDisplayHandle::new();
                 let handle = RawDisplayHandle::UiKit(handle);
-                let handle = unsafe {DisplayHandle::borrow_raw(handle)};
+                let handle = unsafe { DisplayHandle::borrow_raw(handle) };
 
                 Ok(handle)
             }
@@ -288,7 +282,7 @@ impl HasDisplayHandle for Window {
 
                 let handle = AndroidDisplayHandle::new();
                 let handle = RawDisplayHandle::Android(handle);
-                let handle = unsafe {DisplayHandle::borrow_raw(handle)};
+                let handle = unsafe { DisplayHandle::borrow_raw(handle) };
 
                 Ok(handle)
             }
diff --git a/src/sdl2/rect.rs b/src/sdl2/rect.rs
index 0043f2c997..aa3a9bf183 100644
--- a/src/sdl2/rect.rs
+++ b/src/sdl2/rect.rs
@@ -60,6 +60,14 @@ fn clamped_mul(a: i32, b: i32) -> i32 {
     }
 }
 
+fn clamp_f32_size(val: f32) -> f32 {
+    if val <= 0.0 {
+        1.0
+    } else {
+        val
+    }
+}
+
 /// A (non-empty) rectangle.
 ///
 /// The width and height of a `Rect` must always be strictly positive (never
@@ -962,206 +970,1036 @@ impl std::iter::Sum for Point {
     }
 }
 
-#[cfg(test)]
-mod test {
-    use super::{max_int_value, min_int_value, Point, Rect};
-
-    /// Used to compare "literal" (unclamped) rect values.
-    fn tuple(x: i32, y: i32, w: u32, h: u32) -> (i32, i32, u32, u32) {
-        (x, y, w, h)
-    }
+/// A (non-empty) rectangle with float precision.
+///
+/// The width and height of a `FRect` must always be strictly positive (never
+/// zero). In cases where empty rects may need to be represented, it is
+/// recommended to use `Option<FRect>`, with `None` representing an empty
+/// rectangle (see, for example, the output of the
+/// [`intersection`](#method.intersection) method).
+#[derive(Clone, Copy)]
+pub struct FRect {
+    raw: sys::SDL_FRect,
+}
 
-    #[test]
-    fn centered() {
-        // Tests both center_on and centered_on
-        assert_eq!(
-            Rect::new(0, 0, 10, 10).centered_on((0, 0)),
-            Rect::new(-5, -5, 10, 10)
+impl ::std::fmt::Debug for FRect {
+    fn fmt(&self, fmt: &mut ::std::fmt::Formatter) -> Result<(), ::std::fmt::Error> {
+        return write!(
+            fmt,
+            "FRect {{ x: {}, y: {}, w: {}, h: {} }}",
+            self.raw.x, self.raw.y, self.raw.w, self.raw.h
         );
     }
+}
 
-    #[test]
-    fn enclose_points_valid() {
-        assert_eq!(
-            Some(tuple(2, 4, 4, 6)),
-            Rect::from_enclose_points(&[Point::new(2, 4), Point::new(5, 9)], None)
-                .map(|r| r.into())
-        );
+impl PartialEq for FRect {
+    fn eq(&self, other: &FRect) -> bool {
+        self.raw.x == other.raw.x
+            && self.raw.y == other.raw.y
+            && self.raw.w == other.raw.w
+            && self.raw.h == other.raw.h
     }
+}
 
-    #[test]
-    fn enclose_points_outside_clip_rect() {
-        assert_eq!(
-            Rect::from_enclose_points(
-                &[Point::new(0, 0), Point::new(10, 10)],
-                Some(Rect::new(3, 3, 1, 1))
-            ),
-            None
-        );
+impl FRect {
+    /// Creates a new rectangle with float precision from the given values.
+    ///
+    /// `FRect`s must always be non-empty, so a `width` and/or `height` argument
+    /// of 0 or less will be replaced with 1.
+    pub fn new(x: f32, y: f32, width: f32, height: f32) -> FRect {
+        let raw = sys::SDL_FRect {
+            x,
+            y,
+            w: clamp_f32_size(width),
+            h: clamp_f32_size(height),
+        };
+        FRect { raw }
     }
 
-    #[test]
-    fn enclose_points_max_values() {
-        // Try to enclose the top-left-most and bottom-right-most points.
-        assert_eq!(
-            Some(tuple(
-                min_int_value(),
-                min_int_value(),
-                max_int_value(),
-                max_int_value()
-            )),
-            Rect::from_enclose_points(
-                &[
-                    Point::new(i32::min_value(), i32::min_value()),
-                    Point::new(i32::max_value(), i32::max_value())
-                ],
-                None
-            )
-            .map(|r| r.into())
-        );
+    /// Creates a new rectangle with float precision centered on the given position.
+    ///
+    /// `FRect`s must always be non-empty, so a `width` and/or `height` argument
+    /// of 0 or less will be replaced with 1.
+    pub fn from_center<P>(center: P, width: f32, height: f32) -> FRect
+    where
+        P: Into<FPoint>,
+    {
+        let raw = sys::SDL_FRect {
+            x: 0.0,
+            y: 0.0,
+            w: clamp_f32_size(width),
+            h: clamp_f32_size(height),
+        };
+        let mut rect = FRect { raw };
+        rect.center_on(center.into());
+        rect
     }
 
-    #[test]
-    fn has_intersection() {
-        let rect = Rect::new(0, 0, 10, 10);
-        assert!(rect.has_intersection(Rect::new(9, 9, 10, 10)));
-        // edge
-        assert!(!rect.has_intersection(Rect::new(10, 10, 10, 10)));
-        // out
-        assert!(!rect.has_intersection(Rect::new(11, 11, 10, 10)));
+    /// The horizontal position of this rectangle.
+    #[inline]
+    pub fn x(&self) -> f32 {
+        self.raw.x
     }
 
-    #[test]
-    fn intersection() {
-        let rect = Rect::new(0, 0, 10, 10);
-        assert_eq!(rect & Rect::new(9, 9, 10, 10), Some(Rect::new(9, 9, 1, 1)));
-        assert_eq!(rect & Rect::new(11, 11, 10, 10), None);
+    /// The vertical position of this rectangle.
+    #[inline]
+    pub fn y(&self) -> f32 {
+        self.raw.y
     }
 
-    #[test]
-    fn union() {
-        assert_eq!(
-            Rect::new(0, 0, 1, 1) | Rect::new(9, 9, 1, 1),
-            Rect::new(0, 0, 10, 10)
-        );
+    /// The width of this rectangle.
+    pub fn width(&self) -> f32 {
+        self.raw.w as f32
     }
 
-    #[test]
-    fn intersect_line() {
-        assert_eq!(
-            Rect::new(1, 1, 5, 5).intersect_line(Point::new(0, 0), Point::new(10, 10)),
-            Some((Point::new(1, 1), Point::new(5, 5)))
-        );
+    /// The height of this rectangle.
+    pub fn height(&self) -> f32 {
+        self.raw.h as f32
     }
 
-    #[test]
-    fn clamp_size_zero() {
-        assert_eq!(tuple(0, 0, 1, 1), Rect::new(0, 0, 0, 0).into());
+    /// Returns the width and height of this rectangle.
+    pub fn size(&self) -> (f32, f32) {
+        (self.width(), self.height())
     }
 
-    #[test]
-    fn clamp_position_min() {
-        assert_eq!(
-            tuple(min_int_value(), min_int_value(), 1, 1),
-            Rect::new(i32::min_value(), i32::min_value(), 1, 1).into()
-        );
+    /// Sets the horizontal position of this rectangle to the given value,
+    /// clamped to be less than or equal to i32::max_value() / 2.
+    pub fn set_x(&mut self, x: f32) {
+        self.raw.x = x;
     }
 
-    #[test]
-    fn clamp_size_max() {
-        assert_eq!(
-            tuple(0, 0, max_int_value(), max_int_value()),
-            Rect::new(0, 0, max_int_value() + 1, max_int_value() + 1).into()
-        );
+    /// Sets the vertical position of this rectangle to the given value,
+    /// clamped to be less than or equal to i32::max_value() / 2.
+    pub fn set_y(&mut self, y: f32) {
+        self.raw.y = y;
     }
 
-    #[test]
-    fn clamp_i32_max() {
-        assert_eq!(
-            tuple(0, 0, max_int_value(), max_int_value()),
-            Rect::new(0, 0, i32::max_value() as u32, i32::max_value() as u32).into()
-        )
+    /// Sets the width of this rectangle to the given value,
+    /// clamped to be less than or equal to i32::max_value() / 2.
+    ///
+    /// `FRect`s must always be non-empty, so a `width` argument of 0 will be
+    /// replaced with 1.
+    pub fn set_width(&mut self, width: f32) {
+        self.raw.w = clamp_f32_size(width);
     }
 
-    #[test]
-    fn clamp_position_max() {
-        assert_eq!(
-            tuple(max_int_value() as i32, max_int_value() as i32, 1, 1),
-            Rect::new(max_int_value() as i32 + 1, max_int_value() as i32 + 1, 1, 1).into()
-        );
+    /// Sets the height of this rectangle to the given value,
+    /// clamped to be less than or equal to i32::max_value() / 2.
+    ///
+    /// `FRect`s must always be non-empty, so a `height` argument of 0 will be
+    /// replaced with 1.
+    pub fn set_height(&mut self, height: f32) {
+        self.raw.h = clamp_f32_size(height);
     }
 
-    #[test]
-    fn shifted() {
-        // Groups all functions into a single assertion
-        let rect = Rect::new(5, 5, 10, 10)
-            .left_shifted(5)
-            .right_shifted(5)
-            .top_shifted(5)
-            .bottom_shifted(5);
-        assert_eq!(rect, Rect::new(5, 5, 10, 10));
+    /// Returns the x-position of the left side of this rectangle.
+    pub fn left(&self) -> f32 {
+        self.raw.x
     }
 
-    #[test]
-    fn rect_into() {
-        let test: (i32, i32, u32, u32) = (-11, 5, 50, 20);
-        assert_eq!(test, Rect::new(-11, 5, 50, 20).into());
+    /// Returns the x-position of the right side of this rectangle.
+    pub fn right(&self) -> f32 {
+        self.raw.x + self.raw.w
     }
 
-    #[test]
-    fn rect_from() {
-        assert_eq!(Rect::from((-11, 5, 50, 20)), Rect::new(-11, 5, 50, 20));
+    /// Returns the y-position of the top side of this rectangle.
+    pub fn top(&self) -> f32 {
+        self.raw.y
     }
 
-    #[test]
-    fn point_into() {
-        let test: (i32, i32) = (-11, 5);
-        assert_eq!(test, Point::new(-11, 5).into());
+    /// Returns the y-position of the bottom side of this rectangle.
+    pub fn bottom(&self) -> f32 {
+        self.raw.y + self.raw.h
     }
 
-    #[test]
-    fn point_from() {
-        let test: (i32, i32) = (-11, 5);
-        assert_eq!(test, Point::new(-11, 5).into());
+    /// Shifts this rectangle to the left by `offset`.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use sdl2::rect::FRect;
+    /// assert_eq!(FRect::new(0.0, 0.0, 10.0, 10.0).left_shifted(5.0), FRect::new(-5.0, 0.0, 10.0, 10.0));
+    /// ```
+    pub fn left_shifted(mut self, offset: f32) -> FRect {
+        self.offset(-offset, self.y());
+        self
     }
 
-    #[test]
-    fn point_add() {
-        assert_eq!(Point::new(-5, 7), Point::new(-11, 5) + Point::new(6, 2));
+    /// Shifts this rectangle to the right by `offset`.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use sdl2::rect::FRect;
+    /// assert_eq!(FRect::new(0.0, 0.0, 10.0, 10.0).right_shifted(5.0), FRect::new(5.0, 0.0, 10.0, 10.0));
+    /// ```
+    pub fn right_shifted(mut self, offset: f32) -> FRect {
+        self.offset(offset, self.y());
+        self
     }
 
-    #[test]
-    fn point_add_assign() {
-        let mut point = Point::new(-11, 5);
-        point += Point::new(6, 2);
-        assert_eq!(point, Point::new(-11, 5) + Point::new(6, 2));
+    /// Shifts this rectangle to the top by `offset`.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use sdl2::rect::FRect;
+    /// assert_eq!(FRect::new(0.0, 0.0, 10.0, 10.0).top_shifted(5.00), FRect::new(0.0, -5.0, 10.0, 10.0));
+    /// ```
+    pub fn top_shifted(mut self, offset: f32) -> FRect {
+        self.offset(self.x(), -offset);
+        self
     }
 
-    #[test]
-    fn point_sub() {
-        assert_eq!(Point::new(-17, 3), Point::new(-11, 5) - Point::new(6, 2));
+    /// Shifts this rectangle to the bottom by `offset`.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use sdl2::rect::FRect;
+    /// assert_eq!(FRect::new(0.0, 0.0, 10.0, 10.0).bottom_shifted(5.0), FRect::new(0.0, 5.0, 10.0, 10.0));
+    /// ```
+    pub fn bottom_shifted(mut self, offset: f32) -> FRect {
+        self.offset(self.x(), offset);
+        self
     }
 
-    #[test]
-    fn point_sub_assign() {
-        let mut point = Point::new(-11, 5);
-        point -= Point::new(6, 2);
-        assert_eq!(point, Point::new(-11, 5) - Point::new(6, 2));
+    /// Returns the center position of this rectangle.
+    ///
+    /// Note that if the width or height is not a multiple of two,
+    /// the center will be rounded down.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use sdl2::rect::{FRect, FPoint};
+    /// let rect = FRect::new(1.0, 0.0, 2.0, 3.0);
+    /// assert_eq!(FPoint::new(2.0, 1.5), rect.center());
+    /// ```
+    pub fn center(&self) -> FPoint {
+        let x = self.raw.x + (self.raw.w / 2.0);
+        let y = self.raw.y + (self.raw.h / 2.0);
+        FPoint::new(x, y)
     }
 
-    #[test]
-    fn point_mul() {
-        assert_eq!(Point::new(-33, 15), Point::new(-11, 5) * 3);
+    /// Returns the top-left corner of this rectangle.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use sdl2::rect::{FRect, FPoint};
+    /// let rect = FRect::new(1.0, 0.0, 2.0, 3.0);
+    /// assert_eq!(FPoint::new(1.0, 0.0), rect.top_left());
+    /// ```
+    pub fn top_left(&self) -> FPoint {
+        FPoint::new(self.left(), self.top())
     }
 
-    #[test]
-    fn point_mul_assign() {
-        let mut point = Point::new(-11, 5);
-        point *= 3;
-        assert_eq!(point, Point::new(-11, 5) * 3);
+    /// Returns the top-right corner of this rectangle.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use sdl2::rect::{FRect, FPoint};
+    /// let rect = FRect::new(1.0, 0.0, 2.0, 3.0);
+    /// assert_eq!(FPoint::new(3.0, 0.0), rect.top_right());
+    /// ```
+    pub fn top_right(&self) -> FPoint {
+        FPoint::new(self.right(), self.top())
     }
 
-    #[test]
+    /// Returns the bottom-left corner of this rectangle.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use sdl2::rect::{FRect, FPoint};
+    /// let rect = FRect::new(1.0, 0.0, 2.0, 3.0);
+    /// assert_eq!(FPoint::new(1.0, 3.0), rect.bottom_left());
+    /// ```
+    pub fn bottom_left(&self) -> FPoint {
+        FPoint::new(self.left(), self.bottom())
+    }
+
+    /// Returns the bottom-right corner of this rectangle.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use sdl2::rect::{FRect, FPoint};
+    /// let rect = FRect::new(1.0, 0.0, 2.0, 3.0);
+    /// assert_eq!(FPoint::new(3.0, 3.0), rect.bottom_right());
+    /// ```
+    pub fn bottom_right(&self) -> FPoint {
+        FPoint::new(self.right(), self.bottom())
+    }
+
+    /// Sets the position of the right side of this rectangle to the given
+    /// value, clamped to be greater than 0.
+    pub fn set_right(&mut self, right: f32) {
+        self.raw.x = clamp_f32_size(clamp_f32_size(right) - self.raw.w);
+    }
+
+    /// Sets the position of the bottom side of this rectangle to the given
+    /// value, clamped to be greater than 0.
+    pub fn set_bottom(&mut self, bottom: f32) {
+        self.raw.y = clamp_f32_size(clamp_f32_size(bottom) - self.raw.h);
+    }
+
+    /// Centers the rectangle on the given point (in place).
+    #[inline]
+    pub fn center_on<P>(&mut self, point: P)
+    where
+        P: Into<(f32, f32)>,
+    {
+        let (x, y) = point.into();
+        self.raw.x = x - self.raw.w / 2.0;
+        self.raw.y = y - self.raw.h / 2.0;
+    }
+
+    /// Centers the rectangle on the given point.
+    #[inline]
+    pub fn centered_on<P>(mut self, point: P) -> FRect
+    where
+        P: Into<(f32, f32)>,
+    {
+        self.center_on(point);
+        self
+    }
+
+    /// Move this rect.
+    #[inline]
+    pub fn offset(&mut self, x: f32, y: f32) {
+        self.raw.x += x;
+        self.raw.y += y;
+    }
+
+    /// Moves this rect to the given position.
+    pub fn reposition<P>(&mut self, point: P)
+    where
+        P: Into<(f32, f32)>,
+    {
+        let (x, y) = point.into();
+        self.raw.x = x;
+        self.raw.y = y;
+    }
+
+    /// Resizes this rect to the given size after clamping the values.
+    pub fn resize(&mut self, width: f32, height: f32) {
+        self.raw.w = clamp_f32_size(width);
+        self.raw.h = clamp_f32_size(height);
+    }
+
+    /// Checks whether this rectangle contains a given point.
+    ///
+    /// Points along the right and bottom edges are not considered to be inside
+    /// the rectangle. Another way to look at it is that this method returns true if
+    /// and only if the given point would be painted by a call to
+    /// [`Renderer::fill_frect`](
+    /// ../render/struct.Renderer.html#method.fill_frect).
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use sdl2::rect::{FRect, FPoint};
+    /// let rect = FRect::new(1.0, 2.0, 3.0, 4.0);
+    /// assert!(rect.contains_point(FPoint::new(1.0, 2.0)));
+    /// assert!(!rect.contains_point(FPoint::new(0.0, 1.0)));
+    /// assert!(rect.contains_point(FPoint::new(3.0, 5.0)));
+    /// assert!(!rect.contains_point(FPoint::new(4.0, 6.0)));
+    /// ```
+    pub fn contains_point<P>(&self, point: P) -> bool
+    where
+        P: Into<(f32, f32)>,
+    {
+        let (x, y) = point.into();
+        let inside_x = x >= self.left() && x < self.right();
+        inside_x && (y >= self.top() && y < self.bottom())
+    }
+
+    /// Checks whether this rectangle completely contains another rectangle.
+    ///
+    /// This method returns true if and only if every point contained by
+    /// `other` is also contained by `self`; in other words, if the
+    /// intersection of `self` and `other` is equal to `other`.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use sdl2::rect::FRect;
+    /// let rect = FRect::new(1.0, 2.0, 3.0, 4.0);
+    /// assert!(rect.contains_rect(rect));
+    /// assert!(rect.contains_rect(FRect::new(3.0, 3.0, 1.0, 1.0)));
+    /// assert!(!rect.contains_rect(FRect::new(2.0, 1.0, 1.0, 1.0)));
+    /// assert!(!rect.contains_rect(FRect::new(3.0, 3.0, 2.0, 1.0)));
+    /// ```
+    pub fn contains_rect(&self, other: FRect) -> bool {
+        other.left() >= self.left()
+            && other.right() <= self.right()
+            && other.top() >= self.top()
+            && other.bottom() <= self.bottom()
+    }
+
+    /// Returns the underlying C FRect.
+    // this can prevent introducing UB until
+    // https://github.com/rust-lang/rust-clippy/issues/5953 is fixed
+    #[allow(clippy::trivially_copy_pass_by_ref)]
+    pub fn raw(&self) -> *const sys::SDL_FRect {
+        &self.raw
+    }
+
+    pub fn raw_mut(&mut self) -> *mut sys::SDL_FRect {
+        self.raw() as *mut _
+    }
+
+    #[doc(alias = "SDL_FRect")]
+    pub fn raw_slice(slice: &[FRect]) -> *const sys::SDL_FRect {
+        slice.as_ptr() as *const sys::SDL_FRect
+    }
+
+    pub fn from_ll(raw: sys::SDL_FRect) -> FRect {
+        FRect::new(raw.x, raw.y, raw.w, raw.h)
+    }
+
+    /// Calculate a minimal rectangle enclosing a set of points.
+    /// If a clipping rectangle is given, only points that are within it will be
+    /// considered.
+    #[doc(alias = "SDL_EncloseFPoints")]
+    pub fn from_enclose_points<R: Into<Option<FRect>>>(
+        points: &[FPoint],
+        clipping_rect: R,
+    ) -> Option<FRect>
+    where
+        R: Into<Option<FRect>>,
+    {
+        let clipping_rect = clipping_rect.into();
+
+        if points.is_empty() {
+            return None;
+        }
+
+        let mut out = mem::MaybeUninit::uninit();
+
+        let clip_ptr = match clipping_rect.as_ref() {
+            Some(r) => r.raw(),
+            None => ptr::null(),
+        };
+
+        let result = unsafe {
+            sys::SDL_EncloseFPoints(
+                FPoint::raw_slice(points),
+                points.len() as i32,
+                clip_ptr,
+                out.as_mut_ptr(),
+            ) != sys::SDL_bool::SDL_FALSE
+        };
+
+        if result {
+            let out = unsafe { out.assume_init() };
+
+            // Return an error if the dimensions are too large.
+            Some(FRect::from_ll(out))
+        } else {
+            None
+        }
+    }
+
+    /// Determines whether two rectangles intersect.
+    ///
+    /// Rectangles that share an edge but don't actually overlap are not
+    /// considered to intersect.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use sdl2::rect::FRect;
+    /// let rect = FRect::new(0.0, 0.0, 5.0, 5.0);
+    /// assert!(rect.has_intersection(rect));
+    /// assert!(rect.has_intersection(FRect::new(2.0, 2.0, 5.0, 5.0)));
+    /// assert!(!rect.has_intersection(FRect::new(5.0, 0.0, 5.0, 5.0)));
+    /// ```
+    #[doc(alias = "SDL_HasIntersectionF")]
+    pub fn has_intersection(&self, other: FRect) -> bool {
+        unsafe { sys::SDL_HasIntersectionF(self.raw(), other.raw()) != sys::SDL_bool::SDL_FALSE }
+    }
+
+    /// Calculates the intersection of two rectangles.
+    ///
+    /// Returns `None` if the two rectangles don't intersect.  Rectangles that
+    /// share an edge but don't actually overlap are not considered to
+    /// intersect.
+    ///
+    /// The bitwise AND operator `&` can also be used.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use sdl2::rect::FRect;
+    /// let rect = FRect::new(0.0, 0.0, 5.0, 5.0);
+    /// assert_eq!(rect.intersection(rect), Some(rect));
+    /// assert_eq!(rect.intersection(FRect::new(2.0, 2.0, 5.0, 5.0)),
+    ///            Some(FRect::new(2.0, 2.0, 3.0, 3.0)));
+    /// assert_eq!(rect.intersection(FRect::new(5.0, 0.0, 5.0, 5.0)), None);
+    /// ```
+    #[doc(alias = "SDL_IntersectFRect")]
+    pub fn intersection(&self, other: FRect) -> Option<FRect> {
+        let mut out = mem::MaybeUninit::uninit();
+
+        let success = unsafe {
+            sys::SDL_IntersectFRect(self.raw(), other.raw(), out.as_mut_ptr())
+                != sys::SDL_bool::SDL_FALSE
+        };
+
+        if success {
+            let out = unsafe { out.assume_init() };
+            Some(FRect::from_ll(out))
+        } else {
+            None
+        }
+    }
+
+    /// Calculates the union of two rectangles (i.e. the smallest rectangle
+    /// that contains both).
+    ///
+    /// The bitwise OR operator `|` can also be used.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use sdl2::rect::FRect;
+    /// let rect = FRect::new(0.0, 0.0, 5.0, 5.0);
+    /// assert_eq!(rect.union(rect), rect);
+    /// assert_eq!(rect.union(FRect::new(2.0, 2.0, 5.0, 5.0)), FRect::new(0.0, 0.0, 7.0, 7.0));
+    /// assert_eq!(rect.union(FRect::new(5.0, 0.0, 5.0, 5.0)), FRect::new(0.0, 0.0, 10.0, 5.0));
+    /// ```
+    #[doc(alias = "SDL_UnionFRect")]
+    pub fn union(&self, other: FRect) -> FRect {
+        let mut out = mem::MaybeUninit::uninit();
+
+        unsafe {
+            // If `self` and `other` are both empty, `out` remains uninitialized.
+            // Because empty rectangles aren't allowed in Rect, we don't need to worry about this.
+            sys::SDL_UnionFRect(self.raw(), other.raw(), out.as_mut_ptr())
+        };
+
+        let out = unsafe { out.assume_init() };
+
+        FRect::from_ll(out)
+    }
+
+    /// Calculates the intersection of a rectangle and a line segment and
+    /// returns the points of their intersection.
+    #[doc(alias = "SDL_IntersectFRectAndLine")]
+    pub fn intersect_line(&self, start: FPoint, end: FPoint) -> Option<(FPoint, FPoint)> {
+        let (mut start_x, mut start_y) = (start.x(), start.y());
+        let (mut end_x, mut end_y) = (end.x(), end.y());
+
+        let intersected = unsafe {
+            sys::SDL_IntersectFRectAndLine(
+                self.raw(),
+                &mut start_x,
+                &mut start_y,
+                &mut end_x,
+                &mut end_y,
+            ) != sys::SDL_bool::SDL_FALSE
+        };
+
+        if intersected {
+            Some((FPoint::new(start_x, start_y), FPoint::new(end_x, end_y)))
+        } else {
+            None
+        }
+    }
+}
+
+impl Deref for FRect {
+    type Target = sys::SDL_FRect;
+
+    /// # Example
+    ///
+    /// ```rust
+    /// use sdl2::rect::FRect;
+    /// let rect = FRect::new(2.0, 3.0, 4.0, 5.0);
+    /// assert_eq!(2.0, rect.x);
+    /// ```
+    fn deref(&self) -> &sys::SDL_FRect {
+        &self.raw
+    }
+}
+
+impl DerefMut for FRect {
+    /// # Example
+    ///
+    /// ```rust
+    /// use sdl2::rect::FRect;
+    /// let mut rect = FRect::new(2.0, 3.0, 4.0, 5.0);
+    /// rect.x = 60.0;
+    /// assert_eq!(60.0, rect.x);
+    /// ```
+    fn deref_mut(&mut self) -> &mut sys::SDL_FRect {
+        &mut self.raw
+    }
+}
+
+impl Into<sys::SDL_FRect> for FRect {
+    fn into(self) -> sys::SDL_FRect {
+        self.raw
+    }
+}
+
+impl Into<(f32, f32, f32, f32)> for FRect {
+    fn into(self) -> (f32, f32, f32, f32) {
+        (self.raw.x, self.raw.y, self.raw.w, self.raw.h)
+    }
+}
+
+impl From<sys::SDL_FRect> for FRect {
+    fn from(raw: sys::SDL_FRect) -> FRect {
+        FRect { raw }
+    }
+}
+
+impl From<(f32, f32, f32, f32)> for FRect {
+    fn from((x, y, width, height): (f32, f32, f32, f32)) -> FRect {
+        FRect::new(x, y, width, height)
+    }
+}
+
+impl AsRef<sys::SDL_FRect> for FRect {
+    fn as_ref(&self) -> &sys::SDL_FRect {
+        &self.raw
+    }
+}
+
+impl AsMut<sys::SDL_FRect> for FRect {
+    fn as_mut(&mut self) -> &mut sys::SDL_FRect {
+        &mut self.raw
+    }
+}
+
+// Intersection
+impl BitAnd<FRect> for FRect {
+    type Output = Option<FRect>;
+    #[doc(alias = "SDL_FPoint")]
+    fn bitand(self, rhs: FRect) -> Option<FRect> {
+        self.intersection(rhs)
+    }
+}
+
+// Union
+impl BitOr<FRect> for FRect {
+    type Output = FRect;
+    fn bitor(self, rhs: FRect) -> FRect {
+        self.union(rhs)
+    }
+}
+
+/// Immutable point type with float precision, consisting of x and y.
+#[derive(Copy, Clone)]
+pub struct FPoint {
+    raw: sys::SDL_FPoint,
+}
+
+impl ::std::fmt::Debug for FPoint {
+    fn fmt(&self, fmt: &mut ::std::fmt::Formatter) -> Result<(), ::std::fmt::Error> {
+        return write!(fmt, "FPoint {{ x: {}, y: {} }}", self.raw.x, self.raw.y);
+    }
+}
+
+impl PartialEq for FPoint {
+    fn eq(&self, other: &FPoint) -> bool {
+        self.raw.x == other.raw.x && self.raw.y == other.raw.y
+    }
+}
+
+impl Deref for FPoint {
+    type Target = sys::SDL_FPoint;
+
+    /// # Example
+    ///
+    /// ```rust
+    /// use sdl2::rect::FPoint;
+    /// let point = FPoint::new(2.0, 3.0);
+    /// assert_eq!(2.0, point.x);
+    /// ```
+    fn deref(&self) -> &sys::SDL_FPoint {
+        &self.raw
+    }
+}
+
+impl DerefMut for FPoint {
+    /// # Example
+    ///
+    /// ```rust
+    /// use sdl2::rect::FPoint;
+    /// let mut point = FPoint::new(2.0, 3.0);
+    /// point.x = 4.0;
+    /// assert_eq!(4.0, point.x);
+    /// ```
+    fn deref_mut(&mut self) -> &mut sys::SDL_FPoint {
+        &mut self.raw
+    }
+}
+
+impl AsRef<sys::SDL_FPoint> for FPoint {
+    fn as_ref(&self) -> &sys::SDL_FPoint {
+        &self.raw
+    }
+}
+
+impl AsMut<sys::SDL_FPoint> for FPoint {
+    fn as_mut(&mut self) -> &mut sys::SDL_FPoint {
+        &mut self.raw
+    }
+}
+
+impl From<sys::SDL_FPoint> for FPoint {
+    fn from(prim: sys::SDL_FPoint) -> FPoint {
+        FPoint { raw: prim }
+    }
+}
+
+impl From<(f32, f32)> for FPoint {
+    fn from((x, y): (f32, f32)) -> FPoint {
+        FPoint::new(x, y)
+    }
+}
+
+impl Into<sys::SDL_FPoint> for FPoint {
+    fn into(self) -> sys::SDL_FPoint {
+        self.raw
+    }
+}
+
+impl Into<(f32, f32)> for FPoint {
+    fn into(self) -> (f32, f32) {
+        (self.x(), self.y())
+    }
+}
+
+impl FPoint {
+    /// Creates a new point from the given coordinates.
+    pub fn new(x: f32, y: f32) -> FPoint {
+        FPoint {
+            raw: sys::SDL_FPoint { x, y },
+        }
+    }
+
+    pub fn from_ll(raw: sys::SDL_FPoint) -> FPoint {
+        FPoint::new(raw.x, raw.y)
+    }
+
+    #[doc(alias = "SDL_FPoint")]
+    pub fn raw_slice(slice: &[FPoint]) -> *const sys::SDL_FPoint {
+        slice.as_ptr() as *const sys::SDL_FPoint
+    }
+
+    // this can prevent introducing UB until
+    // https://github.com/rust-lang/rust-clippy/issues/5953 is fixed
+    #[allow(clippy::trivially_copy_pass_by_ref)]
+    pub fn raw(&self) -> *const sys::SDL_FPoint {
+        &self.raw
+    }
+
+    /// Returns a new point by shifting this point's coordinates by the given
+    /// x and y values.
+    pub fn offset(self, x: f32, y: f32) -> FPoint {
+        let x = self.raw.x + x;
+        let y = self.raw.y + y;
+        FPoint::new(x, y)
+    }
+
+    /// Returns a new point by multiplying this point's coordinates by the
+    /// given scale factor.
+    pub fn scale(self, f: f32) -> FPoint {
+        FPoint::new(self.raw.x * f, self.raw.y * f)
+    }
+
+    /// Returns the x-coordinate of this point.
+    pub fn x(self) -> f32 {
+        self.raw.x
+    }
+
+    /// Returns the y-coordinate of this point.
+    pub fn y(self) -> f32 {
+        self.raw.y
+    }
+}
+
+impl Add for FPoint {
+    type Output = FPoint;
+
+    fn add(self, rhs: FPoint) -> FPoint {
+        self.offset(rhs.x(), rhs.y())
+    }
+}
+
+impl AddAssign for FPoint {
+    fn add_assign(&mut self, rhs: FPoint) {
+        self.raw.x = self.x() + rhs.x();
+        self.raw.y = self.y() + rhs.y();
+    }
+}
+
+impl Neg for FPoint {
+    type Output = FPoint;
+
+    fn neg(self) -> FPoint {
+        FPoint::new(-self.x(), -self.y())
+    }
+}
+
+impl Sub for FPoint {
+    type Output = FPoint;
+
+    fn sub(self, rhs: FPoint) -> FPoint {
+        self.offset(-rhs.x(), -rhs.y())
+    }
+}
+
+impl SubAssign for FPoint {
+    fn sub_assign(&mut self, rhs: FPoint) {
+        self.raw.x = self.x() - rhs.x();
+        self.raw.y = self.y() - rhs.y();
+    }
+}
+
+impl Mul<f32> for FPoint {
+    type Output = FPoint;
+
+    fn mul(self, rhs: f32) -> FPoint {
+        self.scale(rhs)
+    }
+}
+
+impl MulAssign<f32> for FPoint {
+    fn mul_assign(&mut self, rhs: f32) {
+        self.raw.x = self.x() * rhs;
+        self.raw.y = self.y() * rhs;
+    }
+}
+
+impl Div<f32> for FPoint {
+    type Output = FPoint;
+
+    fn div(self, rhs: f32) -> FPoint {
+        FPoint::new(self.x() / rhs, self.y() / rhs)
+    }
+}
+
+impl DivAssign<f32> for FPoint {
+    fn div_assign(&mut self, rhs: f32) {
+        self.raw.x /= rhs;
+        self.raw.y /= rhs;
+    }
+}
+
+impl std::iter::Sum for FPoint {
+    fn sum<I: Iterator<Item = Self>>(iter: I) -> Self {
+        iter.fold(FPoint::new(0.0, 0.0), FPoint::add)
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::{max_int_value, min_int_value, FPoint, FRect, Point, Rect};
+
+    /// Used to compare "literal" (unclamped) rect values.
+    fn tuple(x: i32, y: i32, w: u32, h: u32) -> (i32, i32, u32, u32) {
+        (x, y, w, h)
+    }
+
+    #[test]
+    fn centered() {
+        // Tests both center_on and centered_on
+        assert_eq!(
+            Rect::new(0, 0, 10, 10).centered_on((0, 0)),
+            Rect::new(-5, -5, 10, 10)
+        );
+    }
+
+    #[test]
+    fn enclose_points_valid() {
+        assert_eq!(
+            Some(tuple(2, 4, 4, 6)),
+            Rect::from_enclose_points(&[Point::new(2, 4), Point::new(5, 9)], None)
+                .map(|r| r.into())
+        );
+    }
+
+    #[test]
+    fn enclose_points_outside_clip_rect() {
+        assert_eq!(
+            Rect::from_enclose_points(
+                &[Point::new(0, 0), Point::new(10, 10)],
+                Some(Rect::new(3, 3, 1, 1))
+            ),
+            None
+        );
+    }
+
+    #[test]
+    fn enclose_points_max_values() {
+        // Try to enclose the top-left-most and bottom-right-most points.
+        assert_eq!(
+            Some(tuple(
+                min_int_value(),
+                min_int_value(),
+                max_int_value(),
+                max_int_value()
+            )),
+            Rect::from_enclose_points(
+                &[
+                    Point::new(i32::min_value(), i32::min_value()),
+                    Point::new(i32::max_value(), i32::max_value())
+                ],
+                None
+            )
+            .map(|r| r.into())
+        );
+    }
+
+    #[test]
+    fn has_intersection() {
+        let rect = Rect::new(0, 0, 10, 10);
+        assert!(rect.has_intersection(Rect::new(9, 9, 10, 10)));
+        // edge
+        assert!(!rect.has_intersection(Rect::new(10, 10, 10, 10)));
+        // out
+        assert!(!rect.has_intersection(Rect::new(11, 11, 10, 10)));
+    }
+
+    #[test]
+    fn intersection() {
+        let rect = Rect::new(0, 0, 10, 10);
+        assert_eq!(rect & Rect::new(9, 9, 10, 10), Some(Rect::new(9, 9, 1, 1)));
+        assert_eq!(rect & Rect::new(11, 11, 10, 10), None);
+    }
+
+    #[test]
+    fn union() {
+        assert_eq!(
+            Rect::new(0, 0, 1, 1) | Rect::new(9, 9, 1, 1),
+            Rect::new(0, 0, 10, 10)
+        );
+    }
+
+    #[test]
+    fn intersect_line() {
+        assert_eq!(
+            Rect::new(1, 1, 5, 5).intersect_line(Point::new(0, 0), Point::new(10, 10)),
+            Some((Point::new(1, 1), Point::new(5, 5)))
+        );
+    }
+
+    #[test]
+    fn clamp_size_zero() {
+        assert_eq!(tuple(0, 0, 1, 1), Rect::new(0, 0, 0, 0).into());
+    }
+
+    #[test]
+    fn clamp_position_min() {
+        assert_eq!(
+            tuple(min_int_value(), min_int_value(), 1, 1),
+            Rect::new(i32::min_value(), i32::min_value(), 1, 1).into()
+        );
+    }
+
+    #[test]
+    fn clamp_size_max() {
+        assert_eq!(
+            tuple(0, 0, max_int_value(), max_int_value()),
+            Rect::new(0, 0, max_int_value() + 1, max_int_value() + 1).into()
+        );
+    }
+
+    #[test]
+    fn clamp_i32_max() {
+        assert_eq!(
+            tuple(0, 0, max_int_value(), max_int_value()),
+            Rect::new(0, 0, i32::max_value() as u32, i32::max_value() as u32).into()
+        )
+    }
+
+    #[test]
+    fn clamp_position_max() {
+        assert_eq!(
+            tuple(max_int_value() as i32, max_int_value() as i32, 1, 1),
+            Rect::new(max_int_value() as i32 + 1, max_int_value() as i32 + 1, 1, 1).into()
+        );
+    }
+
+    #[test]
+    fn shifted() {
+        // Groups all functions into a single assertion
+        let rect = Rect::new(5, 5, 10, 10)
+            .left_shifted(5)
+            .right_shifted(5)
+            .top_shifted(5)
+            .bottom_shifted(5);
+        assert_eq!(rect, Rect::new(5, 5, 10, 10));
+    }
+
+    #[test]
+    fn rect_into() {
+        let test: (i32, i32, u32, u32) = (-11, 5, 50, 20);
+        assert_eq!(test, Rect::new(-11, 5, 50, 20).into());
+    }
+
+    #[test]
+    fn rect_from() {
+        assert_eq!(Rect::from((-11, 5, 50, 20)), Rect::new(-11, 5, 50, 20));
+    }
+
+    #[test]
+    fn point_into() {
+        let test: (i32, i32) = (-11, 5);
+        assert_eq!(test, Point::new(-11, 5).into());
+    }
+
+    #[test]
+    fn point_from() {
+        let test: (i32, i32) = (-11, 5);
+        assert_eq!(test, Point::new(-11, 5).into());
+    }
+
+    #[test]
+    fn point_add() {
+        assert_eq!(Point::new(-5, 7), Point::new(-11, 5) + Point::new(6, 2));
+    }
+
+    #[test]
+    fn point_add_assign() {
+        let mut point = Point::new(-11, 5);
+        point += Point::new(6, 2);
+        assert_eq!(point, Point::new(-11, 5) + Point::new(6, 2));
+    }
+
+    #[test]
+    fn point_sub() {
+        assert_eq!(Point::new(-17, 3), Point::new(-11, 5) - Point::new(6, 2));
+    }
+
+    #[test]
+    fn point_sub_assign() {
+        let mut point = Point::new(-11, 5);
+        point -= Point::new(6, 2);
+        assert_eq!(point, Point::new(-11, 5) - Point::new(6, 2));
+    }
+
+    #[test]
+    fn point_mul() {
+        assert_eq!(Point::new(-33, 15), Point::new(-11, 5) * 3);
+    }
+
+    #[test]
+    fn point_mul_assign() {
+        let mut point = Point::new(-11, 5);
+        point *= 3;
+        assert_eq!(point, Point::new(-11, 5) * 3);
+    }
+
+    #[test]
     fn point_mul_clamp() {
         assert_eq!(
             Point::new(0x7fffffff, -0x7fffffff),
@@ -1193,4 +2031,169 @@ mod test {
         let points_sum: Point = vec![Point::new(-11, 5), Point::new(6, 2)].into_iter().sum();
         assert_eq!(Point::new(-5, 7), points_sum);
     }
+
+    #[test]
+    fn frect_centered() {
+        // Tests both center_on and centered_on
+        assert_eq!(
+            FRect::new(0.0, 0.0, 10.0, 10.0).centered_on((0.0, 0.0)),
+            FRect::new(-5.0, -5.0, 10.0, 10.0)
+        );
+    }
+
+    #[test]
+    fn frect_enclose_points_valid() {
+        assert_eq!(
+            Some((2.0, 4.0, 4.0, 6.0)),
+            FRect::from_enclose_points(&[FPoint::new(2.0, 4.0), FPoint::new(5.0, 9.0)], None)
+                .map(|r| r.into())
+        );
+    }
+
+    #[test]
+    fn frect_enclose_points_outside_clip_rect() {
+        assert_eq!(
+            FRect::from_enclose_points(
+                &[FPoint::new(0.0, 0.0), FPoint::new(10.0, 10.0)],
+                Some(FRect::new(3.0, 3.0, 1.0, 1.0))
+            ),
+            None
+        );
+    }
+
+    #[test]
+    fn frect_has_intersection() {
+        let rect = FRect::new(0.0, 0.0, 10.0, 10.0);
+        assert!(rect.has_intersection(FRect::new(9.0, 9.0, 10.0, 10.0)));
+        // edge
+        assert!(!rect.has_intersection(FRect::new(10.0, 10.0, 10.0, 10.0)));
+        // out
+        assert!(!rect.has_intersection(FRect::new(11.0, 11.0, 10.0, 10.0)));
+    }
+
+    #[test]
+    fn frect_intersection() {
+        let rect = FRect::new(0.0, 0.0, 10.0, 10.0);
+        assert_eq!(
+            rect & FRect::new(9.0, 9.0, 10.0, 10.0),
+            Some(FRect::new(9.0, 9.0, 1.0, 1.0))
+        );
+        assert_eq!(rect & FRect::new(11.0, 11.0, 10.0, 10.0), None);
+    }
+
+    #[test]
+    fn frect_union() {
+        assert_eq!(
+            FRect::new(0.0, 0.0, 1.0, 1.0) | FRect::new(9.0, 9.0, 1.0, 1.0),
+            FRect::new(0.0, 0.0, 10.0, 10.0)
+        );
+    }
+
+    #[test]
+    fn frect_intersect_line() {
+        assert_eq!(
+            FRect::new(1.0, 1.0, 5.0, 5.0)
+                .intersect_line(FPoint::new(0.0, 0.0), FPoint::new(10.0, 10.0)),
+            Some((FPoint::new(1.0, 1.0), FPoint::new(5.0, 5.0)))
+        );
+    }
+
+    #[test]
+    fn frect_shifted() {
+        // Groups all functions into a single assertion
+        let rect = FRect::new(0.0, 0.0, 10.0, 10.0)
+            .left_shifted(5.0)
+            .right_shifted(5.0)
+            .top_shifted(5.0)
+            .bottom_shifted(5.0);
+        assert_eq!(rect, FRect::new(0.0, 0.0, 10.0, 10.0));
+    }
+
+    #[test]
+    fn frect_into() {
+        let test: (f32, f32, f32, f32) = (-11.0, 5.0, 50.0, 20.0);
+        assert_eq!(test, FRect::new(-11.0, 5.0, 50.0, 20.0).into());
+    }
+
+    #[test]
+    fn frect_from() {
+        assert_eq!(
+            FRect::from((-11.0, 5.0, 50.0, 20.0)),
+            FRect::new(-11.0, 5.0, 50.0, 20.0)
+        );
+    }
+
+    #[test]
+    fn fpoint_into() {
+        let test: (f32, f32) = (-11.0, 5.0);
+        assert_eq!(test, FPoint::new(-11.0, 5.0).into());
+    }
+
+    #[test]
+    fn fpoint_from() {
+        let test: (f32, f32) = (-11.0, 5.0);
+        assert_eq!(test, FPoint::new(-11.0, 5.0).into());
+    }
+
+    #[test]
+    fn fpoint_add() {
+        assert_eq!(
+            FPoint::new(-5.0, 7.0),
+            FPoint::new(-11.0, 5.0) + FPoint::new(6.0, 2.0)
+        );
+    }
+
+    #[test]
+    fn fpoint_add_assign() {
+        let mut point = FPoint::new(-11.0, 5.0);
+        point += FPoint::new(6.0, 2.0);
+        assert_eq!(point, FPoint::new(-11.0, 5.0) + FPoint::new(6.0, 2.0));
+    }
+
+    #[test]
+    fn fpoint_sub() {
+        assert_eq!(
+            FPoint::new(-17.0, 3.0),
+            FPoint::new(-11.0, 5.0) - FPoint::new(6.0, 2.0)
+        );
+    }
+
+    #[test]
+    fn fpoint_sub_assign() {
+        let mut point = FPoint::new(-11.0, 5.0);
+        point -= FPoint::new(6.0, 2.0);
+        assert_eq!(point, FPoint::new(-11.0, 5.0) - FPoint::new(6.0, 2.0));
+    }
+
+    #[test]
+    fn fpoint_mul() {
+        assert_eq!(FPoint::new(-33.0, 15.0), FPoint::new(-11.0, 5.0) * 3.0);
+    }
+
+    #[test]
+    fn fpoint_mul_assign() {
+        let mut point = FPoint::new(-11.0, 5.0);
+        point *= 3.0;
+        assert_eq!(point, FPoint::new(-11.0, 5.0) * 3.0);
+    }
+
+    #[test]
+    fn fpoint_div() {
+        assert_eq!(FPoint::new(-3.0, 1.0), FPoint::new(-9.0, 3.0) / 3.0);
+    }
+
+    #[test]
+    fn fpoint_div_assign() {
+        let mut point = FPoint::new(-11.0, 5.0);
+        point /= 3.0;
+        assert_eq!(point, FPoint::new(-11.0, 5.0) / 3.0);
+    }
+
+    #[test]
+    fn fpoint_sum() {
+        let points_sum: FPoint = vec![FPoint::new(-11.0, 5.0), FPoint::new(6.0, 2.0)]
+            .into_iter()
+            .sum();
+        assert_eq!(FPoint::new(-5.0, 7.0), points_sum);
+    }
 }
diff --git a/src/sdl2/render.rs b/src/sdl2/render.rs
index cb645752b9..96abd52422 100644
--- a/src/sdl2/render.rs
+++ b/src/sdl2/render.rs
@@ -32,6 +32,8 @@ use crate::common::{validate_int, IntegerOrSdlError};
 use crate::get_error;
 use crate::pixels;
 use crate::pixels::PixelFormatEnum;
+use crate::rect::FPoint;
+use crate::rect::FRect;
 use crate::rect::Point;
 use crate::rect::Rect;
 use crate::surface;
@@ -1331,6 +1333,251 @@ impl<T: RenderTarget> Canvas<T> {
         }
     }
 
+    /// Draws a point on the current rendering target.
+    /// Errors if drawing fails for any reason (e.g. driver failure)
+    #[doc(alias = "SDL_RenderDrawPointF")]
+    pub fn draw_fpoint<P: Into<FPoint>>(&mut self, point: P) -> Result<(), String> {
+        let point = point.into();
+        let result = unsafe { sys::SDL_RenderDrawPointF(self.context.raw, point.x(), point.y()) };
+        if result != 0 {
+            Err(get_error())
+        } else {
+            Ok(())
+        }
+    }
+
+    /// Draws multiple points on the current rendering target.
+    /// Errors if drawing fails for any reason (e.g. driver failure)
+    #[doc(alias = "SDL_RenderDrawPointsF")]
+    pub fn draw_fpoints<'a, P: Into<&'a [FPoint]>>(&mut self, points: P) -> Result<(), String> {
+        let points = points.into();
+        let result = unsafe {
+            sys::SDL_RenderDrawPointsF(
+                self.context.raw,
+                FPoint::raw_slice(points),
+                points.len() as c_int,
+            )
+        };
+        if result != 0 {
+            Err(get_error())
+        } else {
+            Ok(())
+        }
+    }
+
+    /// Draws a line on the current rendering target.
+    /// Errors if drawing fails for any reason (e.g. driver failure)
+    #[doc(alias = "SDL_RenderDrawLineF")]
+    pub fn draw_fline<P1: Into<FPoint>, P2: Into<FPoint>>(
+        &mut self,
+        start: P1,
+        end: P2,
+    ) -> Result<(), String> {
+        let start = start.into();
+        let end = end.into();
+        let result = unsafe {
+            sys::SDL_RenderDrawLineF(self.context.raw, start.x(), start.y(), end.x(), end.y())
+        };
+        if result != 0 {
+            Err(get_error())
+        } else {
+            Ok(())
+        }
+    }
+
+    /// Draws a series of connected lines on the current rendering target.
+    /// Errors if drawing fails for any reason (e.g. driver failure)
+    #[doc(alias = "SDL_RenderDrawLinesF")]
+    pub fn draw_flines<'a, P: Into<&'a [FPoint]>>(&mut self, points: P) -> Result<(), String> {
+        let points = points.into();
+        let result = unsafe {
+            sys::SDL_RenderDrawLinesF(
+                self.context.raw,
+                FPoint::raw_slice(points),
+                points.len() as c_int,
+            )
+        };
+        if result != 0 {
+            Err(get_error())
+        } else {
+            Ok(())
+        }
+    }
+
+    /// Draws a rectangle on the current rendering target.
+    /// Errors if drawing fails for any reason (e.g. driver failure)
+    #[doc(alias = "SDL_RenderDrawRectF")]
+    pub fn draw_frect(&mut self, rect: FRect) -> Result<(), String> {
+        let result = unsafe { sys::SDL_RenderDrawRectF(self.context.raw, rect.raw()) };
+        if result != 0 {
+            Err(get_error())
+        } else {
+            Ok(())
+        }
+    }
+
+    /// Draws some number of rectangles on the current rendering target.
+    /// Errors if drawing fails for any reason (e.g. driver failure)
+    #[doc(alias = "SDL_RenderDrawRectsF")]
+    pub fn draw_frects(&mut self, rects: &[FRect]) -> Result<(), String> {
+        let result = unsafe {
+            sys::SDL_RenderDrawRectsF(
+                self.context.raw,
+                FRect::raw_slice(rects),
+                rects.len() as c_int,
+            )
+        };
+        if result != 0 {
+            Err(get_error())
+        } else {
+            Ok(())
+        }
+    }
+
+    /// Fills a rectangle on the current rendering target with the drawing
+    /// color.
+    /// Passing None will fill the entire rendering target.
+    /// Errors if drawing fails for any reason (e.g. driver failure)
+    #[doc(alias = "SDL_RenderFillRectF")]
+    pub fn fill_frect<R: Into<Option<FRect>>>(&mut self, rect: R) -> Result<(), String> {
+        let result = unsafe {
+            sys::SDL_RenderFillRectF(
+                self.context.raw,
+                rect.into().as_ref().map(|r| r.raw()).unwrap_or(ptr::null()),
+            )
+        };
+        if result != 0 {
+            Err(get_error())
+        } else {
+            Ok(())
+        }
+    }
+
+    /// Fills some number of rectangles on the current rendering target with
+    /// the drawing color.
+    /// Errors if drawing fails for any reason (e.g. driver failure)
+    #[doc(alias = "SDL_RenderFillRectsF")]
+    pub fn fill_frects(&mut self, rects: &[FRect]) -> Result<(), String> {
+        let result = unsafe {
+            sys::SDL_RenderFillRectsF(
+                self.context.raw,
+                FRect::raw_slice(rects),
+                rects.len() as c_int,
+            )
+        };
+        if result != 0 {
+            Err(get_error())
+        } else {
+            Ok(())
+        }
+    }
+
+    /// Copies a portion of the texture to the current rendering target.
+    ///
+    /// * If `src` is `None`, the entire texture is copied.
+    /// * If `dst` is `None`, the texture will be stretched to fill the given
+    ///   rectangle.
+    ///
+    /// Errors if drawing fails for any reason (e.g. driver failure),
+    /// or if the provided texture does not belong to the renderer.
+    #[doc(alias = "SDL_RenderCopyF")]
+    pub fn copy_f<R1, R2>(&mut self, texture: &Texture, src: R1, dst: R2) -> Result<(), String>
+    where
+        R1: Into<Option<Rect>>,
+        R2: Into<Option<FRect>>,
+    {
+        let ret = unsafe {
+            sys::SDL_RenderCopyF(
+                self.context.raw,
+                texture.raw,
+                match src.into() {
+                    Some(ref rect) => rect.raw(),
+                    None => ptr::null(),
+                },
+                match dst.into() {
+                    Some(ref rect) => rect.raw(),
+                    None => ptr::null(),
+                },
+            )
+        };
+
+        if ret != 0 {
+            Err(get_error())
+        } else {
+            Ok(())
+        }
+    }
+
+    /// Copies a portion of the texture to the current rendering target,
+    /// optionally rotating it by angle around the given center and also
+    /// flipping it top-bottom and/or left-right.
+    ///
+    /// * If `src` is `None`, the entire texture is copied.
+    /// * If `dst` is `None`, the texture will be stretched to fill the given
+    ///   rectangle.
+    /// * If `center` is `None`, rotation will be done around the center point
+    ///   of `dst`, or `src` if `dst` is None.
+    ///
+    /// Errors if drawing fails for any reason (e.g. driver failure),
+    /// if the provided texture does not belong to the renderer,
+    /// or if the driver does not support RenderCopyEx.
+    #[doc(alias = "SDL_RenderCopyExF")]
+    pub fn copy_ex_f<R1, R2, P>(
+        &mut self,
+        texture: &Texture,
+        src: R1,
+        dst: R2,
+        angle: f64,
+        center: P,
+        flip_horizontal: bool,
+        flip_vertical: bool,
+    ) -> Result<(), String>
+    where
+        R1: Into<Option<Rect>>,
+        R2: Into<Option<FRect>>,
+        P: Into<Option<FPoint>>,
+    {
+        use crate::sys::SDL_RendererFlip::*;
+        let flip = unsafe {
+            match (flip_horizontal, flip_vertical) {
+                (false, false) => SDL_FLIP_NONE,
+                (true, false) => SDL_FLIP_HORIZONTAL,
+                (false, true) => SDL_FLIP_VERTICAL,
+                (true, true) => transmute::<u32, sys::SDL_RendererFlip>(
+                    transmute::<sys::SDL_RendererFlip, u32>(SDL_FLIP_HORIZONTAL)
+                        | transmute::<sys::SDL_RendererFlip, u32>(SDL_FLIP_VERTICAL),
+                ),
+            }
+        };
+
+        let ret = unsafe {
+            sys::SDL_RenderCopyExF(
+                self.context.raw,
+                texture.raw,
+                match src.into() {
+                    Some(ref rect) => rect.raw(),
+                    None => ptr::null(),
+                },
+                match dst.into() {
+                    Some(ref rect) => rect.raw(),
+                    None => ptr::null(),
+                },
+                angle as c_double,
+                match center.into() {
+                    Some(ref point) => point.raw(),
+                    None => ptr::null(),
+                },
+                flip,
+            )
+        };
+
+        if ret != 0 {
+            Err(get_error())
+        } else {
+            Ok(())
+        }
+    }
+
     /// Copies a portion of the texture to the current rendering target.
     ///
     /// * If `src` is `None`, the entire texture is copied.
diff --git a/src/sdl2/rwops.rs b/src/sdl2/rwops.rs
index d48332b7e8..33478137f8 100644
--- a/src/sdl2/rwops.rs
+++ b/src/sdl2/rwops.rs
@@ -145,7 +145,7 @@ impl<'a> io::Read for RWops<'a> {
                 self.raw,
                 buf.as_ptr() as *mut c_void,
                 1,
-                out_len as sys::size_t,
+                out_len as libc::size_t,
             )
         };
         Ok(ret as usize)
@@ -160,7 +160,7 @@ impl<'a> io::Write for RWops<'a> {
                 self.raw,
                 buf.as_ptr() as *const c_void,
                 1,
-                in_len as sys::size_t,
+                in_len as libc::size_t,
             )
         };
         Ok(ret as usize)
diff --git a/src/sdl2/video.rs b/src/sdl2/video.rs
index 22a6deef06..f6996262bd 100644
--- a/src/sdl2/video.rs
+++ b/src/sdl2/video.rs
@@ -1489,7 +1489,7 @@ impl Window {
     #[doc(alias = "SDL_GetWindowICCProfile")]
     pub fn icc_profile(&self) -> Result<Vec<u8>, String> {
         unsafe {
-            let mut size: sys::size_t = 0;
+            let mut size: libc::size_t = 0;
             let data = sys::SDL_GetWindowICCProfile(self.context.raw, &mut size as *mut _);
             if data.is_null() {
                 return Err(get_error());
@@ -1556,9 +1556,9 @@ impl Window {
     #[doc(alias = "SDL_SetWindowResizable")]
     pub fn set_resizable(&mut self, resizable: bool) {
         let resizable = if resizable {
-            SDL_bool::SDL_TRUE
+            sys::SDL_bool::SDL_TRUE
         } else {
-            SDL_bool::SDL_FALSE
+            sys::SDL_bool::SDL_FALSE
         };
         unsafe {
             sys::SDL_SetWindowResizable(self.context.raw, resizable);


Test patch:
diff --git a/tests/raw_window_handle.rs b/tests/raw_window_handle.rs
index 373fd1db81..9ebb536086 100644
--- a/tests/raw_window_handle.rs
+++ b/tests/raw_window_handle.rs
@@ -13,17 +13,19 @@ mod raw_window_handle_test {
     fn get_windows_handle() {
         let window = new_hidden_window();
         match window.window_handle() {
-            Ok(window_handle) => {
-                match window_handle.as_raw()  {
-                    RawWindowHandle::Win32(_) => {
-                        println!("Successfully received Win32 window handle")
-                    },
-                    RawWindowHandle::WinRt(_) => {
-                        println!("Successfully received WinRt window handle")
-                    }
-                    raw_handle => {
-                        assert!(false, "Wrong window handle type for Windows: {:?}", raw_handle)
-                    }
+            Ok(window_handle) => match window_handle.as_raw() {
+                RawWindowHandle::Win32(_) => {
+                    println!("Successfully received Win32 window handle")
+                }
+                RawWindowHandle::WinRt(_) => {
+                    println!("Successfully received WinRt window handle")
+                }
+                raw_handle => {
+                    assert!(
+                        false,
+                        "Wrong window handle type for Windows: {:?}",
+                        raw_handle
+                    )
                 }
             },
             Err(e) => {
@@ -31,18 +33,24 @@ mod raw_window_handle_test {
             }
         }
         match window.display_handle() {
-            Ok(display_handle) => {
-                match display_handle.as_raw() {
-                    RawDisplayHandle::Windows(_) => {
-                        println!("Successfully received Windows display handle")
-                    },
-                    raw_handle => {
-                        assert!(false, "Wrong display handle type for Windows: {:?}", raw_handle)
-                    }
+            Ok(display_handle) => match display_handle.as_raw() {
+                RawDisplayHandle::Windows(_) => {
+                    println!("Successfully received Windows display handle")
+                }
+                raw_handle => {
+                    assert!(
+                        false,
+                        "Wrong display handle type for Windows: {:?}",
+                        raw_handle
+                    )
                 }
             },
             Err(e) => {
-                assert!(false, "Failed to recieve display handle on Windows: {:?}", e)
+                assert!(
+                    false,
+                    "Failed to recieve display handle on Windows: {:?}",
+                    e
+                )
             }
         }
     }
@@ -58,17 +66,19 @@ mod raw_window_handle_test {
     fn get_linux_handle() {
         let window = new_hidden_window();
         match window.window_handle() {
-            Ok(handle) => {
-                match handle.as_raw() {
-                    RawWindowHandle::Xlib(_) => {
-                        println!("Successfully received X11 window handle")
-                    }
-                    RawWindowHandle::Wayland(_) => {
-                        println!("Successfully received Wayland window handle")
-                    }
-                    raw_handle => {
-                        assert!(false, "Wrong window handle type for Linux: {:?}", raw_handle)
-                    }
+            Ok(handle) => match handle.as_raw() {
+                RawWindowHandle::Xlib(_) => {
+                    println!("Successfully received X11 window handle")
+                }
+                RawWindowHandle::Wayland(_) => {
+                    println!("Successfully received Wayland window handle")
+                }
+                raw_handle => {
+                    assert!(
+                        false,
+                        "Wrong window handle type for Linux: {:?}",
+                        raw_handle
+                    )
                 }
             },
             Err(e) => {
@@ -76,22 +86,24 @@ mod raw_window_handle_test {
             }
         }
         match window.display_handle() {
-            Ok(handle) => {
-                match handle.as_raw() {
-                    RawDisplayHandle::Xlib(_) => {
-                        println!("Successfully recieved X11 display handle")
-                    }
-                    RawDisplayHandle::Wayland(_) => {
-                        println!("Successfully recieved Wayland display handle")
-                    }
-                    raw_handle => {
-                        assert!(false, "Wrong display handle type for Linux: {:?}", raw_handle)
-                    }
+            Ok(handle) => match handle.as_raw() {
+                RawDisplayHandle::Xlib(_) => {
+                    println!("Successfully recieved X11 display handle")
                 }
-            }
+                RawDisplayHandle::Wayland(_) => {
+                    println!("Successfully recieved Wayland display handle")
+                }
+                raw_handle => {
+                    assert!(
+                        false,
+                        "Wrong display handle type for Linux: {:?}",
+                        raw_handle
+                    )
+                }
+            },
             Err(e) => {
                 assert!(false, "Failed to recieve display handle on Linux: {:?}", e)
-            },
+            }
         }
     }
 
@@ -100,29 +112,33 @@ mod raw_window_handle_test {
     fn get_macos_handle() {
         let window = new_hidden_window();
         match window.window_handle() {
-            Ok(handle) => {
-                match handle.as_raw() {
-                    RawWindowHandle::AppKit(_) => {
-                        println!("Successfully recieved AppKit window handle")
-                    }
-                    raw_handle => {
-                        assert!(false, "Wrong window handle type for macOS: {:?}", raw_handle)
-                    }
+            Ok(handle) => match handle.as_raw() {
+                RawWindowHandle::AppKit(_) => {
+                    println!("Successfully recieved AppKit window handle")
                 }
-            }
+                raw_handle => {
+                    assert!(
+                        false,
+                        "Wrong window handle type for macOS: {:?}",
+                        raw_handle
+                    )
+                }
+            },
             Err(e) => {
                 assert!(false, "Failed to recieve window handle on macOS: {:?}", e)
             }
         };
         match window.display_handle() {
-            Ok(handle) => {
-                match handle.as_raw(){
-                    RawDisplayHandle::AppKit(_) => {
-                        println!("Successfully recieved AppKit display handle")
-                    }
-                    raw_handle =>  {
-                        assert!(false, "Wrong display handle type for macOS: {:?}", raw_handle)
-                    }
+            Ok(handle) => match handle.as_raw() {
+                RawDisplayHandle::AppKit(_) => {
+                    println!("Successfully recieved AppKit display handle")
+                }
+                raw_handle => {
+                    assert!(
+                        false,
+                        "Wrong display handle type for macOS: {:?}",
+                        raw_handle
+                    )
                 }
             },
             Err(e) => {