[INFO] cloning repository https://github.com/IllusionMan1212/glad-repro
[INFO] running `Command { std: "git" "-c" "credential.helper=" "-c" "credential.helper=/workspace/cargo-home/bin/git-credential-null" "clone" "--bare" "https://github.com/IllusionMan1212/glad-repro" "/workspace/cache/git-repos/https%3A%2F%2Fgithub.com%2FIllusionMan1212%2Fglad-repro", kill_on_drop: false }`
[INFO] [stderr] Cloning into bare repository '/workspace/cache/git-repos/https%3A%2F%2Fgithub.com%2FIllusionMan1212%2Fglad-repro'...
[INFO] running `Command { std: "git" "rev-parse" "HEAD", kill_on_drop: false }`
[INFO] [stdout] 2fa4a305da3c8f372eb641786dc79f171941fae9
[INFO] documenting IllusionMan1212/glad-repro against 1.76.0 for beta-1.77-rustdoc-1
[INFO] running `Command { std: "git" "clone" "/workspace/cache/git-repos/https%3A%2F%2Fgithub.com%2FIllusionMan1212%2Fglad-repro" "/workspace/builds/worker-4-tc1/source", kill_on_drop: false }`
[INFO] [stderr] Cloning into '/workspace/builds/worker-4-tc1/source'...
[INFO] [stderr] done.
[INFO] validating manifest of git repo https://github.com/IllusionMan1212/glad-repro on toolchain 1.76.0
[INFO] running `Command { std: CARGO_HOME="/workspace/cargo-home" RUSTUP_HOME="/workspace/rustup-home" "/workspace/cargo-home/bin/cargo" "+1.76.0" "metadata" "--manifest-path" "Cargo.toml" "--no-deps", kill_on_drop: false }`
[INFO] started tweaking git repo https://github.com/IllusionMan1212/glad-repro
[INFO] finished tweaking git repo https://github.com/IllusionMan1212/glad-repro
[INFO] tweaked toml for git repo https://github.com/IllusionMan1212/glad-repro written to /workspace/builds/worker-4-tc1/source/Cargo.toml
[INFO] crate git repo https://github.com/IllusionMan1212/glad-repro already has a lockfile, it will not be regenerated
[INFO] running `Command { std: CARGO_HOME="/workspace/cargo-home" RUSTUP_HOME="/workspace/rustup-home" "/workspace/cargo-home/bin/cargo" "+1.76.0" "fetch" "--manifest-path" "Cargo.toml", kill_on_drop: false }`
[INFO] [stderr]     Updating crates.io index
[INFO] [stderr]  Downloading crates ...
[INFO] [stderr]   Downloaded glm v0.2.3
[INFO] running `Command { std: "docker" "create" "-v" "/var/lib/crater-agent-workspace/builds/worker-4-tc1/target:/opt/rustwide/target:rw,Z" "-v" "/var/lib/crater-agent-workspace/builds/worker-4-tc1/source:/opt/rustwide/workdir:ro,Z" "-v" "/var/lib/crater-agent-workspace/cargo-home:/opt/rustwide/cargo-home:ro,Z" "-v" "/var/lib/crater-agent-workspace/rustup-home:/opt/rustwide/rustup-home:ro,Z" "-e" "SOURCE_DIR=/opt/rustwide/workdir" "-e" "CARGO_TARGET_DIR=/opt/rustwide/target" "-e" "CARGO_HOME=/opt/rustwide/cargo-home" "-e" "RUSTUP_HOME=/opt/rustwide/rustup-home" "-w" "/opt/rustwide/workdir" "-m" "1610612736" "--user" "0:0" "--network" "none" "ghcr.io/rust-lang/crates-build-env/linux@sha256:2788e3201cd34a07e3172128adcd8b3090168a8e3bcc40d7c032b9dda1df7d1c" "/opt/rustwide/cargo-home/bin/cargo" "+1.76.0" "metadata" "--no-deps" "--format-version=1", kill_on_drop: false }`
[INFO] [stdout] a36355ebc474fdd7820cecbca5c1c5a62a1115ac090b3028384affc992da12e7
[INFO] running `Command { std: "docker" "start" "-a" "a36355ebc474fdd7820cecbca5c1c5a62a1115ac090b3028384affc992da12e7", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "inspect" "a36355ebc474fdd7820cecbca5c1c5a62a1115ac090b3028384affc992da12e7", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "rm" "-f" "a36355ebc474fdd7820cecbca5c1c5a62a1115ac090b3028384affc992da12e7", kill_on_drop: false }`
[INFO] [stdout] a36355ebc474fdd7820cecbca5c1c5a62a1115ac090b3028384affc992da12e7
[INFO] running `Command { std: "docker" "create" "-v" "/var/lib/crater-agent-workspace/builds/worker-4-tc1/target:/opt/rustwide/target:rw,Z" "-v" "/var/lib/crater-agent-workspace/builds/worker-4-tc1/source:/opt/rustwide/workdir:ro,Z" "-v" "/var/lib/crater-agent-workspace/cargo-home:/opt/rustwide/cargo-home:ro,Z" "-v" "/var/lib/crater-agent-workspace/rustup-home:/opt/rustwide/rustup-home:ro,Z" "-e" "SOURCE_DIR=/opt/rustwide/workdir" "-e" "CARGO_TARGET_DIR=/opt/rustwide/target" "-e" "CARGO_INCREMENTAL=0" "-e" "RUST_BACKTRACE=full" "-e" "RUSTFLAGS=--cap-lints=warn" "-e" "RUSTDOCFLAGS=--cap-lints=warn" "-e" "CARGO_HOME=/opt/rustwide/cargo-home" "-e" "RUSTUP_HOME=/opt/rustwide/rustup-home" "-w" "/opt/rustwide/workdir" "-m" "1610612736" "--user" "0:0" "--network" "none" "ghcr.io/rust-lang/crates-build-env/linux@sha256:2788e3201cd34a07e3172128adcd8b3090168a8e3bcc40d7c032b9dda1df7d1c" "/opt/rustwide/cargo-home/bin/cargo" "+1.76.0" "doc" "--frozen" "--no-deps" "--document-private-items" "--message-format=json", kill_on_drop: false }`
[INFO] [stdout] a58582f9af881cb0330685a71e8d19ac0369fd8f3786fb8add53328aec433184
[INFO] running `Command { std: "docker" "start" "-a" "a58582f9af881cb0330685a71e8d19ac0369fd8f3786fb8add53328aec433184", kill_on_drop: false }`
[INFO] [stderr]    Compiling libc v0.2.142
[INFO] [stderr]    Compiling autocfg v1.1.0
[INFO] [stderr]    Compiling winapi-build v0.1.1
[INFO] [stderr]     Checking winapi v0.2.8
[INFO] [stderr]    Compiling log v0.4.17
[INFO] [stderr]    Compiling cc v1.0.79
[INFO] [stderr]     Checking rustc-serialize v0.3.24
[INFO] [stderr]     Checking regex-syntax v0.3.9
[INFO] [stderr]     Checking utf8-ranges v0.1.3
[INFO] [stderr]    Compiling kernel32-sys v0.2.2
[INFO] [stderr]     Checking bitflags v1.3.2
[INFO] [stderr]     Checking raw-window-handle v0.5.2
[INFO] [stdout] error[E0310]: the parameter type `T` may not live long enough
[INFO] [stdout]     --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/rustc-serialize-0.3.24/src/serialize.rs:1155:5
[INFO] [stdout]      |
[INFO] [stdout] 1155 |     fn decode<D: Decoder>(d: &mut D) -> Result<Cow<'static, T>, D::Error> {
[INFO] [stdout]      |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |     |
[INFO] [stdout]      |     the parameter type `T` must be valid for the static lifetime...
[INFO] [stdout]      |     ...so that the type `T` will meet its required lifetime bounds...
[INFO] [stdout]      |
[INFO] [stdout] note: ...that is required by this bound
[INFO] [stdout]     --> /rustc/07dca489ac2d933c78d3c5158e3f43beefeb02ce/library/alloc/src/borrow.rs:180:30
[INFO] [stdout] help: consider adding an explicit lifetime bound
[INFO] [stdout]      |
[INFO] [stdout] 1151 | impl<'a, T: ?Sized + 'static> Decodable for Cow<'a, T>
[INFO] [stdout]      |                    +++++++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stderr]     Checking glad-gl v2.0.4 (/opt/rustwide/workdir/3rdparty/glad-gl)
[INFO] [stderr]    Compiling num-traits v0.2.15
[INFO] [stderr]    Compiling num-integer v0.1.45
[INFO] [stderr]    Compiling num-iter v0.1.43
[INFO] [stderr]    Compiling cmake v0.1.50
[INFO] [stderr]     Checking log v0.3.9
[INFO] [stdout] error: aborting due to 1 previous error
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] For more information about this error, try `rustc --explain E0310`.
[INFO] [stdout] 
[INFO] [stderr] error: could not compile `rustc-serialize` (lib) due to 2 previous errors
[INFO] [stderr] warning: build failed, waiting for other jobs to finish...
[INFO] running `Command { std: "docker" "inspect" "a58582f9af881cb0330685a71e8d19ac0369fd8f3786fb8add53328aec433184", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "rm" "-f" "a58582f9af881cb0330685a71e8d19ac0369fd8f3786fb8add53328aec433184", kill_on_drop: false }`
[INFO] [stdout] a58582f9af881cb0330685a71e8d19ac0369fd8f3786fb8add53328aec433184
[INFO] documenting IllusionMan1212/glad-repro against beta-2024-02-10 for beta-1.77-rustdoc-1
[INFO] running `Command { std: "git" "clone" "/workspace/cache/git-repos/https%3A%2F%2Fgithub.com%2FIllusionMan1212%2Fglad-repro" "/workspace/builds/worker-4-tc2/source", kill_on_drop: false }`
[INFO] [stderr] Cloning into '/workspace/builds/worker-4-tc2/source'...
[INFO] [stderr] done.
[INFO] validating manifest of git repo https://github.com/IllusionMan1212/glad-repro on toolchain beta-2024-02-10
[INFO] running `Command { std: CARGO_HOME="/workspace/cargo-home" RUSTUP_HOME="/workspace/rustup-home" "/workspace/cargo-home/bin/cargo" "+beta-2024-02-10" "metadata" "--manifest-path" "Cargo.toml" "--no-deps", kill_on_drop: false }`
[INFO] started tweaking git repo https://github.com/IllusionMan1212/glad-repro
[INFO] finished tweaking git repo https://github.com/IllusionMan1212/glad-repro
[INFO] tweaked toml for git repo https://github.com/IllusionMan1212/glad-repro written to /workspace/builds/worker-4-tc2/source/Cargo.toml
[INFO] crate git repo https://github.com/IllusionMan1212/glad-repro already has a lockfile, it will not be regenerated
[INFO] running `Command { std: CARGO_HOME="/workspace/cargo-home" RUSTUP_HOME="/workspace/rustup-home" "/workspace/cargo-home/bin/cargo" "+beta-2024-02-10" "fetch" "--manifest-path" "Cargo.toml", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "create" "-v" "/var/lib/crater-agent-workspace/builds/worker-4-tc2/target:/opt/rustwide/target:rw,Z" "-v" "/var/lib/crater-agent-workspace/builds/worker-4-tc2/source:/opt/rustwide/workdir:ro,Z" "-v" "/var/lib/crater-agent-workspace/cargo-home:/opt/rustwide/cargo-home:ro,Z" "-v" "/var/lib/crater-agent-workspace/rustup-home:/opt/rustwide/rustup-home:ro,Z" "-e" "SOURCE_DIR=/opt/rustwide/workdir" "-e" "CARGO_TARGET_DIR=/opt/rustwide/target" "-e" "CARGO_HOME=/opt/rustwide/cargo-home" "-e" "RUSTUP_HOME=/opt/rustwide/rustup-home" "-w" "/opt/rustwide/workdir" "-m" "1610612736" "--user" "0:0" "--network" "none" "ghcr.io/rust-lang/crates-build-env/linux@sha256:2788e3201cd34a07e3172128adcd8b3090168a8e3bcc40d7c032b9dda1df7d1c" "/opt/rustwide/cargo-home/bin/cargo" "+beta-2024-02-10" "metadata" "--no-deps" "--format-version=1", kill_on_drop: false }`
[INFO] [stdout] 1666d80d62d6523475fbddd6822d041f72072134c613189a1f61f90967d766b0
[INFO] running `Command { std: "docker" "start" "-a" "1666d80d62d6523475fbddd6822d041f72072134c613189a1f61f90967d766b0", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "inspect" "1666d80d62d6523475fbddd6822d041f72072134c613189a1f61f90967d766b0", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "rm" "-f" "1666d80d62d6523475fbddd6822d041f72072134c613189a1f61f90967d766b0", kill_on_drop: false }`
[INFO] [stdout] 1666d80d62d6523475fbddd6822d041f72072134c613189a1f61f90967d766b0
[INFO] running `Command { std: "docker" "create" "-v" "/var/lib/crater-agent-workspace/builds/worker-4-tc2/target:/opt/rustwide/target:rw,Z" "-v" "/var/lib/crater-agent-workspace/builds/worker-4-tc2/source:/opt/rustwide/workdir:ro,Z" "-v" "/var/lib/crater-agent-workspace/cargo-home:/opt/rustwide/cargo-home:ro,Z" "-v" "/var/lib/crater-agent-workspace/rustup-home:/opt/rustwide/rustup-home:ro,Z" "-e" "SOURCE_DIR=/opt/rustwide/workdir" "-e" "CARGO_TARGET_DIR=/opt/rustwide/target" "-e" "CARGO_INCREMENTAL=0" "-e" "RUST_BACKTRACE=full" "-e" "RUSTFLAGS=--cap-lints=warn" "-e" "RUSTDOCFLAGS=--cap-lints=warn" "-e" "CARGO_HOME=/opt/rustwide/cargo-home" "-e" "RUSTUP_HOME=/opt/rustwide/rustup-home" "-w" "/opt/rustwide/workdir" "-m" "1610612736" "--user" "0:0" "--network" "none" "ghcr.io/rust-lang/crates-build-env/linux@sha256:2788e3201cd34a07e3172128adcd8b3090168a8e3bcc40d7c032b9dda1df7d1c" "/opt/rustwide/cargo-home/bin/cargo" "+beta-2024-02-10" "doc" "--frozen" "--no-deps" "--document-private-items" "--message-format=json", kill_on_drop: false }`
[INFO] [stdout] b04c938b31ecfa8b6be4b6e81504b4fd315c5c5f8e8a74a8d5b4c0620e504399
[INFO] running `Command { std: "docker" "start" "-a" "b04c938b31ecfa8b6be4b6e81504b4fd315c5c5f8e8a74a8d5b4c0620e504399", kill_on_drop: false }`
[INFO] [stderr]    Compiling libc v0.2.142
[INFO] [stderr]    Compiling autocfg v1.1.0
[INFO] [stderr]    Compiling winapi-build v0.1.1
[INFO] [stderr]     Checking winapi v0.2.8
[INFO] [stderr]    Compiling log v0.4.17
[INFO] [stderr]    Compiling cc v1.0.79
[INFO] [stderr]     Checking rustc-serialize v0.3.24
[INFO] [stderr]     Checking utf8-ranges v0.1.3
[INFO] [stderr]     Checking regex-syntax v0.3.9
[INFO] [stderr]    Compiling kernel32-sys v0.2.2
[INFO] [stderr]     Checking bitflags v1.3.2
[INFO] [stderr]     Checking raw-window-handle v0.5.2
[INFO] [stdout] error[E0310]: the parameter type `T` may not live long enough
[INFO] [stdout]     --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/rustc-serialize-0.3.24/src/serialize.rs:1155:5
[INFO] [stdout]      |
[INFO] [stdout] 1155 |     fn decode<D: Decoder>(d: &mut D) -> Result<Cow<'static, T>, D::Error> {
[INFO] [stdout]      |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |     |
[INFO] [stdout]      |     the parameter type `T` must be valid for the static lifetime...
[INFO] [stdout]      |     ...so that the type `T` will meet its required lifetime bounds...
[INFO] [stdout]      |
[INFO] [stdout] note: ...that is required by this bound
[INFO] [stdout]     --> /rustc/f2048098a1ca42a520e7bed68e321a66edc0a1b1/library/alloc/src/borrow.rs:180:30
[INFO] [stdout] help: consider adding an explicit lifetime bound
[INFO] [stdout]      |
[INFO] [stdout] 1151 | impl<'a, T: ?Sized + 'static> Decodable for Cow<'a, T>
[INFO] [stdout]      |                    +++++++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stderr]     Checking glad-gl v2.0.4 (/opt/rustwide/workdir/3rdparty/glad-gl)
[INFO] [stderr]    Compiling num-traits v0.2.15
[INFO] [stderr]    Compiling num-integer v0.1.45
[INFO] [stderr]    Compiling num-iter v0.1.43
[INFO] [stderr]    Compiling cmake v0.1.50
[INFO] [stderr]     Checking log v0.3.9
[INFO] [stdout] error: aborting due to 1 previous error
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] For more information about this error, try `rustc --explain E0310`.
[INFO] [stdout] 
[INFO] [stderr] error: could not compile `rustc-serialize` (lib) due to 2 previous errors
[INFO] [stderr] warning: build failed, waiting for other jobs to finish...
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12226:41
[INFO] [stdout]       |
[INFO] [stdout] 12226 |          storage::ActiveTexture.aliased(&storage::ActiveTextureARB);
[INFO] [stdout]       |                                         ^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout]       = note: `#[warn(static_mut_ref)]` on by default
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12226 |          storage::ActiveTexture.aliased(addr_of!(storage::ActiveTextureARB));
[INFO] [stdout]       |                                         ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12227:44
[INFO] [stdout]       |
[INFO] [stdout] 12227 |          storage::ActiveTextureARB.aliased(&storage::ActiveTexture);
[INFO] [stdout]       |                                            ^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12227 |          storage::ActiveTextureARB.aliased(addr_of!(storage::ActiveTexture));
[INFO] [stdout]       |                                            ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12228:43
[INFO] [stdout]       |
[INFO] [stdout] 12228 |          storage::AttachObjectARB.aliased(&storage::AttachShader);
[INFO] [stdout]       |                                           ^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12228 |          storage::AttachObjectARB.aliased(addr_of!(storage::AttachShader));
[INFO] [stdout]       |                                           ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12229:40
[INFO] [stdout]       |
[INFO] [stdout] 12229 |          storage::AttachShader.aliased(&storage::AttachObjectARB);
[INFO] [stdout]       |                                        ^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12229 |          storage::AttachShader.aliased(addr_of!(storage::AttachObjectARB));
[INFO] [stdout]       |                                        ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12230:50
[INFO] [stdout]       |
[INFO] [stdout] 12230 |          storage::BeginConditionalRender.aliased(&storage::BeginConditionalRenderNV);
[INFO] [stdout]       |                                                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12230 |          storage::BeginConditionalRender.aliased(addr_of!(storage::BeginConditionalRenderNV));
[INFO] [stdout]       |                                                  ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12231:52
[INFO] [stdout]       |
[INFO] [stdout] 12231 |          storage::BeginConditionalRenderNV.aliased(&storage::BeginConditionalRender);
[INFO] [stdout]       |                                                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12231 |          storage::BeginConditionalRenderNV.aliased(addr_of!(storage::BeginConditionalRender));
[INFO] [stdout]       |                                                    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12232:38
[INFO] [stdout]       |
[INFO] [stdout] 12232 |          storage::BeginQuery.aliased(&storage::BeginQueryARB);
[INFO] [stdout]       |                                      ^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12232 |          storage::BeginQuery.aliased(addr_of!(storage::BeginQueryARB));
[INFO] [stdout]       |                                      ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12233:41
[INFO] [stdout]       |
[INFO] [stdout] 12233 |          storage::BeginQueryARB.aliased(&storage::BeginQuery);
[INFO] [stdout]       |                                         ^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12233 |          storage::BeginQueryARB.aliased(addr_of!(storage::BeginQuery));
[INFO] [stdout]       |                                         ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12234:50
[INFO] [stdout]       |
[INFO] [stdout] 12234 |          storage::BeginTransformFeedback.aliased(&storage::BeginTransformFeedbackEXT);
[INFO] [stdout]       |                                                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12234 |          storage::BeginTransformFeedback.aliased(addr_of!(storage::BeginTransformFeedbackEXT));
[INFO] [stdout]       |                                                  ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12235:50
[INFO] [stdout]       |
[INFO] [stdout] 12235 |          storage::BeginTransformFeedback.aliased(&storage::BeginTransformFeedbackNV);
[INFO] [stdout]       |                                                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12235 |          storage::BeginTransformFeedback.aliased(addr_of!(storage::BeginTransformFeedbackNV));
[INFO] [stdout]       |                                                  ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12236:53
[INFO] [stdout]       |
[INFO] [stdout] 12236 |          storage::BeginTransformFeedbackEXT.aliased(&storage::BeginTransformFeedback);
[INFO] [stdout]       |                                                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12236 |          storage::BeginTransformFeedbackEXT.aliased(addr_of!(storage::BeginTransformFeedback));
[INFO] [stdout]       |                                                     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12237:53
[INFO] [stdout]       |
[INFO] [stdout] 12237 |          storage::BeginTransformFeedbackEXT.aliased(&storage::BeginTransformFeedbackNV);
[INFO] [stdout]       |                                                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12237 |          storage::BeginTransformFeedbackEXT.aliased(addr_of!(storage::BeginTransformFeedbackNV));
[INFO] [stdout]       |                                                     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12238:52
[INFO] [stdout]       |
[INFO] [stdout] 12238 |          storage::BeginTransformFeedbackNV.aliased(&storage::BeginTransformFeedback);
[INFO] [stdout]       |                                                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12238 |          storage::BeginTransformFeedbackNV.aliased(addr_of!(storage::BeginTransformFeedback));
[INFO] [stdout]       |                                                    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12239:52
[INFO] [stdout]       |
[INFO] [stdout] 12239 |          storage::BeginTransformFeedbackNV.aliased(&storage::BeginTransformFeedbackEXT);
[INFO] [stdout]       |                                                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12239 |          storage::BeginTransformFeedbackNV.aliased(addr_of!(storage::BeginTransformFeedbackEXT));
[INFO] [stdout]       |                                                    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12240:46
[INFO] [stdout]       |
[INFO] [stdout] 12240 |          storage::BindAttribLocation.aliased(&storage::BindAttribLocationARB);
[INFO] [stdout]       |                                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12240 |          storage::BindAttribLocation.aliased(addr_of!(storage::BindAttribLocationARB));
[INFO] [stdout]       |                                              ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12241:49
[INFO] [stdout]       |
[INFO] [stdout] 12241 |          storage::BindAttribLocationARB.aliased(&storage::BindAttribLocation);
[INFO] [stdout]       |                                                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12241 |          storage::BindAttribLocationARB.aliased(addr_of!(storage::BindAttribLocation));
[INFO] [stdout]       |                                                 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12242:38
[INFO] [stdout]       |
[INFO] [stdout] 12242 |          storage::BindBuffer.aliased(&storage::BindBufferARB);
[INFO] [stdout]       |                                      ^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12242 |          storage::BindBuffer.aliased(addr_of!(storage::BindBufferARB));
[INFO] [stdout]       |                                      ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12243:41
[INFO] [stdout]       |
[INFO] [stdout] 12243 |          storage::BindBufferARB.aliased(&storage::BindBuffer);
[INFO] [stdout]       |                                         ^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12243 |          storage::BindBufferARB.aliased(addr_of!(storage::BindBuffer));
[INFO] [stdout]       |                                         ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12244:42
[INFO] [stdout]       |
[INFO] [stdout] 12244 |          storage::BindBufferBase.aliased(&storage::BindBufferBaseEXT);
[INFO] [stdout]       |                                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12244 |          storage::BindBufferBase.aliased(addr_of!(storage::BindBufferBaseEXT));
[INFO] [stdout]       |                                          ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12245:42
[INFO] [stdout]       |
[INFO] [stdout] 12245 |          storage::BindBufferBase.aliased(&storage::BindBufferBaseNV);
[INFO] [stdout]       |                                          ^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12245 |          storage::BindBufferBase.aliased(addr_of!(storage::BindBufferBaseNV));
[INFO] [stdout]       |                                          ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12246:45
[INFO] [stdout]       |
[INFO] [stdout] 12246 |          storage::BindBufferBaseEXT.aliased(&storage::BindBufferBase);
[INFO] [stdout]       |                                             ^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12246 |          storage::BindBufferBaseEXT.aliased(addr_of!(storage::BindBufferBase));
[INFO] [stdout]       |                                             ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12247:45
[INFO] [stdout]       |
[INFO] [stdout] 12247 |          storage::BindBufferBaseEXT.aliased(&storage::BindBufferBaseNV);
[INFO] [stdout]       |                                             ^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12247 |          storage::BindBufferBaseEXT.aliased(addr_of!(storage::BindBufferBaseNV));
[INFO] [stdout]       |                                             ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12248:44
[INFO] [stdout]       |
[INFO] [stdout] 12248 |          storage::BindBufferBaseNV.aliased(&storage::BindBufferBase);
[INFO] [stdout]       |                                            ^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12248 |          storage::BindBufferBaseNV.aliased(addr_of!(storage::BindBufferBase));
[INFO] [stdout]       |                                            ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12249:44
[INFO] [stdout]       |
[INFO] [stdout] 12249 |          storage::BindBufferBaseNV.aliased(&storage::BindBufferBaseEXT);
[INFO] [stdout]       |                                            ^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12249 |          storage::BindBufferBaseNV.aliased(addr_of!(storage::BindBufferBaseEXT));
[INFO] [stdout]       |                                            ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12250:47
[INFO] [stdout]       |
[INFO] [stdout] 12250 |          storage::BindBufferOffsetEXT.aliased(&storage::BindBufferOffsetNV);
[INFO] [stdout]       |                                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12250 |          storage::BindBufferOffsetEXT.aliased(addr_of!(storage::BindBufferOffsetNV));
[INFO] [stdout]       |                                               ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12251:46
[INFO] [stdout]       |
[INFO] [stdout] 12251 |          storage::BindBufferOffsetNV.aliased(&storage::BindBufferOffsetEXT);
[INFO] [stdout]       |                                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12251 |          storage::BindBufferOffsetNV.aliased(addr_of!(storage::BindBufferOffsetEXT));
[INFO] [stdout]       |                                              ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12252:43
[INFO] [stdout]       |
[INFO] [stdout] 12252 |          storage::BindBufferRange.aliased(&storage::BindBufferRangeEXT);
[INFO] [stdout]       |                                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12252 |          storage::BindBufferRange.aliased(addr_of!(storage::BindBufferRangeEXT));
[INFO] [stdout]       |                                           ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12253:43
[INFO] [stdout]       |
[INFO] [stdout] 12253 |          storage::BindBufferRange.aliased(&storage::BindBufferRangeNV);
[INFO] [stdout]       |                                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12253 |          storage::BindBufferRange.aliased(addr_of!(storage::BindBufferRangeNV));
[INFO] [stdout]       |                                           ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12254:46
[INFO] [stdout]       |
[INFO] [stdout] 12254 |          storage::BindBufferRangeEXT.aliased(&storage::BindBufferRange);
[INFO] [stdout]       |                                              ^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12254 |          storage::BindBufferRangeEXT.aliased(addr_of!(storage::BindBufferRange));
[INFO] [stdout]       |                                              ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12255:46
[INFO] [stdout]       |
[INFO] [stdout] 12255 |          storage::BindBufferRangeEXT.aliased(&storage::BindBufferRangeNV);
[INFO] [stdout]       |                                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12255 |          storage::BindBufferRangeEXT.aliased(addr_of!(storage::BindBufferRangeNV));
[INFO] [stdout]       |                                              ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12256:45
[INFO] [stdout]       |
[INFO] [stdout] 12256 |          storage::BindBufferRangeNV.aliased(&storage::BindBufferRange);
[INFO] [stdout]       |                                             ^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12256 |          storage::BindBufferRangeNV.aliased(addr_of!(storage::BindBufferRange));
[INFO] [stdout]       |                                             ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12257:45
[INFO] [stdout]       |
[INFO] [stdout] 12257 |          storage::BindBufferRangeNV.aliased(&storage::BindBufferRangeEXT);
[INFO] [stdout]       |                                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12257 |          storage::BindBufferRangeNV.aliased(addr_of!(storage::BindBufferRangeEXT));
[INFO] [stdout]       |                                             ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12258:48
[INFO] [stdout]       |
[INFO] [stdout] 12258 |          storage::BindFragDataLocation.aliased(&storage::BindFragDataLocationEXT);
[INFO] [stdout]       |                                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12258 |          storage::BindFragDataLocation.aliased(addr_of!(storage::BindFragDataLocationEXT));
[INFO] [stdout]       |                                                ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12259:51
[INFO] [stdout]       |
[INFO] [stdout] 12259 |          storage::BindFragDataLocationEXT.aliased(&storage::BindFragDataLocation);
[INFO] [stdout]       |                                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12259 |          storage::BindFragDataLocationEXT.aliased(addr_of!(storage::BindFragDataLocation));
[INFO] [stdout]       |                                                   ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12260:42
[INFO] [stdout]       |
[INFO] [stdout] 12260 |          storage::BindProgramARB.aliased(&storage::BindProgramNV);
[INFO] [stdout]       |                                          ^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12260 |          storage::BindProgramARB.aliased(addr_of!(storage::BindProgramNV));
[INFO] [stdout]       |                                          ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12261:41
[INFO] [stdout]       |
[INFO] [stdout] 12261 |          storage::BindProgramNV.aliased(&storage::BindProgramARB);
[INFO] [stdout]       |                                         ^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12261 |          storage::BindProgramNV.aliased(addr_of!(storage::BindProgramARB));
[INFO] [stdout]       |                                         ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12262:39
[INFO] [stdout]       |
[INFO] [stdout] 12262 |          storage::BindTexture.aliased(&storage::BindTextureEXT);
[INFO] [stdout]       |                                       ^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12262 |          storage::BindTexture.aliased(addr_of!(storage::BindTextureEXT));
[INFO] [stdout]       |                                       ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12263:42
[INFO] [stdout]       |
[INFO] [stdout] 12263 |          storage::BindTextureEXT.aliased(&storage::BindTexture);
[INFO] [stdout]       |                                          ^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12263 |          storage::BindTextureEXT.aliased(addr_of!(storage::BindTexture));
[INFO] [stdout]       |                                          ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12264:38
[INFO] [stdout]       |
[INFO] [stdout] 12264 |          storage::BlendColor.aliased(&storage::BlendColorEXT);
[INFO] [stdout]       |                                      ^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12264 |          storage::BlendColor.aliased(addr_of!(storage::BlendColorEXT));
[INFO] [stdout]       |                                      ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12265:41
[INFO] [stdout]       |
[INFO] [stdout] 12265 |          storage::BlendColorEXT.aliased(&storage::BlendColor);
[INFO] [stdout]       |                                         ^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12265 |          storage::BlendColorEXT.aliased(addr_of!(storage::BlendColor));
[INFO] [stdout]       |                                         ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12266:41
[INFO] [stdout]       |
[INFO] [stdout] 12266 |          storage::BlendEquation.aliased(&storage::BlendEquationEXT);
[INFO] [stdout]       |                                         ^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12266 |          storage::BlendEquation.aliased(addr_of!(storage::BlendEquationEXT));
[INFO] [stdout]       |                                         ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12267:44
[INFO] [stdout]       |
[INFO] [stdout] 12267 |          storage::BlendEquationEXT.aliased(&storage::BlendEquation);
[INFO] [stdout]       |                                            ^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12267 |          storage::BlendEquationEXT.aliased(addr_of!(storage::BlendEquation));
[INFO] [stdout]       |                                            ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12268:49
[INFO] [stdout]       |
[INFO] [stdout] 12268 |          storage::BlendEquationSeparate.aliased(&storage::BlendEquationSeparateEXT);
[INFO] [stdout]       |                                                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12268 |          storage::BlendEquationSeparate.aliased(addr_of!(storage::BlendEquationSeparateEXT));
[INFO] [stdout]       |                                                 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12269:52
[INFO] [stdout]       |
[INFO] [stdout] 12269 |          storage::BlendEquationSeparateEXT.aliased(&storage::BlendEquationSeparate);
[INFO] [stdout]       |                                                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12269 |          storage::BlendEquationSeparateEXT.aliased(addr_of!(storage::BlendEquationSeparate));
[INFO] [stdout]       |                                                    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12270:45
[INFO] [stdout]       |
[INFO] [stdout] 12270 |          storage::BlendFuncSeparate.aliased(&storage::BlendFuncSeparateEXT);
[INFO] [stdout]       |                                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12270 |          storage::BlendFuncSeparate.aliased(addr_of!(storage::BlendFuncSeparateEXT));
[INFO] [stdout]       |                                             ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12271:45
[INFO] [stdout]       |
[INFO] [stdout] 12271 |          storage::BlendFuncSeparate.aliased(&storage::BlendFuncSeparateINGR);
[INFO] [stdout]       |                                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12271 |          storage::BlendFuncSeparate.aliased(addr_of!(storage::BlendFuncSeparateINGR));
[INFO] [stdout]       |                                             ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12272:48
[INFO] [stdout]       |
[INFO] [stdout] 12272 |          storage::BlendFuncSeparateEXT.aliased(&storage::BlendFuncSeparate);
[INFO] [stdout]       |                                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12272 |          storage::BlendFuncSeparateEXT.aliased(addr_of!(storage::BlendFuncSeparate));
[INFO] [stdout]       |                                                ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12273:48
[INFO] [stdout]       |
[INFO] [stdout] 12273 |          storage::BlendFuncSeparateEXT.aliased(&storage::BlendFuncSeparateINGR);
[INFO] [stdout]       |                                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12273 |          storage::BlendFuncSeparateEXT.aliased(addr_of!(storage::BlendFuncSeparateINGR));
[INFO] [stdout]       |                                                ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12274:49
[INFO] [stdout]       |
[INFO] [stdout] 12274 |          storage::BlendFuncSeparateINGR.aliased(&storage::BlendFuncSeparate);
[INFO] [stdout]       |                                                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12274 |          storage::BlendFuncSeparateINGR.aliased(addr_of!(storage::BlendFuncSeparate));
[INFO] [stdout]       |                                                 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12275:49
[INFO] [stdout]       |
[INFO] [stdout] 12275 |          storage::BlendFuncSeparateINGR.aliased(&storage::BlendFuncSeparateEXT);
[INFO] [stdout]       |                                                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12275 |          storage::BlendFuncSeparateINGR.aliased(addr_of!(storage::BlendFuncSeparateEXT));
[INFO] [stdout]       |                                                 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12276:43
[INFO] [stdout]       |
[INFO] [stdout] 12276 |          storage::BlitFramebuffer.aliased(&storage::BlitFramebufferEXT);
[INFO] [stdout]       |                                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12276 |          storage::BlitFramebuffer.aliased(addr_of!(storage::BlitFramebufferEXT));
[INFO] [stdout]       |                                           ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12277:46
[INFO] [stdout]       |
[INFO] [stdout] 12277 |          storage::BlitFramebufferEXT.aliased(&storage::BlitFramebuffer);
[INFO] [stdout]       |                                              ^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12277 |          storage::BlitFramebufferEXT.aliased(addr_of!(storage::BlitFramebuffer));
[INFO] [stdout]       |                                              ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12278:38
[INFO] [stdout]       |
[INFO] [stdout] 12278 |          storage::BufferData.aliased(&storage::BufferDataARB);
[INFO] [stdout]       |                                      ^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12278 |          storage::BufferData.aliased(addr_of!(storage::BufferDataARB));
[INFO] [stdout]       |                                      ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12279:41
[INFO] [stdout]       |
[INFO] [stdout] 12279 |          storage::BufferDataARB.aliased(&storage::BufferData);
[INFO] [stdout]       |                                         ^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12279 |          storage::BufferDataARB.aliased(addr_of!(storage::BufferData));
[INFO] [stdout]       |                                         ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12280:41
[INFO] [stdout]       |
[INFO] [stdout] 12280 |          storage::BufferSubData.aliased(&storage::BufferSubDataARB);
[INFO] [stdout]       |                                         ^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12280 |          storage::BufferSubData.aliased(addr_of!(storage::BufferSubDataARB));
[INFO] [stdout]       |                                         ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12281:44
[INFO] [stdout]       |
[INFO] [stdout] 12281 |          storage::BufferSubDataARB.aliased(&storage::BufferSubData);
[INFO] [stdout]       |                                            ^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12281 |          storage::BufferSubDataARB.aliased(addr_of!(storage::BufferSubData));
[INFO] [stdout]       |                                            ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12282:50
[INFO] [stdout]       |
[INFO] [stdout] 12282 |          storage::CheckFramebufferStatus.aliased(&storage::CheckFramebufferStatusEXT);
[INFO] [stdout]       |                                                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12282 |          storage::CheckFramebufferStatus.aliased(addr_of!(storage::CheckFramebufferStatusEXT));
[INFO] [stdout]       |                                                  ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12283:53
[INFO] [stdout]       |
[INFO] [stdout] 12283 |          storage::CheckFramebufferStatusEXT.aliased(&storage::CheckFramebufferStatus);
[INFO] [stdout]       |                                                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12283 |          storage::CheckFramebufferStatusEXT.aliased(addr_of!(storage::CheckFramebufferStatus));
[INFO] [stdout]       |                                                     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12284:38
[INFO] [stdout]       |
[INFO] [stdout] 12284 |          storage::ClampColor.aliased(&storage::ClampColorARB);
[INFO] [stdout]       |                                      ^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12284 |          storage::ClampColor.aliased(addr_of!(storage::ClampColorARB));
[INFO] [stdout]       |                                      ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12285:41
[INFO] [stdout]       |
[INFO] [stdout] 12285 |          storage::ClampColorARB.aliased(&storage::ClampColor);
[INFO] [stdout]       |                                         ^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12285 |          storage::ClampColorARB.aliased(addr_of!(storage::ClampColor));
[INFO] [stdout]       |                                         ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12286:39
[INFO] [stdout]       |
[INFO] [stdout] 12286 |          storage::ClearDepthf.aliased(&storage::ClearDepthfOES);
[INFO] [stdout]       |                                       ^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12286 |          storage::ClearDepthf.aliased(addr_of!(storage::ClearDepthfOES));
[INFO] [stdout]       |                                       ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12287:42
[INFO] [stdout]       |
[INFO] [stdout] 12287 |          storage::ClearDepthfOES.aliased(&storage::ClearDepthf);
[INFO] [stdout]       |                                          ^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12287 |          storage::ClearDepthfOES.aliased(addr_of!(storage::ClearDepthf));
[INFO] [stdout]       |                                          ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12288:38
[INFO] [stdout]       |
[INFO] [stdout] 12288 |          storage::ColorMaski.aliased(&storage::ColorMaskIndexedEXT);
[INFO] [stdout]       |                                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12288 |          storage::ColorMaski.aliased(addr_of!(storage::ColorMaskIndexedEXT));
[INFO] [stdout]       |                                      ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12289:47
[INFO] [stdout]       |
[INFO] [stdout] 12289 |          storage::ColorMaskIndexedEXT.aliased(&storage::ColorMaski);
[INFO] [stdout]       |                                               ^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12289 |          storage::ColorMaskIndexedEXT.aliased(addr_of!(storage::ColorMaski));
[INFO] [stdout]       |                                               ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12290:41
[INFO] [stdout]       |
[INFO] [stdout] 12290 |          storage::CompileShader.aliased(&storage::CompileShaderARB);
[INFO] [stdout]       |                                         ^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12290 |          storage::CompileShader.aliased(addr_of!(storage::CompileShaderARB));
[INFO] [stdout]       |                                         ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12291:44
[INFO] [stdout]       |
[INFO] [stdout] 12291 |          storage::CompileShaderARB.aliased(&storage::CompileShader);
[INFO] [stdout]       |                                            ^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12291 |          storage::CompileShaderARB.aliased(addr_of!(storage::CompileShader));
[INFO] [stdout]       |                                            ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12292:48
[INFO] [stdout]       |
[INFO] [stdout] 12292 |          storage::CompressedTexImage1D.aliased(&storage::CompressedTexImage1DARB);
[INFO] [stdout]       |                                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12292 |          storage::CompressedTexImage1D.aliased(addr_of!(storage::CompressedTexImage1DARB));
[INFO] [stdout]       |                                                ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12293:51
[INFO] [stdout]       |
[INFO] [stdout] 12293 |          storage::CompressedTexImage1DARB.aliased(&storage::CompressedTexImage1D);
[INFO] [stdout]       |                                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12293 |          storage::CompressedTexImage1DARB.aliased(addr_of!(storage::CompressedTexImage1D));
[INFO] [stdout]       |                                                   ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12294:48
[INFO] [stdout]       |
[INFO] [stdout] 12294 |          storage::CompressedTexImage2D.aliased(&storage::CompressedTexImage2DARB);
[INFO] [stdout]       |                                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12294 |          storage::CompressedTexImage2D.aliased(addr_of!(storage::CompressedTexImage2DARB));
[INFO] [stdout]       |                                                ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12295:51
[INFO] [stdout]       |
[INFO] [stdout] 12295 |          storage::CompressedTexImage2DARB.aliased(&storage::CompressedTexImage2D);
[INFO] [stdout]       |                                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12295 |          storage::CompressedTexImage2DARB.aliased(addr_of!(storage::CompressedTexImage2D));
[INFO] [stdout]       |                                                   ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12296:48
[INFO] [stdout]       |
[INFO] [stdout] 12296 |          storage::CompressedTexImage3D.aliased(&storage::CompressedTexImage3DARB);
[INFO] [stdout]       |                                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12296 |          storage::CompressedTexImage3D.aliased(addr_of!(storage::CompressedTexImage3DARB));
[INFO] [stdout]       |                                                ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12297:51
[INFO] [stdout]       |
[INFO] [stdout] 12297 |          storage::CompressedTexImage3DARB.aliased(&storage::CompressedTexImage3D);
[INFO] [stdout]       |                                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12297 |          storage::CompressedTexImage3DARB.aliased(addr_of!(storage::CompressedTexImage3D));
[INFO] [stdout]       |                                                   ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12298:51
[INFO] [stdout]       |
[INFO] [stdout] 12298 |          storage::CompressedTexSubImage1D.aliased(&storage::CompressedTexSubImage1DARB);
[INFO] [stdout]       |                                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12298 |          storage::CompressedTexSubImage1D.aliased(addr_of!(storage::CompressedTexSubImage1DARB));
[INFO] [stdout]       |                                                   ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12299:54
[INFO] [stdout]       |
[INFO] [stdout] 12299 |          storage::CompressedTexSubImage1DARB.aliased(&storage::CompressedTexSubImage1D);
[INFO] [stdout]       |                                                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12299 |          storage::CompressedTexSubImage1DARB.aliased(addr_of!(storage::CompressedTexSubImage1D));
[INFO] [stdout]       |                                                      ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12300:51
[INFO] [stdout]       |
[INFO] [stdout] 12300 |          storage::CompressedTexSubImage2D.aliased(&storage::CompressedTexSubImage2DARB);
[INFO] [stdout]       |                                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12300 |          storage::CompressedTexSubImage2D.aliased(addr_of!(storage::CompressedTexSubImage2DARB));
[INFO] [stdout]       |                                                   ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12301:54
[INFO] [stdout]       |
[INFO] [stdout] 12301 |          storage::CompressedTexSubImage2DARB.aliased(&storage::CompressedTexSubImage2D);
[INFO] [stdout]       |                                                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12301 |          storage::CompressedTexSubImage2DARB.aliased(addr_of!(storage::CompressedTexSubImage2D));
[INFO] [stdout]       |                                                      ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12302:51
[INFO] [stdout]       |
[INFO] [stdout] 12302 |          storage::CompressedTexSubImage3D.aliased(&storage::CompressedTexSubImage3DARB);
[INFO] [stdout]       |                                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12302 |          storage::CompressedTexSubImage3D.aliased(addr_of!(storage::CompressedTexSubImage3DARB));
[INFO] [stdout]       |                                                   ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12303:54
[INFO] [stdout]       |
[INFO] [stdout] 12303 |          storage::CompressedTexSubImage3DARB.aliased(&storage::CompressedTexSubImage3D);
[INFO] [stdout]       |                                                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12303 |          storage::CompressedTexSubImage3DARB.aliased(addr_of!(storage::CompressedTexSubImage3D));
[INFO] [stdout]       |                                                      ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12304:42
[INFO] [stdout]       |
[INFO] [stdout] 12304 |          storage::CopyTexImage1D.aliased(&storage::CopyTexImage1DEXT);
[INFO] [stdout]       |                                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12304 |          storage::CopyTexImage1D.aliased(addr_of!(storage::CopyTexImage1DEXT));
[INFO] [stdout]       |                                          ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12305:45
[INFO] [stdout]       |
[INFO] [stdout] 12305 |          storage::CopyTexImage1DEXT.aliased(&storage::CopyTexImage1D);
[INFO] [stdout]       |                                             ^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12305 |          storage::CopyTexImage1DEXT.aliased(addr_of!(storage::CopyTexImage1D));
[INFO] [stdout]       |                                             ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12306:42
[INFO] [stdout]       |
[INFO] [stdout] 12306 |          storage::CopyTexImage2D.aliased(&storage::CopyTexImage2DEXT);
[INFO] [stdout]       |                                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12306 |          storage::CopyTexImage2D.aliased(addr_of!(storage::CopyTexImage2DEXT));
[INFO] [stdout]       |                                          ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12307:45
[INFO] [stdout]       |
[INFO] [stdout] 12307 |          storage::CopyTexImage2DEXT.aliased(&storage::CopyTexImage2D);
[INFO] [stdout]       |                                             ^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12307 |          storage::CopyTexImage2DEXT.aliased(addr_of!(storage::CopyTexImage2D));
[INFO] [stdout]       |                                             ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12308:45
[INFO] [stdout]       |
[INFO] [stdout] 12308 |          storage::CopyTexSubImage1D.aliased(&storage::CopyTexSubImage1DEXT);
[INFO] [stdout]       |                                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12308 |          storage::CopyTexSubImage1D.aliased(addr_of!(storage::CopyTexSubImage1DEXT));
[INFO] [stdout]       |                                             ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12309:48
[INFO] [stdout]       |
[INFO] [stdout] 12309 |          storage::CopyTexSubImage1DEXT.aliased(&storage::CopyTexSubImage1D);
[INFO] [stdout]       |                                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12309 |          storage::CopyTexSubImage1DEXT.aliased(addr_of!(storage::CopyTexSubImage1D));
[INFO] [stdout]       |                                                ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12310:45
[INFO] [stdout]       |
[INFO] [stdout] 12310 |          storage::CopyTexSubImage2D.aliased(&storage::CopyTexSubImage2DEXT);
[INFO] [stdout]       |                                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12310 |          storage::CopyTexSubImage2D.aliased(addr_of!(storage::CopyTexSubImage2DEXT));
[INFO] [stdout]       |                                             ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12311:48
[INFO] [stdout]       |
[INFO] [stdout] 12311 |          storage::CopyTexSubImage2DEXT.aliased(&storage::CopyTexSubImage2D);
[INFO] [stdout]       |                                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12311 |          storage::CopyTexSubImage2DEXT.aliased(addr_of!(storage::CopyTexSubImage2D));
[INFO] [stdout]       |                                                ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12312:45
[INFO] [stdout]       |
[INFO] [stdout] 12312 |          storage::CopyTexSubImage3D.aliased(&storage::CopyTexSubImage3DEXT);
[INFO] [stdout]       |                                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12312 |          storage::CopyTexSubImage3D.aliased(addr_of!(storage::CopyTexSubImage3DEXT));
[INFO] [stdout]       |                                             ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12313:48
[INFO] [stdout]       |
[INFO] [stdout] 12313 |          storage::CopyTexSubImage3DEXT.aliased(&storage::CopyTexSubImage3D);
[INFO] [stdout]       |                                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12313 |          storage::CopyTexSubImage3DEXT.aliased(addr_of!(storage::CopyTexSubImage3D));
[INFO] [stdout]       |                                                ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12314:41
[INFO] [stdout]       |
[INFO] [stdout] 12314 |          storage::CreateProgram.aliased(&storage::CreateProgramObjectARB);
[INFO] [stdout]       |                                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12314 |          storage::CreateProgram.aliased(addr_of!(storage::CreateProgramObjectARB));
[INFO] [stdout]       |                                         ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12315:50
[INFO] [stdout]       |
[INFO] [stdout] 12315 |          storage::CreateProgramObjectARB.aliased(&storage::CreateProgram);
[INFO] [stdout]       |                                                  ^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12315 |          storage::CreateProgramObjectARB.aliased(addr_of!(storage::CreateProgram));
[INFO] [stdout]       |                                                  ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12316:40
[INFO] [stdout]       |
[INFO] [stdout] 12316 |          storage::CreateShader.aliased(&storage::CreateShaderObjectARB);
[INFO] [stdout]       |                                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12316 |          storage::CreateShader.aliased(addr_of!(storage::CreateShaderObjectARB));
[INFO] [stdout]       |                                        ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12317:49
[INFO] [stdout]       |
[INFO] [stdout] 12317 |          storage::CreateShaderObjectARB.aliased(&storage::CreateShader);
[INFO] [stdout]       |                                                 ^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12317 |          storage::CreateShaderObjectARB.aliased(addr_of!(storage::CreateShader));
[INFO] [stdout]       |                                                 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12318:48
[INFO] [stdout]       |
[INFO] [stdout] 12318 |          storage::DebugMessageCallback.aliased(&storage::DebugMessageCallbackARB);
[INFO] [stdout]       |                                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12318 |          storage::DebugMessageCallback.aliased(addr_of!(storage::DebugMessageCallbackARB));
[INFO] [stdout]       |                                                ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12319:51
[INFO] [stdout]       |
[INFO] [stdout] 12319 |          storage::DebugMessageCallbackARB.aliased(&storage::DebugMessageCallback);
[INFO] [stdout]       |                                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12319 |          storage::DebugMessageCallbackARB.aliased(addr_of!(storage::DebugMessageCallback));
[INFO] [stdout]       |                                                   ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12320:47
[INFO] [stdout]       |
[INFO] [stdout] 12320 |          storage::DebugMessageControl.aliased(&storage::DebugMessageControlARB);
[INFO] [stdout]       |                                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12320 |          storage::DebugMessageControl.aliased(addr_of!(storage::DebugMessageControlARB));
[INFO] [stdout]       |                                               ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12321:50
[INFO] [stdout]       |
[INFO] [stdout] 12321 |          storage::DebugMessageControlARB.aliased(&storage::DebugMessageControl);
[INFO] [stdout]       |                                                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12321 |          storage::DebugMessageControlARB.aliased(addr_of!(storage::DebugMessageControl));
[INFO] [stdout]       |                                                  ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12322:46
[INFO] [stdout]       |
[INFO] [stdout] 12322 |          storage::DebugMessageInsert.aliased(&storage::DebugMessageInsertARB);
[INFO] [stdout]       |                                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12322 |          storage::DebugMessageInsert.aliased(addr_of!(storage::DebugMessageInsertARB));
[INFO] [stdout]       |                                              ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12323:49
[INFO] [stdout]       |
[INFO] [stdout] 12323 |          storage::DebugMessageInsertARB.aliased(&storage::DebugMessageInsert);
[INFO] [stdout]       |                                                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12323 |          storage::DebugMessageInsertARB.aliased(addr_of!(storage::DebugMessageInsert));
[INFO] [stdout]       |                                                 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12324:41
[INFO] [stdout]       |
[INFO] [stdout] 12324 |          storage::DeleteBuffers.aliased(&storage::DeleteBuffersARB);
[INFO] [stdout]       |                                         ^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12324 |          storage::DeleteBuffers.aliased(addr_of!(storage::DeleteBuffersARB));
[INFO] [stdout]       |                                         ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12325:44
[INFO] [stdout]       |
[INFO] [stdout] 12325 |          storage::DeleteBuffersARB.aliased(&storage::DeleteBuffers);
[INFO] [stdout]       |                                            ^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12325 |          storage::DeleteBuffersARB.aliased(addr_of!(storage::DeleteBuffers));
[INFO] [stdout]       |                                            ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12326:46
[INFO] [stdout]       |
[INFO] [stdout] 12326 |          storage::DeleteFramebuffers.aliased(&storage::DeleteFramebuffersEXT);
[INFO] [stdout]       |                                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12326 |          storage::DeleteFramebuffers.aliased(addr_of!(storage::DeleteFramebuffersEXT));
[INFO] [stdout]       |                                              ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12327:49
[INFO] [stdout]       |
[INFO] [stdout] 12327 |          storage::DeleteFramebuffersEXT.aliased(&storage::DeleteFramebuffers);
[INFO] [stdout]       |                                                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12327 |          storage::DeleteFramebuffersEXT.aliased(addr_of!(storage::DeleteFramebuffers));
[INFO] [stdout]       |                                                 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12328:45
[INFO] [stdout]       |
[INFO] [stdout] 12328 |          storage::DeleteProgramsARB.aliased(&storage::DeleteProgramsNV);
[INFO] [stdout]       |                                             ^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12328 |          storage::DeleteProgramsARB.aliased(addr_of!(storage::DeleteProgramsNV));
[INFO] [stdout]       |                                             ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12329:44
[INFO] [stdout]       |
[INFO] [stdout] 12329 |          storage::DeleteProgramsNV.aliased(&storage::DeleteProgramsARB);
[INFO] [stdout]       |                                            ^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12329 |          storage::DeleteProgramsNV.aliased(addr_of!(storage::DeleteProgramsARB));
[INFO] [stdout]       |                                            ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12330:41
[INFO] [stdout]       |
[INFO] [stdout] 12330 |          storage::DeleteQueries.aliased(&storage::DeleteQueriesARB);
[INFO] [stdout]       |                                         ^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12330 |          storage::DeleteQueries.aliased(addr_of!(storage::DeleteQueriesARB));
[INFO] [stdout]       |                                         ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12331:44
[INFO] [stdout]       |
[INFO] [stdout] 12331 |          storage::DeleteQueriesARB.aliased(&storage::DeleteQueries);
[INFO] [stdout]       |                                            ^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12331 |          storage::DeleteQueriesARB.aliased(addr_of!(storage::DeleteQueries));
[INFO] [stdout]       |                                            ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12332:47
[INFO] [stdout]       |
[INFO] [stdout] 12332 |          storage::DeleteRenderbuffers.aliased(&storage::DeleteRenderbuffersEXT);
[INFO] [stdout]       |                                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12332 |          storage::DeleteRenderbuffers.aliased(addr_of!(storage::DeleteRenderbuffersEXT));
[INFO] [stdout]       |                                               ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12333:50
[INFO] [stdout]       |
[INFO] [stdout] 12333 |          storage::DeleteRenderbuffersEXT.aliased(&storage::DeleteRenderbuffers);
[INFO] [stdout]       |                                                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12333 |          storage::DeleteRenderbuffersEXT.aliased(addr_of!(storage::DeleteRenderbuffers));
[INFO] [stdout]       |                                                  ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12334:52
[INFO] [stdout]       |
[INFO] [stdout] 12334 |          storage::DeleteTransformFeedbacks.aliased(&storage::DeleteTransformFeedbacksNV);
[INFO] [stdout]       |                                                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12334 |          storage::DeleteTransformFeedbacks.aliased(addr_of!(storage::DeleteTransformFeedbacksNV));
[INFO] [stdout]       |                                                    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12335:54
[INFO] [stdout]       |
[INFO] [stdout] 12335 |          storage::DeleteTransformFeedbacksNV.aliased(&storage::DeleteTransformFeedbacks);
[INFO] [stdout]       |                                                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12335 |          storage::DeleteTransformFeedbacksNV.aliased(addr_of!(storage::DeleteTransformFeedbacks));
[INFO] [stdout]       |                                                      ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12336:46
[INFO] [stdout]       |
[INFO] [stdout] 12336 |          storage::DeleteVertexArrays.aliased(&storage::DeleteVertexArraysAPPLE);
[INFO] [stdout]       |                                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12336 |          storage::DeleteVertexArrays.aliased(addr_of!(storage::DeleteVertexArraysAPPLE));
[INFO] [stdout]       |                                              ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12337:51
[INFO] [stdout]       |
[INFO] [stdout] 12337 |          storage::DeleteVertexArraysAPPLE.aliased(&storage::DeleteVertexArrays);
[INFO] [stdout]       |                                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12337 |          storage::DeleteVertexArraysAPPLE.aliased(addr_of!(storage::DeleteVertexArrays));
[INFO] [stdout]       |                                                   ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12338:39
[INFO] [stdout]       |
[INFO] [stdout] 12338 |          storage::DepthRangef.aliased(&storage::DepthRangefOES);
[INFO] [stdout]       |                                       ^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12338 |          storage::DepthRangef.aliased(addr_of!(storage::DepthRangefOES));
[INFO] [stdout]       |                                       ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12339:42
[INFO] [stdout]       |
[INFO] [stdout] 12339 |          storage::DepthRangefOES.aliased(&storage::DepthRangef);
[INFO] [stdout]       |                                          ^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12339 |          storage::DepthRangefOES.aliased(addr_of!(storage::DepthRangef));
[INFO] [stdout]       |                                          ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12340:43
[INFO] [stdout]       |
[INFO] [stdout] 12340 |          storage::DetachObjectARB.aliased(&storage::DetachShader);
[INFO] [stdout]       |                                           ^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12340 |          storage::DetachObjectARB.aliased(addr_of!(storage::DetachShader));
[INFO] [stdout]       |                                           ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12341:40
[INFO] [stdout]       |
[INFO] [stdout] 12341 |          storage::DetachShader.aliased(&storage::DetachObjectARB);
[INFO] [stdout]       |                                        ^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12341 |          storage::DetachShader.aliased(addr_of!(storage::DetachObjectARB));
[INFO] [stdout]       |                                        ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12342:36
[INFO] [stdout]       |
[INFO] [stdout] 12342 |          storage::Disablei.aliased(&storage::DisableIndexedEXT);
[INFO] [stdout]       |                                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12342 |          storage::Disablei.aliased(addr_of!(storage::DisableIndexedEXT));
[INFO] [stdout]       |                                    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12343:45
[INFO] [stdout]       |
[INFO] [stdout] 12343 |          storage::DisableIndexedEXT.aliased(&storage::Disablei);
[INFO] [stdout]       |                                             ^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12343 |          storage::DisableIndexedEXT.aliased(addr_of!(storage::Disablei));
[INFO] [stdout]       |                                             ~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12344:52
[INFO] [stdout]       |
[INFO] [stdout] 12344 |          storage::DisableVertexAttribArray.aliased(&storage::DisableVertexAttribArrayARB);
[INFO] [stdout]       |                                                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12344 |          storage::DisableVertexAttribArray.aliased(addr_of!(storage::DisableVertexAttribArrayARB));
[INFO] [stdout]       |                                                    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12345:55
[INFO] [stdout]       |
[INFO] [stdout] 12345 |          storage::DisableVertexAttribArrayARB.aliased(&storage::DisableVertexAttribArray);
[INFO] [stdout]       |                                                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12345 |          storage::DisableVertexAttribArrayARB.aliased(addr_of!(storage::DisableVertexAttribArray));
[INFO] [stdout]       |                                                       ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12346:38
[INFO] [stdout]       |
[INFO] [stdout] 12346 |          storage::DrawArrays.aliased(&storage::DrawArraysEXT);
[INFO] [stdout]       |                                      ^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12346 |          storage::DrawArrays.aliased(addr_of!(storage::DrawArraysEXT));
[INFO] [stdout]       |                                      ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12347:41
[INFO] [stdout]       |
[INFO] [stdout] 12347 |          storage::DrawArraysEXT.aliased(&storage::DrawArrays);
[INFO] [stdout]       |                                         ^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12347 |          storage::DrawArraysEXT.aliased(addr_of!(storage::DrawArrays));
[INFO] [stdout]       |                                         ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12348:47
[INFO] [stdout]       |
[INFO] [stdout] 12348 |          storage::DrawArraysInstanced.aliased(&storage::DrawArraysInstancedARB);
[INFO] [stdout]       |                                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12348 |          storage::DrawArraysInstanced.aliased(addr_of!(storage::DrawArraysInstancedARB));
[INFO] [stdout]       |                                               ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12349:47
[INFO] [stdout]       |
[INFO] [stdout] 12349 |          storage::DrawArraysInstanced.aliased(&storage::DrawArraysInstancedEXT);
[INFO] [stdout]       |                                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12349 |          storage::DrawArraysInstanced.aliased(addr_of!(storage::DrawArraysInstancedEXT));
[INFO] [stdout]       |                                               ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12350:50
[INFO] [stdout]       |
[INFO] [stdout] 12350 |          storage::DrawArraysInstancedARB.aliased(&storage::DrawArraysInstanced);
[INFO] [stdout]       |                                                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12350 |          storage::DrawArraysInstancedARB.aliased(addr_of!(storage::DrawArraysInstanced));
[INFO] [stdout]       |                                                  ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12351:50
[INFO] [stdout]       |
[INFO] [stdout] 12351 |          storage::DrawArraysInstancedARB.aliased(&storage::DrawArraysInstancedEXT);
[INFO] [stdout]       |                                                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12351 |          storage::DrawArraysInstancedARB.aliased(addr_of!(storage::DrawArraysInstancedEXT));
[INFO] [stdout]       |                                                  ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12352:50
[INFO] [stdout]       |
[INFO] [stdout] 12352 |          storage::DrawArraysInstancedEXT.aliased(&storage::DrawArraysInstanced);
[INFO] [stdout]       |                                                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12352 |          storage::DrawArraysInstancedEXT.aliased(addr_of!(storage::DrawArraysInstanced));
[INFO] [stdout]       |                                                  ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12353:50
[INFO] [stdout]       |
[INFO] [stdout] 12353 |          storage::DrawArraysInstancedEXT.aliased(&storage::DrawArraysInstancedARB);
[INFO] [stdout]       |                                                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12353 |          storage::DrawArraysInstancedEXT.aliased(addr_of!(storage::DrawArraysInstancedARB));
[INFO] [stdout]       |                                                  ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12354:39
[INFO] [stdout]       |
[INFO] [stdout] 12354 |          storage::DrawBuffers.aliased(&storage::DrawBuffersARB);
[INFO] [stdout]       |                                       ^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12354 |          storage::DrawBuffers.aliased(addr_of!(storage::DrawBuffersARB));
[INFO] [stdout]       |                                       ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12355:39
[INFO] [stdout]       |
[INFO] [stdout] 12355 |          storage::DrawBuffers.aliased(&storage::DrawBuffersATI);
[INFO] [stdout]       |                                       ^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12355 |          storage::DrawBuffers.aliased(addr_of!(storage::DrawBuffersATI));
[INFO] [stdout]       |                                       ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12356:42
[INFO] [stdout]       |
[INFO] [stdout] 12356 |          storage::DrawBuffersARB.aliased(&storage::DrawBuffers);
[INFO] [stdout]       |                                          ^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12356 |          storage::DrawBuffersARB.aliased(addr_of!(storage::DrawBuffers));
[INFO] [stdout]       |                                          ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12357:42
[INFO] [stdout]       |
[INFO] [stdout] 12357 |          storage::DrawBuffersARB.aliased(&storage::DrawBuffersATI);
[INFO] [stdout]       |                                          ^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12357 |          storage::DrawBuffersARB.aliased(addr_of!(storage::DrawBuffersATI));
[INFO] [stdout]       |                                          ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12358:42
[INFO] [stdout]       |
[INFO] [stdout] 12358 |          storage::DrawBuffersATI.aliased(&storage::DrawBuffers);
[INFO] [stdout]       |                                          ^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12358 |          storage::DrawBuffersATI.aliased(addr_of!(storage::DrawBuffers));
[INFO] [stdout]       |                                          ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12359:42
[INFO] [stdout]       |
[INFO] [stdout] 12359 |          storage::DrawBuffersATI.aliased(&storage::DrawBuffersARB);
[INFO] [stdout]       |                                          ^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12359 |          storage::DrawBuffersATI.aliased(addr_of!(storage::DrawBuffersARB));
[INFO] [stdout]       |                                          ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12360:49
[INFO] [stdout]       |
[INFO] [stdout] 12360 |          storage::DrawElementsInstanced.aliased(&storage::DrawElementsInstancedARB);
[INFO] [stdout]       |                                                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12360 |          storage::DrawElementsInstanced.aliased(addr_of!(storage::DrawElementsInstancedARB));
[INFO] [stdout]       |                                                 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12361:49
[INFO] [stdout]       |
[INFO] [stdout] 12361 |          storage::DrawElementsInstanced.aliased(&storage::DrawElementsInstancedEXT);
[INFO] [stdout]       |                                                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12361 |          storage::DrawElementsInstanced.aliased(addr_of!(storage::DrawElementsInstancedEXT));
[INFO] [stdout]       |                                                 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12362:52
[INFO] [stdout]       |
[INFO] [stdout] 12362 |          storage::DrawElementsInstancedARB.aliased(&storage::DrawElementsInstanced);
[INFO] [stdout]       |                                                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12362 |          storage::DrawElementsInstancedARB.aliased(addr_of!(storage::DrawElementsInstanced));
[INFO] [stdout]       |                                                    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12363:52
[INFO] [stdout]       |
[INFO] [stdout] 12363 |          storage::DrawElementsInstancedARB.aliased(&storage::DrawElementsInstancedEXT);
[INFO] [stdout]       |                                                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12363 |          storage::DrawElementsInstancedARB.aliased(addr_of!(storage::DrawElementsInstancedEXT));
[INFO] [stdout]       |                                                    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12364:52
[INFO] [stdout]       |
[INFO] [stdout] 12364 |          storage::DrawElementsInstancedEXT.aliased(&storage::DrawElementsInstanced);
[INFO] [stdout]       |                                                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12364 |          storage::DrawElementsInstancedEXT.aliased(addr_of!(storage::DrawElementsInstanced));
[INFO] [stdout]       |                                                    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12365:52
[INFO] [stdout]       |
[INFO] [stdout] 12365 |          storage::DrawElementsInstancedEXT.aliased(&storage::DrawElementsInstancedARB);
[INFO] [stdout]       |                                                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12365 |          storage::DrawElementsInstancedEXT.aliased(addr_of!(storage::DrawElementsInstancedARB));
[INFO] [stdout]       |                                                    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12366:45
[INFO] [stdout]       |
[INFO] [stdout] 12366 |          storage::DrawRangeElements.aliased(&storage::DrawRangeElementsEXT);
[INFO] [stdout]       |                                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12366 |          storage::DrawRangeElements.aliased(addr_of!(storage::DrawRangeElementsEXT));
[INFO] [stdout]       |                                             ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12367:48
[INFO] [stdout]       |
[INFO] [stdout] 12367 |          storage::DrawRangeElementsEXT.aliased(&storage::DrawRangeElements);
[INFO] [stdout]       |                                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12367 |          storage::DrawRangeElementsEXT.aliased(addr_of!(storage::DrawRangeElements));
[INFO] [stdout]       |                                                ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12368:49
[INFO] [stdout]       |
[INFO] [stdout] 12368 |          storage::DrawTransformFeedback.aliased(&storage::DrawTransformFeedbackNV);
[INFO] [stdout]       |                                                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12368 |          storage::DrawTransformFeedback.aliased(addr_of!(storage::DrawTransformFeedbackNV));
[INFO] [stdout]       |                                                 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12369:51
[INFO] [stdout]       |
[INFO] [stdout] 12369 |          storage::DrawTransformFeedbackNV.aliased(&storage::DrawTransformFeedback);
[INFO] [stdout]       |                                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12369 |          storage::DrawTransformFeedbackNV.aliased(addr_of!(storage::DrawTransformFeedback));
[INFO] [stdout]       |                                                   ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12370:35
[INFO] [stdout]       |
[INFO] [stdout] 12370 |          storage::Enablei.aliased(&storage::EnableIndexedEXT);
[INFO] [stdout]       |                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12370 |          storage::Enablei.aliased(addr_of!(storage::EnableIndexedEXT));
[INFO] [stdout]       |                                   ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12371:44
[INFO] [stdout]       |
[INFO] [stdout] 12371 |          storage::EnableIndexedEXT.aliased(&storage::Enablei);
[INFO] [stdout]       |                                            ^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12371 |          storage::EnableIndexedEXT.aliased(addr_of!(storage::Enablei));
[INFO] [stdout]       |                                            ~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12372:51
[INFO] [stdout]       |
[INFO] [stdout] 12372 |          storage::EnableVertexAttribArray.aliased(&storage::EnableVertexAttribArrayARB);
[INFO] [stdout]       |                                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12372 |          storage::EnableVertexAttribArray.aliased(addr_of!(storage::EnableVertexAttribArrayARB));
[INFO] [stdout]       |                                                   ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12373:54
[INFO] [stdout]       |
[INFO] [stdout] 12373 |          storage::EnableVertexAttribArrayARB.aliased(&storage::EnableVertexAttribArray);
[INFO] [stdout]       |                                                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12373 |          storage::EnableVertexAttribArrayARB.aliased(addr_of!(storage::EnableVertexAttribArray));
[INFO] [stdout]       |                                                      ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12374:48
[INFO] [stdout]       |
[INFO] [stdout] 12374 |          storage::EndConditionalRender.aliased(&storage::EndConditionalRenderNV);
[INFO] [stdout]       |                                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12374 |          storage::EndConditionalRender.aliased(addr_of!(storage::EndConditionalRenderNV));
[INFO] [stdout]       |                                                ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12375:48
[INFO] [stdout]       |
[INFO] [stdout] 12375 |          storage::EndConditionalRender.aliased(&storage::EndConditionalRenderNVX);
[INFO] [stdout]       |                                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12375 |          storage::EndConditionalRender.aliased(addr_of!(storage::EndConditionalRenderNVX));
[INFO] [stdout]       |                                                ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12376:50
[INFO] [stdout]       |
[INFO] [stdout] 12376 |          storage::EndConditionalRenderNV.aliased(&storage::EndConditionalRender);
[INFO] [stdout]       |                                                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12376 |          storage::EndConditionalRenderNV.aliased(addr_of!(storage::EndConditionalRender));
[INFO] [stdout]       |                                                  ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12377:50
[INFO] [stdout]       |
[INFO] [stdout] 12377 |          storage::EndConditionalRenderNV.aliased(&storage::EndConditionalRenderNVX);
[INFO] [stdout]       |                                                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12377 |          storage::EndConditionalRenderNV.aliased(addr_of!(storage::EndConditionalRenderNVX));
[INFO] [stdout]       |                                                  ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12378:51
[INFO] [stdout]       |
[INFO] [stdout] 12378 |          storage::EndConditionalRenderNVX.aliased(&storage::EndConditionalRender);
[INFO] [stdout]       |                                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12378 |          storage::EndConditionalRenderNVX.aliased(addr_of!(storage::EndConditionalRender));
[INFO] [stdout]       |                                                   ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12379:51
[INFO] [stdout]       |
[INFO] [stdout] 12379 |          storage::EndConditionalRenderNVX.aliased(&storage::EndConditionalRenderNV);
[INFO] [stdout]       |                                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12379 |          storage::EndConditionalRenderNVX.aliased(addr_of!(storage::EndConditionalRenderNV));
[INFO] [stdout]       |                                                   ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12380:36
[INFO] [stdout]       |
[INFO] [stdout] 12380 |          storage::EndQuery.aliased(&storage::EndQueryARB);
[INFO] [stdout]       |                                    ^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12380 |          storage::EndQuery.aliased(addr_of!(storage::EndQueryARB));
[INFO] [stdout]       |                                    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12381:39
[INFO] [stdout]       |
[INFO] [stdout] 12381 |          storage::EndQueryARB.aliased(&storage::EndQuery);
[INFO] [stdout]       |                                       ^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12381 |          storage::EndQueryARB.aliased(addr_of!(storage::EndQuery));
[INFO] [stdout]       |                                       ~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12382:48
[INFO] [stdout]       |
[INFO] [stdout] 12382 |          storage::EndTransformFeedback.aliased(&storage::EndTransformFeedbackEXT);
[INFO] [stdout]       |                                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12382 |          storage::EndTransformFeedback.aliased(addr_of!(storage::EndTransformFeedbackEXT));
[INFO] [stdout]       |                                                ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12383:48
[INFO] [stdout]       |
[INFO] [stdout] 12383 |          storage::EndTransformFeedback.aliased(&storage::EndTransformFeedbackNV);
[INFO] [stdout]       |                                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12383 |          storage::EndTransformFeedback.aliased(addr_of!(storage::EndTransformFeedbackNV));
[INFO] [stdout]       |                                                ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12384:51
[INFO] [stdout]       |
[INFO] [stdout] 12384 |          storage::EndTransformFeedbackEXT.aliased(&storage::EndTransformFeedback);
[INFO] [stdout]       |                                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12384 |          storage::EndTransformFeedbackEXT.aliased(addr_of!(storage::EndTransformFeedback));
[INFO] [stdout]       |                                                   ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12385:51
[INFO] [stdout]       |
[INFO] [stdout] 12385 |          storage::EndTransformFeedbackEXT.aliased(&storage::EndTransformFeedbackNV);
[INFO] [stdout]       |                                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12385 |          storage::EndTransformFeedbackEXT.aliased(addr_of!(storage::EndTransformFeedbackNV));
[INFO] [stdout]       |                                                   ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12386:50
[INFO] [stdout]       |
[INFO] [stdout] 12386 |          storage::EndTransformFeedbackNV.aliased(&storage::EndTransformFeedback);
[INFO] [stdout]       |                                                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12386 |          storage::EndTransformFeedbackNV.aliased(addr_of!(storage::EndTransformFeedback));
[INFO] [stdout]       |                                                  ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12387:50
[INFO] [stdout]       |
[INFO] [stdout] 12387 |          storage::EndTransformFeedbackNV.aliased(&storage::EndTransformFeedbackEXT);
[INFO] [stdout]       |                                                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12387 |          storage::EndTransformFeedbackNV.aliased(addr_of!(storage::EndTransformFeedbackEXT));
[INFO] [stdout]       |                                                  ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12388:50
[INFO] [stdout]       |
[INFO] [stdout] 12388 |          storage::FlushMappedBufferRange.aliased(&storage::FlushMappedBufferRangeAPPLE);
[INFO] [stdout]       |                                                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12388 |          storage::FlushMappedBufferRange.aliased(addr_of!(storage::FlushMappedBufferRangeAPPLE));
[INFO] [stdout]       |                                                  ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12389:55
[INFO] [stdout]       |
[INFO] [stdout] 12389 |          storage::FlushMappedBufferRangeAPPLE.aliased(&storage::FlushMappedBufferRange);
[INFO] [stdout]       |                                                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12389 |          storage::FlushMappedBufferRangeAPPLE.aliased(addr_of!(storage::FlushMappedBufferRange));
[INFO] [stdout]       |                                                       ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12390:51
[INFO] [stdout]       |
[INFO] [stdout] 12390 |          storage::FramebufferRenderbuffer.aliased(&storage::FramebufferRenderbufferEXT);
[INFO] [stdout]       |                                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12390 |          storage::FramebufferRenderbuffer.aliased(addr_of!(storage::FramebufferRenderbufferEXT));
[INFO] [stdout]       |                                                   ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12391:54
[INFO] [stdout]       |
[INFO] [stdout] 12391 |          storage::FramebufferRenderbufferEXT.aliased(&storage::FramebufferRenderbuffer);
[INFO] [stdout]       |                                                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12391 |          storage::FramebufferRenderbufferEXT.aliased(addr_of!(storage::FramebufferRenderbuffer));
[INFO] [stdout]       |                                                      ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12392:46
[INFO] [stdout]       |
[INFO] [stdout] 12392 |          storage::FramebufferTexture.aliased(&storage::FramebufferTextureARB);
[INFO] [stdout]       |                                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12392 |          storage::FramebufferTexture.aliased(addr_of!(storage::FramebufferTextureARB));
[INFO] [stdout]       |                                              ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12393:46
[INFO] [stdout]       |
[INFO] [stdout] 12393 |          storage::FramebufferTexture.aliased(&storage::FramebufferTextureEXT);
[INFO] [stdout]       |                                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12393 |          storage::FramebufferTexture.aliased(addr_of!(storage::FramebufferTextureEXT));
[INFO] [stdout]       |                                              ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12394:48
[INFO] [stdout]       |
[INFO] [stdout] 12394 |          storage::FramebufferTexture1D.aliased(&storage::FramebufferTexture1DEXT);
[INFO] [stdout]       |                                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12394 |          storage::FramebufferTexture1D.aliased(addr_of!(storage::FramebufferTexture1DEXT));
[INFO] [stdout]       |                                                ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12395:51
[INFO] [stdout]       |
[INFO] [stdout] 12395 |          storage::FramebufferTexture1DEXT.aliased(&storage::FramebufferTexture1D);
[INFO] [stdout]       |                                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12395 |          storage::FramebufferTexture1DEXT.aliased(addr_of!(storage::FramebufferTexture1D));
[INFO] [stdout]       |                                                   ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12396:48
[INFO] [stdout]       |
[INFO] [stdout] 12396 |          storage::FramebufferTexture2D.aliased(&storage::FramebufferTexture2DEXT);
[INFO] [stdout]       |                                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12396 |          storage::FramebufferTexture2D.aliased(addr_of!(storage::FramebufferTexture2DEXT));
[INFO] [stdout]       |                                                ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12397:51
[INFO] [stdout]       |
[INFO] [stdout] 12397 |          storage::FramebufferTexture2DEXT.aliased(&storage::FramebufferTexture2D);
[INFO] [stdout]       |                                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12397 |          storage::FramebufferTexture2DEXT.aliased(addr_of!(storage::FramebufferTexture2D));
[INFO] [stdout]       |                                                   ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12398:48
[INFO] [stdout]       |
[INFO] [stdout] 12398 |          storage::FramebufferTexture3D.aliased(&storage::FramebufferTexture3DEXT);
[INFO] [stdout]       |                                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12398 |          storage::FramebufferTexture3D.aliased(addr_of!(storage::FramebufferTexture3DEXT));
[INFO] [stdout]       |                                                ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12399:51
[INFO] [stdout]       |
[INFO] [stdout] 12399 |          storage::FramebufferTexture3DEXT.aliased(&storage::FramebufferTexture3D);
[INFO] [stdout]       |                                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12399 |          storage::FramebufferTexture3DEXT.aliased(addr_of!(storage::FramebufferTexture3D));
[INFO] [stdout]       |                                                   ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12400:49
[INFO] [stdout]       |
[INFO] [stdout] 12400 |          storage::FramebufferTextureARB.aliased(&storage::FramebufferTexture);
[INFO] [stdout]       |                                                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12400 |          storage::FramebufferTextureARB.aliased(addr_of!(storage::FramebufferTexture));
[INFO] [stdout]       |                                                 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12401:49
[INFO] [stdout]       |
[INFO] [stdout] 12401 |          storage::FramebufferTextureARB.aliased(&storage::FramebufferTextureEXT);
[INFO] [stdout]       |                                                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12401 |          storage::FramebufferTextureARB.aliased(addr_of!(storage::FramebufferTextureEXT));
[INFO] [stdout]       |                                                 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12402:49
[INFO] [stdout]       |
[INFO] [stdout] 12402 |          storage::FramebufferTextureEXT.aliased(&storage::FramebufferTexture);
[INFO] [stdout]       |                                                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12402 |          storage::FramebufferTextureEXT.aliased(addr_of!(storage::FramebufferTexture));
[INFO] [stdout]       |                                                 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12403:49
[INFO] [stdout]       |
[INFO] [stdout] 12403 |          storage::FramebufferTextureEXT.aliased(&storage::FramebufferTextureARB);
[INFO] [stdout]       |                                                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12403 |          storage::FramebufferTextureEXT.aliased(addr_of!(storage::FramebufferTextureARB));
[INFO] [stdout]       |                                                 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12404:53
[INFO] [stdout]       |
[INFO] [stdout] 12404 |          storage::FramebufferTextureFaceARB.aliased(&storage::FramebufferTextureFaceEXT);
[INFO] [stdout]       |                                                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12404 |          storage::FramebufferTextureFaceARB.aliased(addr_of!(storage::FramebufferTextureFaceEXT));
[INFO] [stdout]       |                                                     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12405:53
[INFO] [stdout]       |
[INFO] [stdout] 12405 |          storage::FramebufferTextureFaceEXT.aliased(&storage::FramebufferTextureFaceARB);
[INFO] [stdout]       |                                                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12405 |          storage::FramebufferTextureFaceEXT.aliased(addr_of!(storage::FramebufferTextureFaceARB));
[INFO] [stdout]       |                                                     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12406:51
[INFO] [stdout]       |
[INFO] [stdout] 12406 |          storage::FramebufferTextureLayer.aliased(&storage::FramebufferTextureLayerARB);
[INFO] [stdout]       |                                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12406 |          storage::FramebufferTextureLayer.aliased(addr_of!(storage::FramebufferTextureLayerARB));
[INFO] [stdout]       |                                                   ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12407:51
[INFO] [stdout]       |
[INFO] [stdout] 12407 |          storage::FramebufferTextureLayer.aliased(&storage::FramebufferTextureLayerEXT);
[INFO] [stdout]       |                                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12407 |          storage::FramebufferTextureLayer.aliased(addr_of!(storage::FramebufferTextureLayerEXT));
[INFO] [stdout]       |                                                   ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12408:54
[INFO] [stdout]       |
[INFO] [stdout] 12408 |          storage::FramebufferTextureLayerARB.aliased(&storage::FramebufferTextureLayer);
[INFO] [stdout]       |                                                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12408 |          storage::FramebufferTextureLayerARB.aliased(addr_of!(storage::FramebufferTextureLayer));
[INFO] [stdout]       |                                                      ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12409:54
[INFO] [stdout]       |
[INFO] [stdout] 12409 |          storage::FramebufferTextureLayerARB.aliased(&storage::FramebufferTextureLayerEXT);
[INFO] [stdout]       |                                                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12409 |          storage::FramebufferTextureLayerARB.aliased(addr_of!(storage::FramebufferTextureLayerEXT));
[INFO] [stdout]       |                                                      ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12410:54
[INFO] [stdout]       |
[INFO] [stdout] 12410 |          storage::FramebufferTextureLayerEXT.aliased(&storage::FramebufferTextureLayer);
[INFO] [stdout]       |                                                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12410 |          storage::FramebufferTextureLayerEXT.aliased(addr_of!(storage::FramebufferTextureLayer));
[INFO] [stdout]       |                                                      ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12411:54
[INFO] [stdout]       |
[INFO] [stdout] 12411 |          storage::FramebufferTextureLayerEXT.aliased(&storage::FramebufferTextureLayerARB);
[INFO] [stdout]       |                                                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12411 |          storage::FramebufferTextureLayerEXT.aliased(addr_of!(storage::FramebufferTextureLayerARB));
[INFO] [stdout]       |                                                      ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12412:38
[INFO] [stdout]       |
[INFO] [stdout] 12412 |          storage::GenBuffers.aliased(&storage::GenBuffersARB);
[INFO] [stdout]       |                                      ^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12412 |          storage::GenBuffers.aliased(addr_of!(storage::GenBuffersARB));
[INFO] [stdout]       |                                      ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12413:41
[INFO] [stdout]       |
[INFO] [stdout] 12413 |          storage::GenBuffersARB.aliased(&storage::GenBuffers);
[INFO] [stdout]       |                                         ^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12413 |          storage::GenBuffersARB.aliased(addr_of!(storage::GenBuffers));
[INFO] [stdout]       |                                         ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12414:42
[INFO] [stdout]       |
[INFO] [stdout] 12414 |          storage::GenerateMipmap.aliased(&storage::GenerateMipmapEXT);
[INFO] [stdout]       |                                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12414 |          storage::GenerateMipmap.aliased(addr_of!(storage::GenerateMipmapEXT));
[INFO] [stdout]       |                                          ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12415:45
[INFO] [stdout]       |
[INFO] [stdout] 12415 |          storage::GenerateMipmapEXT.aliased(&storage::GenerateMipmap);
[INFO] [stdout]       |                                             ^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12415 |          storage::GenerateMipmapEXT.aliased(addr_of!(storage::GenerateMipmap));
[INFO] [stdout]       |                                             ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12416:43
[INFO] [stdout]       |
[INFO] [stdout] 12416 |          storage::GenFramebuffers.aliased(&storage::GenFramebuffersEXT);
[INFO] [stdout]       |                                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12416 |          storage::GenFramebuffers.aliased(addr_of!(storage::GenFramebuffersEXT));
[INFO] [stdout]       |                                           ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12417:46
[INFO] [stdout]       |
[INFO] [stdout] 12417 |          storage::GenFramebuffersEXT.aliased(&storage::GenFramebuffers);
[INFO] [stdout]       |                                              ^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12417 |          storage::GenFramebuffersEXT.aliased(addr_of!(storage::GenFramebuffers));
[INFO] [stdout]       |                                              ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12418:42
[INFO] [stdout]       |
[INFO] [stdout] 12418 |          storage::GenProgramsARB.aliased(&storage::GenProgramsNV);
[INFO] [stdout]       |                                          ^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12418 |          storage::GenProgramsARB.aliased(addr_of!(storage::GenProgramsNV));
[INFO] [stdout]       |                                          ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12419:41
[INFO] [stdout]       |
[INFO] [stdout] 12419 |          storage::GenProgramsNV.aliased(&storage::GenProgramsARB);
[INFO] [stdout]       |                                         ^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12419 |          storage::GenProgramsNV.aliased(addr_of!(storage::GenProgramsARB));
[INFO] [stdout]       |                                         ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12420:38
[INFO] [stdout]       |
[INFO] [stdout] 12420 |          storage::GenQueries.aliased(&storage::GenQueriesARB);
[INFO] [stdout]       |                                      ^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12420 |          storage::GenQueries.aliased(addr_of!(storage::GenQueriesARB));
[INFO] [stdout]       |                                      ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12421:41
[INFO] [stdout]       |
[INFO] [stdout] 12421 |          storage::GenQueriesARB.aliased(&storage::GenQueries);
[INFO] [stdout]       |                                         ^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12421 |          storage::GenQueriesARB.aliased(addr_of!(storage::GenQueries));
[INFO] [stdout]       |                                         ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12422:44
[INFO] [stdout]       |
[INFO] [stdout] 12422 |          storage::GenRenderbuffers.aliased(&storage::GenRenderbuffersEXT);
[INFO] [stdout]       |                                            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12422 |          storage::GenRenderbuffers.aliased(addr_of!(storage::GenRenderbuffersEXT));
[INFO] [stdout]       |                                            ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12423:47
[INFO] [stdout]       |
[INFO] [stdout] 12423 |          storage::GenRenderbuffersEXT.aliased(&storage::GenRenderbuffers);
[INFO] [stdout]       |                                               ^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12423 |          storage::GenRenderbuffersEXT.aliased(addr_of!(storage::GenRenderbuffers));
[INFO] [stdout]       |                                               ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12424:49
[INFO] [stdout]       |
[INFO] [stdout] 12424 |          storage::GenTransformFeedbacks.aliased(&storage::GenTransformFeedbacksNV);
[INFO] [stdout]       |                                                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12424 |          storage::GenTransformFeedbacks.aliased(addr_of!(storage::GenTransformFeedbacksNV));
[INFO] [stdout]       |                                                 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12425:51
[INFO] [stdout]       |
[INFO] [stdout] 12425 |          storage::GenTransformFeedbacksNV.aliased(&storage::GenTransformFeedbacks);
[INFO] [stdout]       |                                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12425 |          storage::GenTransformFeedbacksNV.aliased(addr_of!(storage::GenTransformFeedbacks));
[INFO] [stdout]       |                                                   ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12426:43
[INFO] [stdout]       |
[INFO] [stdout] 12426 |          storage::GenVertexArrays.aliased(&storage::GenVertexArraysAPPLE);
[INFO] [stdout]       |                                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12426 |          storage::GenVertexArrays.aliased(addr_of!(storage::GenVertexArraysAPPLE));
[INFO] [stdout]       |                                           ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12427:48
[INFO] [stdout]       |
[INFO] [stdout] 12427 |          storage::GenVertexArraysAPPLE.aliased(&storage::GenVertexArrays);
[INFO] [stdout]       |                                                ^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12427 |          storage::GenVertexArraysAPPLE.aliased(addr_of!(storage::GenVertexArrays));
[INFO] [stdout]       |                                                ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12428:43
[INFO] [stdout]       |
[INFO] [stdout] 12428 |          storage::GetActiveAttrib.aliased(&storage::GetActiveAttribARB);
[INFO] [stdout]       |                                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12428 |          storage::GetActiveAttrib.aliased(addr_of!(storage::GetActiveAttribARB));
[INFO] [stdout]       |                                           ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12429:46
[INFO] [stdout]       |
[INFO] [stdout] 12429 |          storage::GetActiveAttribARB.aliased(&storage::GetActiveAttrib);
[INFO] [stdout]       |                                              ^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12429 |          storage::GetActiveAttribARB.aliased(addr_of!(storage::GetActiveAttrib));
[INFO] [stdout]       |                                              ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12430:44
[INFO] [stdout]       |
[INFO] [stdout] 12430 |          storage::GetActiveUniform.aliased(&storage::GetActiveUniformARB);
[INFO] [stdout]       |                                            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12430 |          storage::GetActiveUniform.aliased(addr_of!(storage::GetActiveUniformARB));
[INFO] [stdout]       |                                            ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12431:47
[INFO] [stdout]       |
[INFO] [stdout] 12431 |          storage::GetActiveUniformARB.aliased(&storage::GetActiveUniform);
[INFO] [stdout]       |                                               ^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12431 |          storage::GetActiveUniformARB.aliased(addr_of!(storage::GetActiveUniform));
[INFO] [stdout]       |                                               ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12432:45
[INFO] [stdout]       |
[INFO] [stdout] 12432 |          storage::GetAttribLocation.aliased(&storage::GetAttribLocationARB);
[INFO] [stdout]       |                                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12432 |          storage::GetAttribLocation.aliased(addr_of!(storage::GetAttribLocationARB));
[INFO] [stdout]       |                                             ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12433:48
[INFO] [stdout]       |
[INFO] [stdout] 12433 |          storage::GetAttribLocationARB.aliased(&storage::GetAttribLocation);
[INFO] [stdout]       |                                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12433 |          storage::GetAttribLocationARB.aliased(addr_of!(storage::GetAttribLocation));
[INFO] [stdout]       |                                                ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12434:41
[INFO] [stdout]       |
[INFO] [stdout] 12434 |          storage::GetBooleani_v.aliased(&storage::GetBooleanIndexedvEXT);
[INFO] [stdout]       |                                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12434 |          storage::GetBooleani_v.aliased(addr_of!(storage::GetBooleanIndexedvEXT));
[INFO] [stdout]       |                                         ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12435:49
[INFO] [stdout]       |
[INFO] [stdout] 12435 |          storage::GetBooleanIndexedvEXT.aliased(&storage::GetBooleani_v);
[INFO] [stdout]       |                                                 ^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12435 |          storage::GetBooleanIndexedvEXT.aliased(addr_of!(storage::GetBooleani_v));
[INFO] [stdout]       |                                                 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12436:48
[INFO] [stdout]       |
[INFO] [stdout] 12436 |          storage::GetBufferParameteriv.aliased(&storage::GetBufferParameterivARB);
[INFO] [stdout]       |                                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12436 |          storage::GetBufferParameteriv.aliased(addr_of!(storage::GetBufferParameterivARB));
[INFO] [stdout]       |                                                ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12437:51
[INFO] [stdout]       |
[INFO] [stdout] 12437 |          storage::GetBufferParameterivARB.aliased(&storage::GetBufferParameteriv);
[INFO] [stdout]       |                                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12437 |          storage::GetBufferParameterivARB.aliased(addr_of!(storage::GetBufferParameteriv));
[INFO] [stdout]       |                                                   ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12438:45
[INFO] [stdout]       |
[INFO] [stdout] 12438 |          storage::GetBufferPointerv.aliased(&storage::GetBufferPointervARB);
[INFO] [stdout]       |                                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12438 |          storage::GetBufferPointerv.aliased(addr_of!(storage::GetBufferPointervARB));
[INFO] [stdout]       |                                             ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12439:48
[INFO] [stdout]       |
[INFO] [stdout] 12439 |          storage::GetBufferPointervARB.aliased(&storage::GetBufferPointerv);
[INFO] [stdout]       |                                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12439 |          storage::GetBufferPointervARB.aliased(addr_of!(storage::GetBufferPointerv));
[INFO] [stdout]       |                                                ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12440:44
[INFO] [stdout]       |
[INFO] [stdout] 12440 |          storage::GetBufferSubData.aliased(&storage::GetBufferSubDataARB);
[INFO] [stdout]       |                                            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12440 |          storage::GetBufferSubData.aliased(addr_of!(storage::GetBufferSubDataARB));
[INFO] [stdout]       |                                            ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12441:47
[INFO] [stdout]       |
[INFO] [stdout] 12441 |          storage::GetBufferSubDataARB.aliased(&storage::GetBufferSubData);
[INFO] [stdout]       |                                               ^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12441 |          storage::GetBufferSubDataARB.aliased(addr_of!(storage::GetBufferSubData));
[INFO] [stdout]       |                                               ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12442:49
[INFO] [stdout]       |
[INFO] [stdout] 12442 |          storage::GetCompressedTexImage.aliased(&storage::GetCompressedTexImageARB);
[INFO] [stdout]       |                                                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12442 |          storage::GetCompressedTexImage.aliased(addr_of!(storage::GetCompressedTexImageARB));
[INFO] [stdout]       |                                                 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12443:52
[INFO] [stdout]       |
[INFO] [stdout] 12443 |          storage::GetCompressedTexImageARB.aliased(&storage::GetCompressedTexImage);
[INFO] [stdout]       |                                                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12443 |          storage::GetCompressedTexImageARB.aliased(addr_of!(storage::GetCompressedTexImage));
[INFO] [stdout]       |                                                    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12444:46
[INFO] [stdout]       |
[INFO] [stdout] 12444 |          storage::GetDebugMessageLog.aliased(&storage::GetDebugMessageLogARB);
[INFO] [stdout]       |                                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12444 |          storage::GetDebugMessageLog.aliased(addr_of!(storage::GetDebugMessageLogARB));
[INFO] [stdout]       |                                              ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12445:49
[INFO] [stdout]       |
[INFO] [stdout] 12445 |          storage::GetDebugMessageLogARB.aliased(&storage::GetDebugMessageLog);
[INFO] [stdout]       |                                                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12445 |          storage::GetDebugMessageLogARB.aliased(addr_of!(storage::GetDebugMessageLog));
[INFO] [stdout]       |                                                 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12446:40
[INFO] [stdout]       |
[INFO] [stdout] 12446 |          storage::GetDoublei_v.aliased(&storage::GetDoubleIndexedvEXT);
[INFO] [stdout]       |                                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12446 |          storage::GetDoublei_v.aliased(addr_of!(storage::GetDoubleIndexedvEXT));
[INFO] [stdout]       |                                        ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12447:40
[INFO] [stdout]       |
[INFO] [stdout] 12447 |          storage::GetDoublei_v.aliased(&storage::GetDoublei_vEXT);
[INFO] [stdout]       |                                        ^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12447 |          storage::GetDoublei_v.aliased(addr_of!(storage::GetDoublei_vEXT));
[INFO] [stdout]       |                                        ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12448:43
[INFO] [stdout]       |
[INFO] [stdout] 12448 |          storage::GetDoublei_vEXT.aliased(&storage::GetDoubleIndexedvEXT);
[INFO] [stdout]       |                                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12448 |          storage::GetDoublei_vEXT.aliased(addr_of!(storage::GetDoubleIndexedvEXT));
[INFO] [stdout]       |                                           ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12449:43
[INFO] [stdout]       |
[INFO] [stdout] 12449 |          storage::GetDoublei_vEXT.aliased(&storage::GetDoublei_v);
[INFO] [stdout]       |                                           ^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12449 |          storage::GetDoublei_vEXT.aliased(addr_of!(storage::GetDoublei_v));
[INFO] [stdout]       |                                           ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12450:48
[INFO] [stdout]       |
[INFO] [stdout] 12450 |          storage::GetDoubleIndexedvEXT.aliased(&storage::GetDoublei_v);
[INFO] [stdout]       |                                                ^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12450 |          storage::GetDoubleIndexedvEXT.aliased(addr_of!(storage::GetDoublei_v));
[INFO] [stdout]       |                                                ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12451:48
[INFO] [stdout]       |
[INFO] [stdout] 12451 |          storage::GetDoubleIndexedvEXT.aliased(&storage::GetDoublei_vEXT);
[INFO] [stdout]       |                                                ^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12451 |          storage::GetDoubleIndexedvEXT.aliased(addr_of!(storage::GetDoublei_vEXT));
[INFO] [stdout]       |                                                ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12452:39
[INFO] [stdout]       |
[INFO] [stdout] 12452 |          storage::GetFloati_v.aliased(&storage::GetFloatIndexedvEXT);
[INFO] [stdout]       |                                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12452 |          storage::GetFloati_v.aliased(addr_of!(storage::GetFloatIndexedvEXT));
[INFO] [stdout]       |                                       ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12453:39
[INFO] [stdout]       |
[INFO] [stdout] 12453 |          storage::GetFloati_v.aliased(&storage::GetFloati_vEXT);
[INFO] [stdout]       |                                       ^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12453 |          storage::GetFloati_v.aliased(addr_of!(storage::GetFloati_vEXT));
[INFO] [stdout]       |                                       ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12454:42
[INFO] [stdout]       |
[INFO] [stdout] 12454 |          storage::GetFloati_vEXT.aliased(&storage::GetFloatIndexedvEXT);
[INFO] [stdout]       |                                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12454 |          storage::GetFloati_vEXT.aliased(addr_of!(storage::GetFloatIndexedvEXT));
[INFO] [stdout]       |                                          ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12455:42
[INFO] [stdout]       |
[INFO] [stdout] 12455 |          storage::GetFloati_vEXT.aliased(&storage::GetFloati_v);
[INFO] [stdout]       |                                          ^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12455 |          storage::GetFloati_vEXT.aliased(addr_of!(storage::GetFloati_v));
[INFO] [stdout]       |                                          ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12456:47
[INFO] [stdout]       |
[INFO] [stdout] 12456 |          storage::GetFloatIndexedvEXT.aliased(&storage::GetFloati_v);
[INFO] [stdout]       |                                               ^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12456 |          storage::GetFloatIndexedvEXT.aliased(addr_of!(storage::GetFloati_v));
[INFO] [stdout]       |                                               ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12457:47
[INFO] [stdout]       |
[INFO] [stdout] 12457 |          storage::GetFloatIndexedvEXT.aliased(&storage::GetFloati_vEXT);
[INFO] [stdout]       |                                               ^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12457 |          storage::GetFloatIndexedvEXT.aliased(addr_of!(storage::GetFloati_vEXT));
[INFO] [stdout]       |                                               ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12458:47
[INFO] [stdout]       |
[INFO] [stdout] 12458 |          storage::GetFragDataLocation.aliased(&storage::GetFragDataLocationEXT);
[INFO] [stdout]       |                                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12458 |          storage::GetFragDataLocation.aliased(addr_of!(storage::GetFragDataLocationEXT));
[INFO] [stdout]       |                                               ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12459:50
[INFO] [stdout]       |
[INFO] [stdout] 12459 |          storage::GetFragDataLocationEXT.aliased(&storage::GetFragDataLocation);
[INFO] [stdout]       |                                                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12459 |          storage::GetFragDataLocationEXT.aliased(addr_of!(storage::GetFragDataLocation));
[INFO] [stdout]       |                                                  ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12460:63
[INFO] [stdout]       |
[INFO] [stdout] 12460 |          storage::GetFramebufferAttachmentParameteriv.aliased(&storage::GetFramebufferAttachmentParameterivEXT);
[INFO] [stdout]       |                                                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12460 |          storage::GetFramebufferAttachmentParameteriv.aliased(addr_of!(storage::GetFramebufferAttachmentParameterivEXT));
[INFO] [stdout]       |                                                               ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12461:66
[INFO] [stdout]       |
[INFO] [stdout] 12461 |          storage::GetFramebufferAttachmentParameterivEXT.aliased(&storage::GetFramebufferAttachmentParameteriv);
[INFO] [stdout]       |                                                                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12461 |          storage::GetFramebufferAttachmentParameterivEXT.aliased(addr_of!(storage::GetFramebufferAttachmentParameteriv));
[INFO] [stdout]       |                                                                  ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12462:41
[INFO] [stdout]       |
[INFO] [stdout] 12462 |          storage::GetIntegeri_v.aliased(&storage::GetIntegerIndexedvEXT);
[INFO] [stdout]       |                                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12462 |          storage::GetIntegeri_v.aliased(addr_of!(storage::GetIntegerIndexedvEXT));
[INFO] [stdout]       |                                         ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12463:49
[INFO] [stdout]       |
[INFO] [stdout] 12463 |          storage::GetIntegerIndexedvEXT.aliased(&storage::GetIntegeri_v);
[INFO] [stdout]       |                                                 ^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12463 |          storage::GetIntegerIndexedvEXT.aliased(addr_of!(storage::GetIntegeri_v));
[INFO] [stdout]       |                                                 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12464:44
[INFO] [stdout]       |
[INFO] [stdout] 12464 |          storage::GetMultisamplefv.aliased(&storage::GetMultisamplefvNV);
[INFO] [stdout]       |                                            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12464 |          storage::GetMultisamplefv.aliased(addr_of!(storage::GetMultisamplefvNV));
[INFO] [stdout]       |                                            ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12465:46
[INFO] [stdout]       |
[INFO] [stdout] 12465 |          storage::GetMultisamplefvNV.aliased(&storage::GetMultisamplefv);
[INFO] [stdout]       |                                              ^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12465 |          storage::GetMultisamplefvNV.aliased(addr_of!(storage::GetMultisamplefv));
[INFO] [stdout]       |                                              ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12466:39
[INFO] [stdout]       |
[INFO] [stdout] 12466 |          storage::GetPointerv.aliased(&storage::GetPointervEXT);
[INFO] [stdout]       |                                       ^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12466 |          storage::GetPointerv.aliased(addr_of!(storage::GetPointervEXT));
[INFO] [stdout]       |                                       ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12467:42
[INFO] [stdout]       |
[INFO] [stdout] 12467 |          storage::GetPointervEXT.aliased(&storage::GetPointerv);
[INFO] [stdout]       |                                          ^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12467 |          storage::GetPointervEXT.aliased(addr_of!(storage::GetPointerv));
[INFO] [stdout]       |                                          ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12468:38
[INFO] [stdout]       |
[INFO] [stdout] 12468 |          storage::GetQueryiv.aliased(&storage::GetQueryivARB);
[INFO] [stdout]       |                                      ^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12468 |          storage::GetQueryiv.aliased(addr_of!(storage::GetQueryivARB));
[INFO] [stdout]       |                                      ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12469:41
[INFO] [stdout]       |
[INFO] [stdout] 12469 |          storage::GetQueryivARB.aliased(&storage::GetQueryiv);
[INFO] [stdout]       |                                         ^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12469 |          storage::GetQueryivARB.aliased(addr_of!(storage::GetQueryiv));
[INFO] [stdout]       |                                         ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12470:46
[INFO] [stdout]       |
[INFO] [stdout] 12470 |          storage::GetQueryObjecti64v.aliased(&storage::GetQueryObjecti64vEXT);
[INFO] [stdout]       |                                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12470 |          storage::GetQueryObjecti64v.aliased(addr_of!(storage::GetQueryObjecti64vEXT));
[INFO] [stdout]       |                                              ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12471:49
[INFO] [stdout]       |
[INFO] [stdout] 12471 |          storage::GetQueryObjecti64vEXT.aliased(&storage::GetQueryObjecti64v);
[INFO] [stdout]       |                                                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12471 |          storage::GetQueryObjecti64vEXT.aliased(addr_of!(storage::GetQueryObjecti64v));
[INFO] [stdout]       |                                                 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12472:44
[INFO] [stdout]       |
[INFO] [stdout] 12472 |          storage::GetQueryObjectiv.aliased(&storage::GetQueryObjectivARB);
[INFO] [stdout]       |                                            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12472 |          storage::GetQueryObjectiv.aliased(addr_of!(storage::GetQueryObjectivARB));
[INFO] [stdout]       |                                            ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12473:47
[INFO] [stdout]       |
[INFO] [stdout] 12473 |          storage::GetQueryObjectivARB.aliased(&storage::GetQueryObjectiv);
[INFO] [stdout]       |                                               ^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12473 |          storage::GetQueryObjectivARB.aliased(addr_of!(storage::GetQueryObjectiv));
[INFO] [stdout]       |                                               ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12474:47
[INFO] [stdout]       |
[INFO] [stdout] 12474 |          storage::GetQueryObjectui64v.aliased(&storage::GetQueryObjectui64vEXT);
[INFO] [stdout]       |                                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12474 |          storage::GetQueryObjectui64v.aliased(addr_of!(storage::GetQueryObjectui64vEXT));
[INFO] [stdout]       |                                               ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12475:50
[INFO] [stdout]       |
[INFO] [stdout] 12475 |          storage::GetQueryObjectui64vEXT.aliased(&storage::GetQueryObjectui64v);
[INFO] [stdout]       |                                                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12475 |          storage::GetQueryObjectui64vEXT.aliased(addr_of!(storage::GetQueryObjectui64v));
[INFO] [stdout]       |                                                  ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12476:45
[INFO] [stdout]       |
[INFO] [stdout] 12476 |          storage::GetQueryObjectuiv.aliased(&storage::GetQueryObjectuivARB);
[INFO] [stdout]       |                                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12476 |          storage::GetQueryObjectuiv.aliased(addr_of!(storage::GetQueryObjectuivARB));
[INFO] [stdout]       |                                             ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12477:48
[INFO] [stdout]       |
[INFO] [stdout] 12477 |          storage::GetQueryObjectuivARB.aliased(&storage::GetQueryObjectuiv);
[INFO] [stdout]       |                                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12477 |          storage::GetQueryObjectuivARB.aliased(addr_of!(storage::GetQueryObjectuiv));
[INFO] [stdout]       |                                                ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12478:54
[INFO] [stdout]       |
[INFO] [stdout] 12478 |          storage::GetRenderbufferParameteriv.aliased(&storage::GetRenderbufferParameterivEXT);
[INFO] [stdout]       |                                                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12478 |          storage::GetRenderbufferParameteriv.aliased(addr_of!(storage::GetRenderbufferParameterivEXT));
[INFO] [stdout]       |                                                      ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12479:57
[INFO] [stdout]       |
[INFO] [stdout] 12479 |          storage::GetRenderbufferParameterivEXT.aliased(&storage::GetRenderbufferParameteriv);
[INFO] [stdout]       |                                                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12479 |          storage::GetRenderbufferParameterivEXT.aliased(addr_of!(storage::GetRenderbufferParameteriv));
[INFO] [stdout]       |                                                         ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12480:43
[INFO] [stdout]       |
[INFO] [stdout] 12480 |          storage::GetShaderSource.aliased(&storage::GetShaderSourceARB);
[INFO] [stdout]       |                                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12480 |          storage::GetShaderSource.aliased(addr_of!(storage::GetShaderSourceARB));
[INFO] [stdout]       |                                           ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12481:46
[INFO] [stdout]       |
[INFO] [stdout] 12481 |          storage::GetShaderSourceARB.aliased(&storage::GetShaderSource);
[INFO] [stdout]       |                                              ^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12481 |          storage::GetShaderSourceARB.aliased(addr_of!(storage::GetShaderSource));
[INFO] [stdout]       |                                              ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12482:46
[INFO] [stdout]       |
[INFO] [stdout] 12482 |          storage::GetTexParameterIiv.aliased(&storage::GetTexParameterIivEXT);
[INFO] [stdout]       |                                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12482 |          storage::GetTexParameterIiv.aliased(addr_of!(storage::GetTexParameterIivEXT));
[INFO] [stdout]       |                                              ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12483:49
[INFO] [stdout]       |
[INFO] [stdout] 12483 |          storage::GetTexParameterIivEXT.aliased(&storage::GetTexParameterIiv);
[INFO] [stdout]       |                                                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12483 |          storage::GetTexParameterIivEXT.aliased(addr_of!(storage::GetTexParameterIiv));
[INFO] [stdout]       |                                                 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12484:47
[INFO] [stdout]       |
[INFO] [stdout] 12484 |          storage::GetTexParameterIuiv.aliased(&storage::GetTexParameterIuivEXT);
[INFO] [stdout]       |                                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12484 |          storage::GetTexParameterIuiv.aliased(addr_of!(storage::GetTexParameterIuivEXT));
[INFO] [stdout]       |                                               ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12485:50
[INFO] [stdout]       |
[INFO] [stdout] 12485 |          storage::GetTexParameterIuivEXT.aliased(&storage::GetTexParameterIuiv);
[INFO] [stdout]       |                                                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12485 |          storage::GetTexParameterIuivEXT.aliased(addr_of!(storage::GetTexParameterIuiv));
[INFO] [stdout]       |                                                  ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12486:55
[INFO] [stdout]       |
[INFO] [stdout] 12486 |          storage::GetTransformFeedbackVarying.aliased(&storage::GetTransformFeedbackVaryingEXT);
[INFO] [stdout]       |                                                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12486 |          storage::GetTransformFeedbackVarying.aliased(addr_of!(storage::GetTransformFeedbackVaryingEXT));
[INFO] [stdout]       |                                                       ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12487:58
[INFO] [stdout]       |
[INFO] [stdout] 12487 |          storage::GetTransformFeedbackVaryingEXT.aliased(&storage::GetTransformFeedbackVarying);
[INFO] [stdout]       |                                                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12487 |          storage::GetTransformFeedbackVaryingEXT.aliased(addr_of!(storage::GetTransformFeedbackVarying));
[INFO] [stdout]       |                                                          ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12488:40
[INFO] [stdout]       |
[INFO] [stdout] 12488 |          storage::GetUniformfv.aliased(&storage::GetUniformfvARB);
[INFO] [stdout]       |                                        ^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12488 |          storage::GetUniformfv.aliased(addr_of!(storage::GetUniformfvARB));
[INFO] [stdout]       |                                        ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12489:43
[INFO] [stdout]       |
[INFO] [stdout] 12489 |          storage::GetUniformfvARB.aliased(&storage::GetUniformfv);
[INFO] [stdout]       |                                           ^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12489 |          storage::GetUniformfvARB.aliased(addr_of!(storage::GetUniformfv));
[INFO] [stdout]       |                                           ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12490:40
[INFO] [stdout]       |
[INFO] [stdout] 12490 |          storage::GetUniformiv.aliased(&storage::GetUniformivARB);
[INFO] [stdout]       |                                        ^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12490 |          storage::GetUniformiv.aliased(addr_of!(storage::GetUniformivARB));
[INFO] [stdout]       |                                        ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12491:43
[INFO] [stdout]       |
[INFO] [stdout] 12491 |          storage::GetUniformivARB.aliased(&storage::GetUniformiv);
[INFO] [stdout]       |                                           ^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12491 |          storage::GetUniformivARB.aliased(addr_of!(storage::GetUniformiv));
[INFO] [stdout]       |                                           ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12492:46
[INFO] [stdout]       |
[INFO] [stdout] 12492 |          storage::GetUniformLocation.aliased(&storage::GetUniformLocationARB);
[INFO] [stdout]       |                                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12492 |          storage::GetUniformLocation.aliased(addr_of!(storage::GetUniformLocationARB));
[INFO] [stdout]       |                                              ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12493:49
[INFO] [stdout]       |
[INFO] [stdout] 12493 |          storage::GetUniformLocationARB.aliased(&storage::GetUniformLocation);
[INFO] [stdout]       |                                                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12493 |          storage::GetUniformLocationARB.aliased(addr_of!(storage::GetUniformLocation));
[INFO] [stdout]       |                                                 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12494:41
[INFO] [stdout]       |
[INFO] [stdout] 12494 |          storage::GetUniformuiv.aliased(&storage::GetUniformuivEXT);
[INFO] [stdout]       |                                         ^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12494 |          storage::GetUniformuiv.aliased(addr_of!(storage::GetUniformuivEXT));
[INFO] [stdout]       |                                         ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12495:44
[INFO] [stdout]       |
[INFO] [stdout] 12495 |          storage::GetUniformuivEXT.aliased(&storage::GetUniformuiv);
[INFO] [stdout]       |                                            ^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12495 |          storage::GetUniformuivEXT.aliased(addr_of!(storage::GetUniformuiv));
[INFO] [stdout]       |                                            ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12496:45
[INFO] [stdout]       |
[INFO] [stdout] 12496 |          storage::GetVertexAttribdv.aliased(&storage::GetVertexAttribdvARB);
[INFO] [stdout]       |                                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12496 |          storage::GetVertexAttribdv.aliased(addr_of!(storage::GetVertexAttribdvARB));
[INFO] [stdout]       |                                             ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12497:45
[INFO] [stdout]       |
[INFO] [stdout] 12497 |          storage::GetVertexAttribdv.aliased(&storage::GetVertexAttribdvNV);
[INFO] [stdout]       |                                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12497 |          storage::GetVertexAttribdv.aliased(addr_of!(storage::GetVertexAttribdvNV));
[INFO] [stdout]       |                                             ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12498:48
[INFO] [stdout]       |
[INFO] [stdout] 12498 |          storage::GetVertexAttribdvARB.aliased(&storage::GetVertexAttribdv);
[INFO] [stdout]       |                                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12498 |          storage::GetVertexAttribdvARB.aliased(addr_of!(storage::GetVertexAttribdv));
[INFO] [stdout]       |                                                ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12499:48
[INFO] [stdout]       |
[INFO] [stdout] 12499 |          storage::GetVertexAttribdvARB.aliased(&storage::GetVertexAttribdvNV);
[INFO] [stdout]       |                                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12499 |          storage::GetVertexAttribdvARB.aliased(addr_of!(storage::GetVertexAttribdvNV));
[INFO] [stdout]       |                                                ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12500:47
[INFO] [stdout]       |
[INFO] [stdout] 12500 |          storage::GetVertexAttribdvNV.aliased(&storage::GetVertexAttribdv);
[INFO] [stdout]       |                                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12500 |          storage::GetVertexAttribdvNV.aliased(addr_of!(storage::GetVertexAttribdv));
[INFO] [stdout]       |                                               ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12501:47
[INFO] [stdout]       |
[INFO] [stdout] 12501 |          storage::GetVertexAttribdvNV.aliased(&storage::GetVertexAttribdvARB);
[INFO] [stdout]       |                                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12501 |          storage::GetVertexAttribdvNV.aliased(addr_of!(storage::GetVertexAttribdvARB));
[INFO] [stdout]       |                                               ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12502:45
[INFO] [stdout]       |
[INFO] [stdout] 12502 |          storage::GetVertexAttribfv.aliased(&storage::GetVertexAttribfvARB);
[INFO] [stdout]       |                                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12502 |          storage::GetVertexAttribfv.aliased(addr_of!(storage::GetVertexAttribfvARB));
[INFO] [stdout]       |                                             ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12503:45
[INFO] [stdout]       |
[INFO] [stdout] 12503 |          storage::GetVertexAttribfv.aliased(&storage::GetVertexAttribfvNV);
[INFO] [stdout]       |                                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12503 |          storage::GetVertexAttribfv.aliased(addr_of!(storage::GetVertexAttribfvNV));
[INFO] [stdout]       |                                             ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12504:48
[INFO] [stdout]       |
[INFO] [stdout] 12504 |          storage::GetVertexAttribfvARB.aliased(&storage::GetVertexAttribfv);
[INFO] [stdout]       |                                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12504 |          storage::GetVertexAttribfvARB.aliased(addr_of!(storage::GetVertexAttribfv));
[INFO] [stdout]       |                                                ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12505:48
[INFO] [stdout]       |
[INFO] [stdout] 12505 |          storage::GetVertexAttribfvARB.aliased(&storage::GetVertexAttribfvNV);
[INFO] [stdout]       |                                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12505 |          storage::GetVertexAttribfvARB.aliased(addr_of!(storage::GetVertexAttribfvNV));
[INFO] [stdout]       |                                                ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12506:47
[INFO] [stdout]       |
[INFO] [stdout] 12506 |          storage::GetVertexAttribfvNV.aliased(&storage::GetVertexAttribfv);
[INFO] [stdout]       |                                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12506 |          storage::GetVertexAttribfvNV.aliased(addr_of!(storage::GetVertexAttribfv));
[INFO] [stdout]       |                                               ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12507:47
[INFO] [stdout]       |
[INFO] [stdout] 12507 |          storage::GetVertexAttribfvNV.aliased(&storage::GetVertexAttribfvARB);
[INFO] [stdout]       |                                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12507 |          storage::GetVertexAttribfvNV.aliased(addr_of!(storage::GetVertexAttribfvARB));
[INFO] [stdout]       |                                               ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12508:46
[INFO] [stdout]       |
[INFO] [stdout] 12508 |          storage::GetVertexAttribIiv.aliased(&storage::GetVertexAttribIivEXT);
[INFO] [stdout]       |                                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12508 |          storage::GetVertexAttribIiv.aliased(addr_of!(storage::GetVertexAttribIivEXT));
[INFO] [stdout]       |                                              ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12509:49
[INFO] [stdout]       |
[INFO] [stdout] 12509 |          storage::GetVertexAttribIivEXT.aliased(&storage::GetVertexAttribIiv);
[INFO] [stdout]       |                                                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12509 |          storage::GetVertexAttribIivEXT.aliased(addr_of!(storage::GetVertexAttribIiv));
[INFO] [stdout]       |                                                 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12510:47
[INFO] [stdout]       |
[INFO] [stdout] 12510 |          storage::GetVertexAttribIuiv.aliased(&storage::GetVertexAttribIuivEXT);
[INFO] [stdout]       |                                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12510 |          storage::GetVertexAttribIuiv.aliased(addr_of!(storage::GetVertexAttribIuivEXT));
[INFO] [stdout]       |                                               ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12511:50
[INFO] [stdout]       |
[INFO] [stdout] 12511 |          storage::GetVertexAttribIuivEXT.aliased(&storage::GetVertexAttribIuiv);
[INFO] [stdout]       |                                                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12511 |          storage::GetVertexAttribIuivEXT.aliased(addr_of!(storage::GetVertexAttribIuiv));
[INFO] [stdout]       |                                                  ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12512:45
[INFO] [stdout]       |
[INFO] [stdout] 12512 |          storage::GetVertexAttribiv.aliased(&storage::GetVertexAttribivARB);
[INFO] [stdout]       |                                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12512 |          storage::GetVertexAttribiv.aliased(addr_of!(storage::GetVertexAttribivARB));
[INFO] [stdout]       |                                             ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12513:45
[INFO] [stdout]       |
[INFO] [stdout] 12513 |          storage::GetVertexAttribiv.aliased(&storage::GetVertexAttribivNV);
[INFO] [stdout]       |                                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12513 |          storage::GetVertexAttribiv.aliased(addr_of!(storage::GetVertexAttribivNV));
[INFO] [stdout]       |                                             ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12514:48
[INFO] [stdout]       |
[INFO] [stdout] 12514 |          storage::GetVertexAttribivARB.aliased(&storage::GetVertexAttribiv);
[INFO] [stdout]       |                                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12514 |          storage::GetVertexAttribivARB.aliased(addr_of!(storage::GetVertexAttribiv));
[INFO] [stdout]       |                                                ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12515:48
[INFO] [stdout]       |
[INFO] [stdout] 12515 |          storage::GetVertexAttribivARB.aliased(&storage::GetVertexAttribivNV);
[INFO] [stdout]       |                                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12515 |          storage::GetVertexAttribivARB.aliased(addr_of!(storage::GetVertexAttribivNV));
[INFO] [stdout]       |                                                ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12516:47
[INFO] [stdout]       |
[INFO] [stdout] 12516 |          storage::GetVertexAttribivNV.aliased(&storage::GetVertexAttribiv);
[INFO] [stdout]       |                                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12516 |          storage::GetVertexAttribivNV.aliased(addr_of!(storage::GetVertexAttribiv));
[INFO] [stdout]       |                                               ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12517:47
[INFO] [stdout]       |
[INFO] [stdout] 12517 |          storage::GetVertexAttribivNV.aliased(&storage::GetVertexAttribivARB);
[INFO] [stdout]       |                                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12517 |          storage::GetVertexAttribivNV.aliased(addr_of!(storage::GetVertexAttribivARB));
[INFO] [stdout]       |                                               ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12518:46
[INFO] [stdout]       |
[INFO] [stdout] 12518 |          storage::GetVertexAttribLdv.aliased(&storage::GetVertexAttribLdvEXT);
[INFO] [stdout]       |                                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12518 |          storage::GetVertexAttribLdv.aliased(addr_of!(storage::GetVertexAttribLdvEXT));
[INFO] [stdout]       |                                              ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12519:49
[INFO] [stdout]       |
[INFO] [stdout] 12519 |          storage::GetVertexAttribLdvEXT.aliased(&storage::GetVertexAttribLdv);
[INFO] [stdout]       |                                                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12519 |          storage::GetVertexAttribLdvEXT.aliased(addr_of!(storage::GetVertexAttribLdv));
[INFO] [stdout]       |                                                 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12520:51
[INFO] [stdout]       |
[INFO] [stdout] 12520 |          storage::GetVertexAttribPointerv.aliased(&storage::GetVertexAttribPointervARB);
[INFO] [stdout]       |                                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12520 |          storage::GetVertexAttribPointerv.aliased(addr_of!(storage::GetVertexAttribPointervARB));
[INFO] [stdout]       |                                                   ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12521:51
[INFO] [stdout]       |
[INFO] [stdout] 12521 |          storage::GetVertexAttribPointerv.aliased(&storage::GetVertexAttribPointervNV);
[INFO] [stdout]       |                                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12521 |          storage::GetVertexAttribPointerv.aliased(addr_of!(storage::GetVertexAttribPointervNV));
[INFO] [stdout]       |                                                   ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12522:54
[INFO] [stdout]       |
[INFO] [stdout] 12522 |          storage::GetVertexAttribPointervARB.aliased(&storage::GetVertexAttribPointerv);
[INFO] [stdout]       |                                                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12522 |          storage::GetVertexAttribPointervARB.aliased(addr_of!(storage::GetVertexAttribPointerv));
[INFO] [stdout]       |                                                      ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12523:54
[INFO] [stdout]       |
[INFO] [stdout] 12523 |          storage::GetVertexAttribPointervARB.aliased(&storage::GetVertexAttribPointervNV);
[INFO] [stdout]       |                                                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12523 |          storage::GetVertexAttribPointervARB.aliased(addr_of!(storage::GetVertexAttribPointervNV));
[INFO] [stdout]       |                                                      ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12524:53
[INFO] [stdout]       |
[INFO] [stdout] 12524 |          storage::GetVertexAttribPointervNV.aliased(&storage::GetVertexAttribPointerv);
[INFO] [stdout]       |                                                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12524 |          storage::GetVertexAttribPointervNV.aliased(addr_of!(storage::GetVertexAttribPointerv));
[INFO] [stdout]       |                                                     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12525:53
[INFO] [stdout]       |
[INFO] [stdout] 12525 |          storage::GetVertexAttribPointervNV.aliased(&storage::GetVertexAttribPointervARB);
[INFO] [stdout]       |                                                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12525 |          storage::GetVertexAttribPointervNV.aliased(addr_of!(storage::GetVertexAttribPointervARB));
[INFO] [stdout]       |                                                     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12526:36
[INFO] [stdout]       |
[INFO] [stdout] 12526 |          storage::IsBuffer.aliased(&storage::IsBufferARB);
[INFO] [stdout]       |                                    ^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12526 |          storage::IsBuffer.aliased(addr_of!(storage::IsBufferARB));
[INFO] [stdout]       |                                    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12527:39
[INFO] [stdout]       |
[INFO] [stdout] 12527 |          storage::IsBufferARB.aliased(&storage::IsBuffer);
[INFO] [stdout]       |                                       ^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12527 |          storage::IsBufferARB.aliased(addr_of!(storage::IsBuffer));
[INFO] [stdout]       |                                       ~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12528:38
[INFO] [stdout]       |
[INFO] [stdout] 12528 |          storage::IsEnabledi.aliased(&storage::IsEnabledIndexedEXT);
[INFO] [stdout]       |                                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12528 |          storage::IsEnabledi.aliased(addr_of!(storage::IsEnabledIndexedEXT));
[INFO] [stdout]       |                                      ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12529:47
[INFO] [stdout]       |
[INFO] [stdout] 12529 |          storage::IsEnabledIndexedEXT.aliased(&storage::IsEnabledi);
[INFO] [stdout]       |                                               ^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12529 |          storage::IsEnabledIndexedEXT.aliased(addr_of!(storage::IsEnabledi));
[INFO] [stdout]       |                                               ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12530:41
[INFO] [stdout]       |
[INFO] [stdout] 12530 |          storage::IsFramebuffer.aliased(&storage::IsFramebufferEXT);
[INFO] [stdout]       |                                         ^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12530 |          storage::IsFramebuffer.aliased(addr_of!(storage::IsFramebufferEXT));
[INFO] [stdout]       |                                         ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12531:44
[INFO] [stdout]       |
[INFO] [stdout] 12531 |          storage::IsFramebufferEXT.aliased(&storage::IsFramebuffer);
[INFO] [stdout]       |                                            ^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12531 |          storage::IsFramebufferEXT.aliased(addr_of!(storage::IsFramebuffer));
[INFO] [stdout]       |                                            ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12532:40
[INFO] [stdout]       |
[INFO] [stdout] 12532 |          storage::IsProgramARB.aliased(&storage::IsProgramNV);
[INFO] [stdout]       |                                        ^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12532 |          storage::IsProgramARB.aliased(addr_of!(storage::IsProgramNV));
[INFO] [stdout]       |                                        ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12533:39
[INFO] [stdout]       |
[INFO] [stdout] 12533 |          storage::IsProgramNV.aliased(&storage::IsProgramARB);
[INFO] [stdout]       |                                       ^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12533 |          storage::IsProgramNV.aliased(addr_of!(storage::IsProgramARB));
[INFO] [stdout]       |                                       ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12534:35
[INFO] [stdout]       |
[INFO] [stdout] 12534 |          storage::IsQuery.aliased(&storage::IsQueryARB);
[INFO] [stdout]       |                                   ^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12534 |          storage::IsQuery.aliased(addr_of!(storage::IsQueryARB));
[INFO] [stdout]       |                                   ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12535:38
[INFO] [stdout]       |
[INFO] [stdout] 12535 |          storage::IsQueryARB.aliased(&storage::IsQuery);
[INFO] [stdout]       |                                      ^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12535 |          storage::IsQueryARB.aliased(addr_of!(storage::IsQuery));
[INFO] [stdout]       |                                      ~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12536:42
[INFO] [stdout]       |
[INFO] [stdout] 12536 |          storage::IsRenderbuffer.aliased(&storage::IsRenderbufferEXT);
[INFO] [stdout]       |                                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12536 |          storage::IsRenderbuffer.aliased(addr_of!(storage::IsRenderbufferEXT));
[INFO] [stdout]       |                                          ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12537:45
[INFO] [stdout]       |
[INFO] [stdout] 12537 |          storage::IsRenderbufferEXT.aliased(&storage::IsRenderbuffer);
[INFO] [stdout]       |                                             ^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12537 |          storage::IsRenderbufferEXT.aliased(addr_of!(storage::IsRenderbuffer));
[INFO] [stdout]       |                                             ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12538:47
[INFO] [stdout]       |
[INFO] [stdout] 12538 |          storage::IsTransformFeedback.aliased(&storage::IsTransformFeedbackNV);
[INFO] [stdout]       |                                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12538 |          storage::IsTransformFeedback.aliased(addr_of!(storage::IsTransformFeedbackNV));
[INFO] [stdout]       |                                               ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12539:49
[INFO] [stdout]       |
[INFO] [stdout] 12539 |          storage::IsTransformFeedbackNV.aliased(&storage::IsTransformFeedback);
[INFO] [stdout]       |                                                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12539 |          storage::IsTransformFeedbackNV.aliased(addr_of!(storage::IsTransformFeedback));
[INFO] [stdout]       |                                                 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12540:41
[INFO] [stdout]       |
[INFO] [stdout] 12540 |          storage::IsVertexArray.aliased(&storage::IsVertexArrayAPPLE);
[INFO] [stdout]       |                                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12540 |          storage::IsVertexArray.aliased(addr_of!(storage::IsVertexArrayAPPLE));
[INFO] [stdout]       |                                         ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12541:46
[INFO] [stdout]       |
[INFO] [stdout] 12541 |          storage::IsVertexArrayAPPLE.aliased(&storage::IsVertexArray);
[INFO] [stdout]       |                                              ^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12541 |          storage::IsVertexArrayAPPLE.aliased(addr_of!(storage::IsVertexArray));
[INFO] [stdout]       |                                              ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12542:39
[INFO] [stdout]       |
[INFO] [stdout] 12542 |          storage::LinkProgram.aliased(&storage::LinkProgramARB);
[INFO] [stdout]       |                                       ^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12542 |          storage::LinkProgram.aliased(addr_of!(storage::LinkProgramARB));
[INFO] [stdout]       |                                       ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12543:42
[INFO] [stdout]       |
[INFO] [stdout] 12543 |          storage::LinkProgramARB.aliased(&storage::LinkProgram);
[INFO] [stdout]       |                                          ^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12543 |          storage::LinkProgramARB.aliased(addr_of!(storage::LinkProgram));
[INFO] [stdout]       |                                          ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12544:37
[INFO] [stdout]       |
[INFO] [stdout] 12544 |          storage::MapBuffer.aliased(&storage::MapBufferARB);
[INFO] [stdout]       |                                     ^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12544 |          storage::MapBuffer.aliased(addr_of!(storage::MapBufferARB));
[INFO] [stdout]       |                                     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12545:40
[INFO] [stdout]       |
[INFO] [stdout] 12545 |          storage::MapBufferARB.aliased(&storage::MapBuffer);
[INFO] [stdout]       |                                        ^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12545 |          storage::MapBufferARB.aliased(addr_of!(storage::MapBuffer));
[INFO] [stdout]       |                                        ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12546:55
[INFO] [stdout]       |
[INFO] [stdout] 12546 |          storage::MaxShaderCompilerThreadsARB.aliased(&storage::MaxShaderCompilerThreadsKHR);
[INFO] [stdout]       |                                                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12546 |          storage::MaxShaderCompilerThreadsARB.aliased(addr_of!(storage::MaxShaderCompilerThreadsKHR));
[INFO] [stdout]       |                                                       ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12547:55
[INFO] [stdout]       |
[INFO] [stdout] 12547 |          storage::MaxShaderCompilerThreadsKHR.aliased(&storage::MaxShaderCompilerThreadsARB);
[INFO] [stdout]       |                                                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12547 |          storage::MaxShaderCompilerThreadsKHR.aliased(addr_of!(storage::MaxShaderCompilerThreadsARB));
[INFO] [stdout]       |                                                       ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12548:41
[INFO] [stdout]       |
[INFO] [stdout] 12548 |          storage::MemoryBarrier.aliased(&storage::MemoryBarrierEXT);
[INFO] [stdout]       |                                         ^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12548 |          storage::MemoryBarrier.aliased(addr_of!(storage::MemoryBarrierEXT));
[INFO] [stdout]       |                                         ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12549:44
[INFO] [stdout]       |
[INFO] [stdout] 12549 |          storage::MemoryBarrierEXT.aliased(&storage::MemoryBarrier);
[INFO] [stdout]       |                                            ^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12549 |          storage::MemoryBarrierEXT.aliased(addr_of!(storage::MemoryBarrier));
[INFO] [stdout]       |                                            ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12550:43
[INFO] [stdout]       |
[INFO] [stdout] 12550 |          storage::MultiDrawArrays.aliased(&storage::MultiDrawArraysEXT);
[INFO] [stdout]       |                                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12550 |          storage::MultiDrawArrays.aliased(addr_of!(storage::MultiDrawArraysEXT));
[INFO] [stdout]       |                                           ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12551:46
[INFO] [stdout]       |
[INFO] [stdout] 12551 |          storage::MultiDrawArraysEXT.aliased(&storage::MultiDrawArrays);
[INFO] [stdout]       |                                              ^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12551 |          storage::MultiDrawArraysEXT.aliased(addr_of!(storage::MultiDrawArrays));
[INFO] [stdout]       |                                              ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12552:51
[INFO] [stdout]       |
[INFO] [stdout] 12552 |          storage::MultiDrawArraysIndirect.aliased(&storage::MultiDrawArraysIndirectAMD);
[INFO] [stdout]       |                                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12552 |          storage::MultiDrawArraysIndirect.aliased(addr_of!(storage::MultiDrawArraysIndirectAMD));
[INFO] [stdout]       |                                                   ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12553:54
[INFO] [stdout]       |
[INFO] [stdout] 12553 |          storage::MultiDrawArraysIndirectAMD.aliased(&storage::MultiDrawArraysIndirect);
[INFO] [stdout]       |                                                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12553 |          storage::MultiDrawArraysIndirectAMD.aliased(addr_of!(storage::MultiDrawArraysIndirect));
[INFO] [stdout]       |                                                      ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12554:45
[INFO] [stdout]       |
[INFO] [stdout] 12554 |          storage::MultiDrawElements.aliased(&storage::MultiDrawElementsEXT);
[INFO] [stdout]       |                                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12554 |          storage::MultiDrawElements.aliased(addr_of!(storage::MultiDrawElementsEXT));
[INFO] [stdout]       |                                             ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12555:48
[INFO] [stdout]       |
[INFO] [stdout] 12555 |          storage::MultiDrawElementsEXT.aliased(&storage::MultiDrawElements);
[INFO] [stdout]       |                                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12555 |          storage::MultiDrawElementsEXT.aliased(addr_of!(storage::MultiDrawElements));
[INFO] [stdout]       |                                                ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12556:53
[INFO] [stdout]       |
[INFO] [stdout] 12556 |          storage::MultiDrawElementsIndirect.aliased(&storage::MultiDrawElementsIndirectAMD);
[INFO] [stdout]       |                                                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12556 |          storage::MultiDrawElementsIndirect.aliased(addr_of!(storage::MultiDrawElementsIndirectAMD));
[INFO] [stdout]       |                                                     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12557:56
[INFO] [stdout]       |
[INFO] [stdout] 12557 |          storage::MultiDrawElementsIndirectAMD.aliased(&storage::MultiDrawElementsIndirect);
[INFO] [stdout]       |                                                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12557 |          storage::MultiDrawElementsIndirectAMD.aliased(addr_of!(storage::MultiDrawElementsIndirect));
[INFO] [stdout]       |                                                        ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12558:46
[INFO] [stdout]       |
[INFO] [stdout] 12558 |          storage::NamedBufferStorage.aliased(&storage::NamedBufferStorageEXT);
[INFO] [stdout]       |                                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12558 |          storage::NamedBufferStorage.aliased(addr_of!(storage::NamedBufferStorageEXT));
[INFO] [stdout]       |                                              ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12559:49
[INFO] [stdout]       |
[INFO] [stdout] 12559 |          storage::NamedBufferStorageEXT.aliased(&storage::NamedBufferStorage);
[INFO] [stdout]       |                                                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12559 |          storage::NamedBufferStorageEXT.aliased(addr_of!(storage::NamedBufferStorage));
[INFO] [stdout]       |                                                 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12560:46
[INFO] [stdout]       |
[INFO] [stdout] 12560 |          storage::NamedBufferSubData.aliased(&storage::NamedBufferSubDataEXT);
[INFO] [stdout]       |                                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12560 |          storage::NamedBufferSubData.aliased(addr_of!(storage::NamedBufferSubDataEXT));
[INFO] [stdout]       |                                              ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12561:49
[INFO] [stdout]       |
[INFO] [stdout] 12561 |          storage::NamedBufferSubDataEXT.aliased(&storage::NamedBufferSubData);
[INFO] [stdout]       |                                                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12561 |          storage::NamedBufferSubDataEXT.aliased(addr_of!(storage::NamedBufferSubData));
[INFO] [stdout]       |                                                 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12562:50
[INFO] [stdout]       |
[INFO] [stdout] 12562 |          storage::PauseTransformFeedback.aliased(&storage::PauseTransformFeedbackNV);
[INFO] [stdout]       |                                                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12562 |          storage::PauseTransformFeedback.aliased(addr_of!(storage::PauseTransformFeedbackNV));
[INFO] [stdout]       |                                                  ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12563:52
[INFO] [stdout]       |
[INFO] [stdout] 12563 |          storage::PauseTransformFeedbackNV.aliased(&storage::PauseTransformFeedback);
[INFO] [stdout]       |                                                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12563 |          storage::PauseTransformFeedbackNV.aliased(addr_of!(storage::PauseTransformFeedback));
[INFO] [stdout]       |                                                    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12564:43
[INFO] [stdout]       |
[INFO] [stdout] 12564 |          storage::PointParameterf.aliased(&storage::PointParameterfARB);
[INFO] [stdout]       |                                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12564 |          storage::PointParameterf.aliased(addr_of!(storage::PointParameterfARB));
[INFO] [stdout]       |                                           ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12565:43
[INFO] [stdout]       |
[INFO] [stdout] 12565 |          storage::PointParameterf.aliased(&storage::PointParameterfEXT);
[INFO] [stdout]       |                                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12565 |          storage::PointParameterf.aliased(addr_of!(storage::PointParameterfEXT));
[INFO] [stdout]       |                                           ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12566:43
[INFO] [stdout]       |
[INFO] [stdout] 12566 |          storage::PointParameterf.aliased(&storage::PointParameterfSGIS);
[INFO] [stdout]       |                                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12566 |          storage::PointParameterf.aliased(addr_of!(storage::PointParameterfSGIS));
[INFO] [stdout]       |                                           ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12567:46
[INFO] [stdout]       |
[INFO] [stdout] 12567 |          storage::PointParameterfARB.aliased(&storage::PointParameterf);
[INFO] [stdout]       |                                              ^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12567 |          storage::PointParameterfARB.aliased(addr_of!(storage::PointParameterf));
[INFO] [stdout]       |                                              ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12568:46
[INFO] [stdout]       |
[INFO] [stdout] 12568 |          storage::PointParameterfARB.aliased(&storage::PointParameterfEXT);
[INFO] [stdout]       |                                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12568 |          storage::PointParameterfARB.aliased(addr_of!(storage::PointParameterfEXT));
[INFO] [stdout]       |                                              ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12569:46
[INFO] [stdout]       |
[INFO] [stdout] 12569 |          storage::PointParameterfARB.aliased(&storage::PointParameterfSGIS);
[INFO] [stdout]       |                                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12569 |          storage::PointParameterfARB.aliased(addr_of!(storage::PointParameterfSGIS));
[INFO] [stdout]       |                                              ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12570:46
[INFO] [stdout]       |
[INFO] [stdout] 12570 |          storage::PointParameterfEXT.aliased(&storage::PointParameterf);
[INFO] [stdout]       |                                              ^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12570 |          storage::PointParameterfEXT.aliased(addr_of!(storage::PointParameterf));
[INFO] [stdout]       |                                              ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12571:46
[INFO] [stdout]       |
[INFO] [stdout] 12571 |          storage::PointParameterfEXT.aliased(&storage::PointParameterfARB);
[INFO] [stdout]       |                                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12571 |          storage::PointParameterfEXT.aliased(addr_of!(storage::PointParameterfARB));
[INFO] [stdout]       |                                              ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12572:46
[INFO] [stdout]       |
[INFO] [stdout] 12572 |          storage::PointParameterfEXT.aliased(&storage::PointParameterfSGIS);
[INFO] [stdout]       |                                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12572 |          storage::PointParameterfEXT.aliased(addr_of!(storage::PointParameterfSGIS));
[INFO] [stdout]       |                                              ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12573:47
[INFO] [stdout]       |
[INFO] [stdout] 12573 |          storage::PointParameterfSGIS.aliased(&storage::PointParameterf);
[INFO] [stdout]       |                                               ^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12573 |          storage::PointParameterfSGIS.aliased(addr_of!(storage::PointParameterf));
[INFO] [stdout]       |                                               ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12574:47
[INFO] [stdout]       |
[INFO] [stdout] 12574 |          storage::PointParameterfSGIS.aliased(&storage::PointParameterfARB);
[INFO] [stdout]       |                                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12574 |          storage::PointParameterfSGIS.aliased(addr_of!(storage::PointParameterfARB));
[INFO] [stdout]       |                                               ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12575:47
[INFO] [stdout]       |
[INFO] [stdout] 12575 |          storage::PointParameterfSGIS.aliased(&storage::PointParameterfEXT);
[INFO] [stdout]       |                                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12575 |          storage::PointParameterfSGIS.aliased(addr_of!(storage::PointParameterfEXT));
[INFO] [stdout]       |                                               ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12576:44
[INFO] [stdout]       |
[INFO] [stdout] 12576 |          storage::PointParameterfv.aliased(&storage::PointParameterfvARB);
[INFO] [stdout]       |                                            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12576 |          storage::PointParameterfv.aliased(addr_of!(storage::PointParameterfvARB));
[INFO] [stdout]       |                                            ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12577:44
[INFO] [stdout]       |
[INFO] [stdout] 12577 |          storage::PointParameterfv.aliased(&storage::PointParameterfvEXT);
[INFO] [stdout]       |                                            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12577 |          storage::PointParameterfv.aliased(addr_of!(storage::PointParameterfvEXT));
[INFO] [stdout]       |                                            ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12578:44
[INFO] [stdout]       |
[INFO] [stdout] 12578 |          storage::PointParameterfv.aliased(&storage::PointParameterfvSGIS);
[INFO] [stdout]       |                                            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12578 |          storage::PointParameterfv.aliased(addr_of!(storage::PointParameterfvSGIS));
[INFO] [stdout]       |                                            ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12579:47
[INFO] [stdout]       |
[INFO] [stdout] 12579 |          storage::PointParameterfvARB.aliased(&storage::PointParameterfv);
[INFO] [stdout]       |                                               ^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12579 |          storage::PointParameterfvARB.aliased(addr_of!(storage::PointParameterfv));
[INFO] [stdout]       |                                               ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12580:47
[INFO] [stdout]       |
[INFO] [stdout] 12580 |          storage::PointParameterfvARB.aliased(&storage::PointParameterfvEXT);
[INFO] [stdout]       |                                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12580 |          storage::PointParameterfvARB.aliased(addr_of!(storage::PointParameterfvEXT));
[INFO] [stdout]       |                                               ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12581:47
[INFO] [stdout]       |
[INFO] [stdout] 12581 |          storage::PointParameterfvARB.aliased(&storage::PointParameterfvSGIS);
[INFO] [stdout]       |                                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12581 |          storage::PointParameterfvARB.aliased(addr_of!(storage::PointParameterfvSGIS));
[INFO] [stdout]       |                                               ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12582:47
[INFO] [stdout]       |
[INFO] [stdout] 12582 |          storage::PointParameterfvEXT.aliased(&storage::PointParameterfv);
[INFO] [stdout]       |                                               ^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12582 |          storage::PointParameterfvEXT.aliased(addr_of!(storage::PointParameterfv));
[INFO] [stdout]       |                                               ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12583:47
[INFO] [stdout]       |
[INFO] [stdout] 12583 |          storage::PointParameterfvEXT.aliased(&storage::PointParameterfvARB);
[INFO] [stdout]       |                                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12583 |          storage::PointParameterfvEXT.aliased(addr_of!(storage::PointParameterfvARB));
[INFO] [stdout]       |                                               ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12584:47
[INFO] [stdout]       |
[INFO] [stdout] 12584 |          storage::PointParameterfvEXT.aliased(&storage::PointParameterfvSGIS);
[INFO] [stdout]       |                                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12584 |          storage::PointParameterfvEXT.aliased(addr_of!(storage::PointParameterfvSGIS));
[INFO] [stdout]       |                                               ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12585:48
[INFO] [stdout]       |
[INFO] [stdout] 12585 |          storage::PointParameterfvSGIS.aliased(&storage::PointParameterfv);
[INFO] [stdout]       |                                                ^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12585 |          storage::PointParameterfvSGIS.aliased(addr_of!(storage::PointParameterfv));
[INFO] [stdout]       |                                                ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12586:48
[INFO] [stdout]       |
[INFO] [stdout] 12586 |          storage::PointParameterfvSGIS.aliased(&storage::PointParameterfvARB);
[INFO] [stdout]       |                                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12586 |          storage::PointParameterfvSGIS.aliased(addr_of!(storage::PointParameterfvARB));
[INFO] [stdout]       |                                                ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12587:48
[INFO] [stdout]       |
[INFO] [stdout] 12587 |          storage::PointParameterfvSGIS.aliased(&storage::PointParameterfvEXT);
[INFO] [stdout]       |                                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12587 |          storage::PointParameterfvSGIS.aliased(addr_of!(storage::PointParameterfvEXT));
[INFO] [stdout]       |                                                ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12588:43
[INFO] [stdout]       |
[INFO] [stdout] 12588 |          storage::PointParameteri.aliased(&storage::PointParameteriNV);
[INFO] [stdout]       |                                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12588 |          storage::PointParameteri.aliased(addr_of!(storage::PointParameteriNV));
[INFO] [stdout]       |                                           ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12589:45
[INFO] [stdout]       |
[INFO] [stdout] 12589 |          storage::PointParameteriNV.aliased(&storage::PointParameteri);
[INFO] [stdout]       |                                             ^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12589 |          storage::PointParameteriNV.aliased(addr_of!(storage::PointParameteri));
[INFO] [stdout]       |                                             ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12590:44
[INFO] [stdout]       |
[INFO] [stdout] 12590 |          storage::PointParameteriv.aliased(&storage::PointParameterivNV);
[INFO] [stdout]       |                                            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12590 |          storage::PointParameteriv.aliased(addr_of!(storage::PointParameterivNV));
[INFO] [stdout]       |                                            ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12591:46
[INFO] [stdout]       |
[INFO] [stdout] 12591 |          storage::PointParameterivNV.aliased(&storage::PointParameteriv);
[INFO] [stdout]       |                                              ^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12591 |          storage::PointParameterivNV.aliased(addr_of!(storage::PointParameteriv));
[INFO] [stdout]       |                                              ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12592:46
[INFO] [stdout]       |
[INFO] [stdout] 12592 |          storage::PolygonOffsetClamp.aliased(&storage::PolygonOffsetClampEXT);
[INFO] [stdout]       |                                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12592 |          storage::PolygonOffsetClamp.aliased(addr_of!(storage::PolygonOffsetClampEXT));
[INFO] [stdout]       |                                              ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12593:49
[INFO] [stdout]       |
[INFO] [stdout] 12593 |          storage::PolygonOffsetClampEXT.aliased(&storage::PolygonOffsetClamp);
[INFO] [stdout]       |                                                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12593 |          storage::PolygonOffsetClampEXT.aliased(addr_of!(storage::PolygonOffsetClamp));
[INFO] [stdout]       |                                                 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12594:45
[INFO] [stdout]       |
[INFO] [stdout] 12594 |          storage::ProgramParameteri.aliased(&storage::ProgramParameteriARB);
[INFO] [stdout]       |                                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12594 |          storage::ProgramParameteri.aliased(addr_of!(storage::ProgramParameteriARB));
[INFO] [stdout]       |                                             ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12595:45
[INFO] [stdout]       |
[INFO] [stdout] 12595 |          storage::ProgramParameteri.aliased(&storage::ProgramParameteriEXT);
[INFO] [stdout]       |                                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12595 |          storage::ProgramParameteri.aliased(addr_of!(storage::ProgramParameteriEXT));
[INFO] [stdout]       |                                             ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12596:48
[INFO] [stdout]       |
[INFO] [stdout] 12596 |          storage::ProgramParameteriARB.aliased(&storage::ProgramParameteri);
[INFO] [stdout]       |                                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12596 |          storage::ProgramParameteriARB.aliased(addr_of!(storage::ProgramParameteri));
[INFO] [stdout]       |                                                ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12597:48
[INFO] [stdout]       |
[INFO] [stdout] 12597 |          storage::ProgramParameteriARB.aliased(&storage::ProgramParameteriEXT);
[INFO] [stdout]       |                                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12597 |          storage::ProgramParameteriARB.aliased(addr_of!(storage::ProgramParameteriEXT));
[INFO] [stdout]       |                                                ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12598:48
[INFO] [stdout]       |
[INFO] [stdout] 12598 |          storage::ProgramParameteriEXT.aliased(&storage::ProgramParameteri);
[INFO] [stdout]       |                                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12598 |          storage::ProgramParameteriEXT.aliased(addr_of!(storage::ProgramParameteri));
[INFO] [stdout]       |                                                ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12599:48
[INFO] [stdout]       |
[INFO] [stdout] 12599 |          storage::ProgramParameteriEXT.aliased(&storage::ProgramParameteriARB);
[INFO] [stdout]       |                                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12599 |          storage::ProgramParameteriEXT.aliased(addr_of!(storage::ProgramParameteriARB));
[INFO] [stdout]       |                                                ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12600:44
[INFO] [stdout]       |
[INFO] [stdout] 12600 |          storage::ProgramUniform1f.aliased(&storage::ProgramUniform1fEXT);
[INFO] [stdout]       |                                            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12600 |          storage::ProgramUniform1f.aliased(addr_of!(storage::ProgramUniform1fEXT));
[INFO] [stdout]       |                                            ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12601:47
[INFO] [stdout]       |
[INFO] [stdout] 12601 |          storage::ProgramUniform1fEXT.aliased(&storage::ProgramUniform1f);
[INFO] [stdout]       |                                               ^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12601 |          storage::ProgramUniform1fEXT.aliased(addr_of!(storage::ProgramUniform1f));
[INFO] [stdout]       |                                               ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12602:45
[INFO] [stdout]       |
[INFO] [stdout] 12602 |          storage::ProgramUniform1fv.aliased(&storage::ProgramUniform1fvEXT);
[INFO] [stdout]       |                                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12602 |          storage::ProgramUniform1fv.aliased(addr_of!(storage::ProgramUniform1fvEXT));
[INFO] [stdout]       |                                             ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12603:48
[INFO] [stdout]       |
[INFO] [stdout] 12603 |          storage::ProgramUniform1fvEXT.aliased(&storage::ProgramUniform1fv);
[INFO] [stdout]       |                                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12603 |          storage::ProgramUniform1fvEXT.aliased(addr_of!(storage::ProgramUniform1fv));
[INFO] [stdout]       |                                                ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12604:44
[INFO] [stdout]       |
[INFO] [stdout] 12604 |          storage::ProgramUniform1i.aliased(&storage::ProgramUniform1iEXT);
[INFO] [stdout]       |                                            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12604 |          storage::ProgramUniform1i.aliased(addr_of!(storage::ProgramUniform1iEXT));
[INFO] [stdout]       |                                            ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12605:47
[INFO] [stdout]       |
[INFO] [stdout] 12605 |          storage::ProgramUniform1iEXT.aliased(&storage::ProgramUniform1i);
[INFO] [stdout]       |                                               ^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12605 |          storage::ProgramUniform1iEXT.aliased(addr_of!(storage::ProgramUniform1i));
[INFO] [stdout]       |                                               ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12606:45
[INFO] [stdout]       |
[INFO] [stdout] 12606 |          storage::ProgramUniform1iv.aliased(&storage::ProgramUniform1ivEXT);
[INFO] [stdout]       |                                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12606 |          storage::ProgramUniform1iv.aliased(addr_of!(storage::ProgramUniform1ivEXT));
[INFO] [stdout]       |                                             ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12607:48
[INFO] [stdout]       |
[INFO] [stdout] 12607 |          storage::ProgramUniform1ivEXT.aliased(&storage::ProgramUniform1iv);
[INFO] [stdout]       |                                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12607 |          storage::ProgramUniform1ivEXT.aliased(addr_of!(storage::ProgramUniform1iv));
[INFO] [stdout]       |                                                ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12608:45
[INFO] [stdout]       |
[INFO] [stdout] 12608 |          storage::ProgramUniform1ui.aliased(&storage::ProgramUniform1uiEXT);
[INFO] [stdout]       |                                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12608 |          storage::ProgramUniform1ui.aliased(addr_of!(storage::ProgramUniform1uiEXT));
[INFO] [stdout]       |                                             ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12609:48
[INFO] [stdout]       |
[INFO] [stdout] 12609 |          storage::ProgramUniform1uiEXT.aliased(&storage::ProgramUniform1ui);
[INFO] [stdout]       |                                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12609 |          storage::ProgramUniform1uiEXT.aliased(addr_of!(storage::ProgramUniform1ui));
[INFO] [stdout]       |                                                ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12610:46
[INFO] [stdout]       |
[INFO] [stdout] 12610 |          storage::ProgramUniform1uiv.aliased(&storage::ProgramUniform1uivEXT);
[INFO] [stdout]       |                                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12610 |          storage::ProgramUniform1uiv.aliased(addr_of!(storage::ProgramUniform1uivEXT));
[INFO] [stdout]       |                                              ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12611:49
[INFO] [stdout]       |
[INFO] [stdout] 12611 |          storage::ProgramUniform1uivEXT.aliased(&storage::ProgramUniform1uiv);
[INFO] [stdout]       |                                                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12611 |          storage::ProgramUniform1uivEXT.aliased(addr_of!(storage::ProgramUniform1uiv));
[INFO] [stdout]       |                                                 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12612:44
[INFO] [stdout]       |
[INFO] [stdout] 12612 |          storage::ProgramUniform2f.aliased(&storage::ProgramUniform2fEXT);
[INFO] [stdout]       |                                            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12612 |          storage::ProgramUniform2f.aliased(addr_of!(storage::ProgramUniform2fEXT));
[INFO] [stdout]       |                                            ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12613:47
[INFO] [stdout]       |
[INFO] [stdout] 12613 |          storage::ProgramUniform2fEXT.aliased(&storage::ProgramUniform2f);
[INFO] [stdout]       |                                               ^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12613 |          storage::ProgramUniform2fEXT.aliased(addr_of!(storage::ProgramUniform2f));
[INFO] [stdout]       |                                               ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12614:45
[INFO] [stdout]       |
[INFO] [stdout] 12614 |          storage::ProgramUniform2fv.aliased(&storage::ProgramUniform2fvEXT);
[INFO] [stdout]       |                                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12614 |          storage::ProgramUniform2fv.aliased(addr_of!(storage::ProgramUniform2fvEXT));
[INFO] [stdout]       |                                             ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12615:48
[INFO] [stdout]       |
[INFO] [stdout] 12615 |          storage::ProgramUniform2fvEXT.aliased(&storage::ProgramUniform2fv);
[INFO] [stdout]       |                                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12615 |          storage::ProgramUniform2fvEXT.aliased(addr_of!(storage::ProgramUniform2fv));
[INFO] [stdout]       |                                                ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12616:44
[INFO] [stdout]       |
[INFO] [stdout] 12616 |          storage::ProgramUniform2i.aliased(&storage::ProgramUniform2iEXT);
[INFO] [stdout]       |                                            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12616 |          storage::ProgramUniform2i.aliased(addr_of!(storage::ProgramUniform2iEXT));
[INFO] [stdout]       |                                            ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12617:47
[INFO] [stdout]       |
[INFO] [stdout] 12617 |          storage::ProgramUniform2iEXT.aliased(&storage::ProgramUniform2i);
[INFO] [stdout]       |                                               ^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12617 |          storage::ProgramUniform2iEXT.aliased(addr_of!(storage::ProgramUniform2i));
[INFO] [stdout]       |                                               ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12618:45
[INFO] [stdout]       |
[INFO] [stdout] 12618 |          storage::ProgramUniform2iv.aliased(&storage::ProgramUniform2ivEXT);
[INFO] [stdout]       |                                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12618 |          storage::ProgramUniform2iv.aliased(addr_of!(storage::ProgramUniform2ivEXT));
[INFO] [stdout]       |                                             ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12619:48
[INFO] [stdout]       |
[INFO] [stdout] 12619 |          storage::ProgramUniform2ivEXT.aliased(&storage::ProgramUniform2iv);
[INFO] [stdout]       |                                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12619 |          storage::ProgramUniform2ivEXT.aliased(addr_of!(storage::ProgramUniform2iv));
[INFO] [stdout]       |                                                ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12620:45
[INFO] [stdout]       |
[INFO] [stdout] 12620 |          storage::ProgramUniform2ui.aliased(&storage::ProgramUniform2uiEXT);
[INFO] [stdout]       |                                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12620 |          storage::ProgramUniform2ui.aliased(addr_of!(storage::ProgramUniform2uiEXT));
[INFO] [stdout]       |                                             ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12621:48
[INFO] [stdout]       |
[INFO] [stdout] 12621 |          storage::ProgramUniform2uiEXT.aliased(&storage::ProgramUniform2ui);
[INFO] [stdout]       |                                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12621 |          storage::ProgramUniform2uiEXT.aliased(addr_of!(storage::ProgramUniform2ui));
[INFO] [stdout]       |                                                ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12622:46
[INFO] [stdout]       |
[INFO] [stdout] 12622 |          storage::ProgramUniform2uiv.aliased(&storage::ProgramUniform2uivEXT);
[INFO] [stdout]       |                                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12622 |          storage::ProgramUniform2uiv.aliased(addr_of!(storage::ProgramUniform2uivEXT));
[INFO] [stdout]       |                                              ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12623:49
[INFO] [stdout]       |
[INFO] [stdout] 12623 |          storage::ProgramUniform2uivEXT.aliased(&storage::ProgramUniform2uiv);
[INFO] [stdout]       |                                                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12623 |          storage::ProgramUniform2uivEXT.aliased(addr_of!(storage::ProgramUniform2uiv));
[INFO] [stdout]       |                                                 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12624:44
[INFO] [stdout]       |
[INFO] [stdout] 12624 |          storage::ProgramUniform3f.aliased(&storage::ProgramUniform3fEXT);
[INFO] [stdout]       |                                            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12624 |          storage::ProgramUniform3f.aliased(addr_of!(storage::ProgramUniform3fEXT));
[INFO] [stdout]       |                                            ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12625:47
[INFO] [stdout]       |
[INFO] [stdout] 12625 |          storage::ProgramUniform3fEXT.aliased(&storage::ProgramUniform3f);
[INFO] [stdout]       |                                               ^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12625 |          storage::ProgramUniform3fEXT.aliased(addr_of!(storage::ProgramUniform3f));
[INFO] [stdout]       |                                               ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12626:45
[INFO] [stdout]       |
[INFO] [stdout] 12626 |          storage::ProgramUniform3fv.aliased(&storage::ProgramUniform3fvEXT);
[INFO] [stdout]       |                                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12626 |          storage::ProgramUniform3fv.aliased(addr_of!(storage::ProgramUniform3fvEXT));
[INFO] [stdout]       |                                             ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12627:48
[INFO] [stdout]       |
[INFO] [stdout] 12627 |          storage::ProgramUniform3fvEXT.aliased(&storage::ProgramUniform3fv);
[INFO] [stdout]       |                                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12627 |          storage::ProgramUniform3fvEXT.aliased(addr_of!(storage::ProgramUniform3fv));
[INFO] [stdout]       |                                                ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12628:44
[INFO] [stdout]       |
[INFO] [stdout] 12628 |          storage::ProgramUniform3i.aliased(&storage::ProgramUniform3iEXT);
[INFO] [stdout]       |                                            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12628 |          storage::ProgramUniform3i.aliased(addr_of!(storage::ProgramUniform3iEXT));
[INFO] [stdout]       |                                            ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12629:47
[INFO] [stdout]       |
[INFO] [stdout] 12629 |          storage::ProgramUniform3iEXT.aliased(&storage::ProgramUniform3i);
[INFO] [stdout]       |                                               ^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12629 |          storage::ProgramUniform3iEXT.aliased(addr_of!(storage::ProgramUniform3i));
[INFO] [stdout]       |                                               ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12630:45
[INFO] [stdout]       |
[INFO] [stdout] 12630 |          storage::ProgramUniform3iv.aliased(&storage::ProgramUniform3ivEXT);
[INFO] [stdout]       |                                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12630 |          storage::ProgramUniform3iv.aliased(addr_of!(storage::ProgramUniform3ivEXT));
[INFO] [stdout]       |                                             ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12631:48
[INFO] [stdout]       |
[INFO] [stdout] 12631 |          storage::ProgramUniform3ivEXT.aliased(&storage::ProgramUniform3iv);
[INFO] [stdout]       |                                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12631 |          storage::ProgramUniform3ivEXT.aliased(addr_of!(storage::ProgramUniform3iv));
[INFO] [stdout]       |                                                ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12632:45
[INFO] [stdout]       |
[INFO] [stdout] 12632 |          storage::ProgramUniform3ui.aliased(&storage::ProgramUniform3uiEXT);
[INFO] [stdout]       |                                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12632 |          storage::ProgramUniform3ui.aliased(addr_of!(storage::ProgramUniform3uiEXT));
[INFO] [stdout]       |                                             ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12633:48
[INFO] [stdout]       |
[INFO] [stdout] 12633 |          storage::ProgramUniform3uiEXT.aliased(&storage::ProgramUniform3ui);
[INFO] [stdout]       |                                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12633 |          storage::ProgramUniform3uiEXT.aliased(addr_of!(storage::ProgramUniform3ui));
[INFO] [stdout]       |                                                ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12634:46
[INFO] [stdout]       |
[INFO] [stdout] 12634 |          storage::ProgramUniform3uiv.aliased(&storage::ProgramUniform3uivEXT);
[INFO] [stdout]       |                                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12634 |          storage::ProgramUniform3uiv.aliased(addr_of!(storage::ProgramUniform3uivEXT));
[INFO] [stdout]       |                                              ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12635:49
[INFO] [stdout]       |
[INFO] [stdout] 12635 |          storage::ProgramUniform3uivEXT.aliased(&storage::ProgramUniform3uiv);
[INFO] [stdout]       |                                                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12635 |          storage::ProgramUniform3uivEXT.aliased(addr_of!(storage::ProgramUniform3uiv));
[INFO] [stdout]       |                                                 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12636:44
[INFO] [stdout]       |
[INFO] [stdout] 12636 |          storage::ProgramUniform4f.aliased(&storage::ProgramUniform4fEXT);
[INFO] [stdout]       |                                            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12636 |          storage::ProgramUniform4f.aliased(addr_of!(storage::ProgramUniform4fEXT));
[INFO] [stdout]       |                                            ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12637:47
[INFO] [stdout]       |
[INFO] [stdout] 12637 |          storage::ProgramUniform4fEXT.aliased(&storage::ProgramUniform4f);
[INFO] [stdout]       |                                               ^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12637 |          storage::ProgramUniform4fEXT.aliased(addr_of!(storage::ProgramUniform4f));
[INFO] [stdout]       |                                               ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12638:45
[INFO] [stdout]       |
[INFO] [stdout] 12638 |          storage::ProgramUniform4fv.aliased(&storage::ProgramUniform4fvEXT);
[INFO] [stdout]       |                                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12638 |          storage::ProgramUniform4fv.aliased(addr_of!(storage::ProgramUniform4fvEXT));
[INFO] [stdout]       |                                             ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12639:48
[INFO] [stdout]       |
[INFO] [stdout] 12639 |          storage::ProgramUniform4fvEXT.aliased(&storage::ProgramUniform4fv);
[INFO] [stdout]       |                                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12639 |          storage::ProgramUniform4fvEXT.aliased(addr_of!(storage::ProgramUniform4fv));
[INFO] [stdout]       |                                                ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12640:44
[INFO] [stdout]       |
[INFO] [stdout] 12640 |          storage::ProgramUniform4i.aliased(&storage::ProgramUniform4iEXT);
[INFO] [stdout]       |                                            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12640 |          storage::ProgramUniform4i.aliased(addr_of!(storage::ProgramUniform4iEXT));
[INFO] [stdout]       |                                            ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12641:47
[INFO] [stdout]       |
[INFO] [stdout] 12641 |          storage::ProgramUniform4iEXT.aliased(&storage::ProgramUniform4i);
[INFO] [stdout]       |                                               ^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12641 |          storage::ProgramUniform4iEXT.aliased(addr_of!(storage::ProgramUniform4i));
[INFO] [stdout]       |                                               ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12642:45
[INFO] [stdout]       |
[INFO] [stdout] 12642 |          storage::ProgramUniform4iv.aliased(&storage::ProgramUniform4ivEXT);
[INFO] [stdout]       |                                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12642 |          storage::ProgramUniform4iv.aliased(addr_of!(storage::ProgramUniform4ivEXT));
[INFO] [stdout]       |                                             ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12643:48
[INFO] [stdout]       |
[INFO] [stdout] 12643 |          storage::ProgramUniform4ivEXT.aliased(&storage::ProgramUniform4iv);
[INFO] [stdout]       |                                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12643 |          storage::ProgramUniform4ivEXT.aliased(addr_of!(storage::ProgramUniform4iv));
[INFO] [stdout]       |                                                ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12644:45
[INFO] [stdout]       |
[INFO] [stdout] 12644 |          storage::ProgramUniform4ui.aliased(&storage::ProgramUniform4uiEXT);
[INFO] [stdout]       |                                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12644 |          storage::ProgramUniform4ui.aliased(addr_of!(storage::ProgramUniform4uiEXT));
[INFO] [stdout]       |                                             ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12645:48
[INFO] [stdout]       |
[INFO] [stdout] 12645 |          storage::ProgramUniform4uiEXT.aliased(&storage::ProgramUniform4ui);
[INFO] [stdout]       |                                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12645 |          storage::ProgramUniform4uiEXT.aliased(addr_of!(storage::ProgramUniform4ui));
[INFO] [stdout]       |                                                ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12646:46
[INFO] [stdout]       |
[INFO] [stdout] 12646 |          storage::ProgramUniform4uiv.aliased(&storage::ProgramUniform4uivEXT);
[INFO] [stdout]       |                                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12646 |          storage::ProgramUniform4uiv.aliased(addr_of!(storage::ProgramUniform4uivEXT));
[INFO] [stdout]       |                                              ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12647:49
[INFO] [stdout]       |
[INFO] [stdout] 12647 |          storage::ProgramUniform4uivEXT.aliased(&storage::ProgramUniform4uiv);
[INFO] [stdout]       |                                                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12647 |          storage::ProgramUniform4uivEXT.aliased(addr_of!(storage::ProgramUniform4uiv));
[INFO] [stdout]       |                                                 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12648:51
[INFO] [stdout]       |
[INFO] [stdout] 12648 |          storage::ProgramUniformMatrix2fv.aliased(&storage::ProgramUniformMatrix2fvEXT);
[INFO] [stdout]       |                                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12648 |          storage::ProgramUniformMatrix2fv.aliased(addr_of!(storage::ProgramUniformMatrix2fvEXT));
[INFO] [stdout]       |                                                   ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12649:54
[INFO] [stdout]       |
[INFO] [stdout] 12649 |          storage::ProgramUniformMatrix2fvEXT.aliased(&storage::ProgramUniformMatrix2fv);
[INFO] [stdout]       |                                                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12649 |          storage::ProgramUniformMatrix2fvEXT.aliased(addr_of!(storage::ProgramUniformMatrix2fv));
[INFO] [stdout]       |                                                      ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12650:53
[INFO] [stdout]       |
[INFO] [stdout] 12650 |          storage::ProgramUniformMatrix2x3fv.aliased(&storage::ProgramUniformMatrix2x3fvEXT);
[INFO] [stdout]       |                                                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12650 |          storage::ProgramUniformMatrix2x3fv.aliased(addr_of!(storage::ProgramUniformMatrix2x3fvEXT));
[INFO] [stdout]       |                                                     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12651:56
[INFO] [stdout]       |
[INFO] [stdout] 12651 |          storage::ProgramUniformMatrix2x3fvEXT.aliased(&storage::ProgramUniformMatrix2x3fv);
[INFO] [stdout]       |                                                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12651 |          storage::ProgramUniformMatrix2x3fvEXT.aliased(addr_of!(storage::ProgramUniformMatrix2x3fv));
[INFO] [stdout]       |                                                        ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12652:53
[INFO] [stdout]       |
[INFO] [stdout] 12652 |          storage::ProgramUniformMatrix2x4fv.aliased(&storage::ProgramUniformMatrix2x4fvEXT);
[INFO] [stdout]       |                                                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12652 |          storage::ProgramUniformMatrix2x4fv.aliased(addr_of!(storage::ProgramUniformMatrix2x4fvEXT));
[INFO] [stdout]       |                                                     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12653:56
[INFO] [stdout]       |
[INFO] [stdout] 12653 |          storage::ProgramUniformMatrix2x4fvEXT.aliased(&storage::ProgramUniformMatrix2x4fv);
[INFO] [stdout]       |                                                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12653 |          storage::ProgramUniformMatrix2x4fvEXT.aliased(addr_of!(storage::ProgramUniformMatrix2x4fv));
[INFO] [stdout]       |                                                        ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12654:51
[INFO] [stdout]       |
[INFO] [stdout] 12654 |          storage::ProgramUniformMatrix3fv.aliased(&storage::ProgramUniformMatrix3fvEXT);
[INFO] [stdout]       |                                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12654 |          storage::ProgramUniformMatrix3fv.aliased(addr_of!(storage::ProgramUniformMatrix3fvEXT));
[INFO] [stdout]       |                                                   ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12655:54
[INFO] [stdout]       |
[INFO] [stdout] 12655 |          storage::ProgramUniformMatrix3fvEXT.aliased(&storage::ProgramUniformMatrix3fv);
[INFO] [stdout]       |                                                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12655 |          storage::ProgramUniformMatrix3fvEXT.aliased(addr_of!(storage::ProgramUniformMatrix3fv));
[INFO] [stdout]       |                                                      ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12656:53
[INFO] [stdout]       |
[INFO] [stdout] 12656 |          storage::ProgramUniformMatrix3x2fv.aliased(&storage::ProgramUniformMatrix3x2fvEXT);
[INFO] [stdout]       |                                                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12656 |          storage::ProgramUniformMatrix3x2fv.aliased(addr_of!(storage::ProgramUniformMatrix3x2fvEXT));
[INFO] [stdout]       |                                                     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12657:56
[INFO] [stdout]       |
[INFO] [stdout] 12657 |          storage::ProgramUniformMatrix3x2fvEXT.aliased(&storage::ProgramUniformMatrix3x2fv);
[INFO] [stdout]       |                                                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12657 |          storage::ProgramUniformMatrix3x2fvEXT.aliased(addr_of!(storage::ProgramUniformMatrix3x2fv));
[INFO] [stdout]       |                                                        ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12658:53
[INFO] [stdout]       |
[INFO] [stdout] 12658 |          storage::ProgramUniformMatrix3x4fv.aliased(&storage::ProgramUniformMatrix3x4fvEXT);
[INFO] [stdout]       |                                                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12658 |          storage::ProgramUniformMatrix3x4fv.aliased(addr_of!(storage::ProgramUniformMatrix3x4fvEXT));
[INFO] [stdout]       |                                                     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12659:56
[INFO] [stdout]       |
[INFO] [stdout] 12659 |          storage::ProgramUniformMatrix3x4fvEXT.aliased(&storage::ProgramUniformMatrix3x4fv);
[INFO] [stdout]       |                                                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12659 |          storage::ProgramUniformMatrix3x4fvEXT.aliased(addr_of!(storage::ProgramUniformMatrix3x4fv));
[INFO] [stdout]       |                                                        ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12660:51
[INFO] [stdout]       |
[INFO] [stdout] 12660 |          storage::ProgramUniformMatrix4fv.aliased(&storage::ProgramUniformMatrix4fvEXT);
[INFO] [stdout]       |                                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12660 |          storage::ProgramUniformMatrix4fv.aliased(addr_of!(storage::ProgramUniformMatrix4fvEXT));
[INFO] [stdout]       |                                                   ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12661:54
[INFO] [stdout]       |
[INFO] [stdout] 12661 |          storage::ProgramUniformMatrix4fvEXT.aliased(&storage::ProgramUniformMatrix4fv);
[INFO] [stdout]       |                                                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12661 |          storage::ProgramUniformMatrix4fvEXT.aliased(addr_of!(storage::ProgramUniformMatrix4fv));
[INFO] [stdout]       |                                                      ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12662:53
[INFO] [stdout]       |
[INFO] [stdout] 12662 |          storage::ProgramUniformMatrix4x2fv.aliased(&storage::ProgramUniformMatrix4x2fvEXT);
[INFO] [stdout]       |                                                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12662 |          storage::ProgramUniformMatrix4x2fv.aliased(addr_of!(storage::ProgramUniformMatrix4x2fvEXT));
[INFO] [stdout]       |                                                     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12663:56
[INFO] [stdout]       |
[INFO] [stdout] 12663 |          storage::ProgramUniformMatrix4x2fvEXT.aliased(&storage::ProgramUniformMatrix4x2fv);
[INFO] [stdout]       |                                                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12663 |          storage::ProgramUniformMatrix4x2fvEXT.aliased(addr_of!(storage::ProgramUniformMatrix4x2fv));
[INFO] [stdout]       |                                                        ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12664:53
[INFO] [stdout]       |
[INFO] [stdout] 12664 |          storage::ProgramUniformMatrix4x3fv.aliased(&storage::ProgramUniformMatrix4x3fvEXT);
[INFO] [stdout]       |                                                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12664 |          storage::ProgramUniformMatrix4x3fv.aliased(addr_of!(storage::ProgramUniformMatrix4x3fvEXT));
[INFO] [stdout]       |                                                     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12665:56
[INFO] [stdout]       |
[INFO] [stdout] 12665 |          storage::ProgramUniformMatrix4x3fvEXT.aliased(&storage::ProgramUniformMatrix4x3fv);
[INFO] [stdout]       |                                                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12665 |          storage::ProgramUniformMatrix4x3fvEXT.aliased(addr_of!(storage::ProgramUniformMatrix4x3fv));
[INFO] [stdout]       |                                                        ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12666:43
[INFO] [stdout]       |
[INFO] [stdout] 12666 |          storage::ProvokingVertex.aliased(&storage::ProvokingVertexEXT);
[INFO] [stdout]       |                                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12666 |          storage::ProvokingVertex.aliased(addr_of!(storage::ProvokingVertexEXT));
[INFO] [stdout]       |                                           ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12667:46
[INFO] [stdout]       |
[INFO] [stdout] 12667 |          storage::ProvokingVertexEXT.aliased(&storage::ProvokingVertex);
[INFO] [stdout]       |                                              ^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12667 |          storage::ProvokingVertexEXT.aliased(addr_of!(storage::ProvokingVertex));
[INFO] [stdout]       |                                              ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12668:39
[INFO] [stdout]       |
[INFO] [stdout] 12668 |          storage::ReadnPixels.aliased(&storage::ReadnPixelsARB);
[INFO] [stdout]       |                                       ^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12668 |          storage::ReadnPixels.aliased(addr_of!(storage::ReadnPixelsARB));
[INFO] [stdout]       |                                       ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12669:42
[INFO] [stdout]       |
[INFO] [stdout] 12669 |          storage::ReadnPixelsARB.aliased(&storage::ReadnPixels);
[INFO] [stdout]       |                                          ^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12669 |          storage::ReadnPixelsARB.aliased(addr_of!(storage::ReadnPixels));
[INFO] [stdout]       |                                          ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12670:47
[INFO] [stdout]       |
[INFO] [stdout] 12670 |          storage::RenderbufferStorage.aliased(&storage::RenderbufferStorageEXT);
[INFO] [stdout]       |                                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12670 |          storage::RenderbufferStorage.aliased(addr_of!(storage::RenderbufferStorageEXT));
[INFO] [stdout]       |                                               ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12671:50
[INFO] [stdout]       |
[INFO] [stdout] 12671 |          storage::RenderbufferStorageEXT.aliased(&storage::RenderbufferStorage);
[INFO] [stdout]       |                                                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12671 |          storage::RenderbufferStorageEXT.aliased(addr_of!(storage::RenderbufferStorage));
[INFO] [stdout]       |                                                  ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12672:58
[INFO] [stdout]       |
[INFO] [stdout] 12672 |          storage::RenderbufferStorageMultisample.aliased(&storage::RenderbufferStorageMultisampleEXT);
[INFO] [stdout]       |                                                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12672 |          storage::RenderbufferStorageMultisample.aliased(addr_of!(storage::RenderbufferStorageMultisampleEXT));
[INFO] [stdout]       |                                                          ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12673:61
[INFO] [stdout]       |
[INFO] [stdout] 12673 |          storage::RenderbufferStorageMultisampleEXT.aliased(&storage::RenderbufferStorageMultisample);
[INFO] [stdout]       |                                                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12673 |          storage::RenderbufferStorageMultisampleEXT.aliased(addr_of!(storage::RenderbufferStorageMultisample));
[INFO] [stdout]       |                                                             ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12674:51
[INFO] [stdout]       |
[INFO] [stdout] 12674 |          storage::ResumeTransformFeedback.aliased(&storage::ResumeTransformFeedbackNV);
[INFO] [stdout]       |                                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12674 |          storage::ResumeTransformFeedback.aliased(addr_of!(storage::ResumeTransformFeedbackNV));
[INFO] [stdout]       |                                                   ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12675:53
[INFO] [stdout]       |
[INFO] [stdout] 12675 |          storage::ResumeTransformFeedbackNV.aliased(&storage::ResumeTransformFeedback);
[INFO] [stdout]       |                                                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12675 |          storage::ResumeTransformFeedbackNV.aliased(addr_of!(storage::ResumeTransformFeedback));
[INFO] [stdout]       |                                                     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12676:42
[INFO] [stdout]       |
[INFO] [stdout] 12676 |          storage::SampleCoverage.aliased(&storage::SampleCoverageARB);
[INFO] [stdout]       |                                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12676 |          storage::SampleCoverage.aliased(addr_of!(storage::SampleCoverageARB));
[INFO] [stdout]       |                                          ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12677:45
[INFO] [stdout]       |
[INFO] [stdout] 12677 |          storage::SampleCoverageARB.aliased(&storage::SampleCoverage);
[INFO] [stdout]       |                                             ^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12677 |          storage::SampleCoverageARB.aliased(addr_of!(storage::SampleCoverage));
[INFO] [stdout]       |                                             ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12678:41
[INFO] [stdout]       |
[INFO] [stdout] 12678 |          storage::SampleMaskEXT.aliased(&storage::SampleMaskSGIS);
[INFO] [stdout]       |                                         ^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12678 |          storage::SampleMaskEXT.aliased(addr_of!(storage::SampleMaskSGIS));
[INFO] [stdout]       |                                         ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12679:42
[INFO] [stdout]       |
[INFO] [stdout] 12679 |          storage::SampleMaskSGIS.aliased(&storage::SampleMaskEXT);
[INFO] [stdout]       |                                          ^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12679 |          storage::SampleMaskSGIS.aliased(addr_of!(storage::SampleMaskEXT));
[INFO] [stdout]       |                                          ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12680:44
[INFO] [stdout]       |
[INFO] [stdout] 12680 |          storage::SamplePatternEXT.aliased(&storage::SamplePatternSGIS);
[INFO] [stdout]       |                                            ^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12680 |          storage::SamplePatternEXT.aliased(addr_of!(storage::SamplePatternSGIS));
[INFO] [stdout]       |                                            ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12681:45
[INFO] [stdout]       |
[INFO] [stdout] 12681 |          storage::SamplePatternSGIS.aliased(&storage::SamplePatternEXT);
[INFO] [stdout]       |                                             ^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12681 |          storage::SamplePatternSGIS.aliased(addr_of!(storage::SamplePatternEXT));
[INFO] [stdout]       |                                             ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12682:40
[INFO] [stdout]       |
[INFO] [stdout] 12682 |          storage::ShaderSource.aliased(&storage::ShaderSourceARB);
[INFO] [stdout]       |                                        ^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12682 |          storage::ShaderSource.aliased(addr_of!(storage::ShaderSourceARB));
[INFO] [stdout]       |                                        ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12683:43
[INFO] [stdout]       |
[INFO] [stdout] 12683 |          storage::ShaderSourceARB.aliased(&storage::ShaderSource);
[INFO] [stdout]       |                                           ^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12683 |          storage::ShaderSourceARB.aliased(addr_of!(storage::ShaderSource));
[INFO] [stdout]       |                                           ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12684:45
[INFO] [stdout]       |
[INFO] [stdout] 12684 |          storage::StencilOpSeparate.aliased(&storage::StencilOpSeparateATI);
[INFO] [stdout]       |                                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12684 |          storage::StencilOpSeparate.aliased(addr_of!(storage::StencilOpSeparateATI));
[INFO] [stdout]       |                                             ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12685:48
[INFO] [stdout]       |
[INFO] [stdout] 12685 |          storage::StencilOpSeparateATI.aliased(&storage::StencilOpSeparate);
[INFO] [stdout]       |                                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12685 |          storage::StencilOpSeparateATI.aliased(addr_of!(storage::StencilOpSeparate));
[INFO] [stdout]       |                                                ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12686:37
[INFO] [stdout]       |
[INFO] [stdout] 12686 |          storage::TexBuffer.aliased(&storage::TexBufferARB);
[INFO] [stdout]       |                                     ^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12686 |          storage::TexBuffer.aliased(addr_of!(storage::TexBufferARB));
[INFO] [stdout]       |                                     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12687:37
[INFO] [stdout]       |
[INFO] [stdout] 12687 |          storage::TexBuffer.aliased(&storage::TexBufferEXT);
[INFO] [stdout]       |                                     ^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12687 |          storage::TexBuffer.aliased(addr_of!(storage::TexBufferEXT));
[INFO] [stdout]       |                                     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12688:40
[INFO] [stdout]       |
[INFO] [stdout] 12688 |          storage::TexBufferARB.aliased(&storage::TexBuffer);
[INFO] [stdout]       |                                        ^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12688 |          storage::TexBufferARB.aliased(addr_of!(storage::TexBuffer));
[INFO] [stdout]       |                                        ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12689:40
[INFO] [stdout]       |
[INFO] [stdout] 12689 |          storage::TexBufferARB.aliased(&storage::TexBufferEXT);
[INFO] [stdout]       |                                        ^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12689 |          storage::TexBufferARB.aliased(addr_of!(storage::TexBufferEXT));
[INFO] [stdout]       |                                        ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12690:40
[INFO] [stdout]       |
[INFO] [stdout] 12690 |          storage::TexBufferEXT.aliased(&storage::TexBuffer);
[INFO] [stdout]       |                                        ^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12690 |          storage::TexBufferEXT.aliased(addr_of!(storage::TexBuffer));
[INFO] [stdout]       |                                        ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12691:40
[INFO] [stdout]       |
[INFO] [stdout] 12691 |          storage::TexBufferEXT.aliased(&storage::TexBufferARB);
[INFO] [stdout]       |                                        ^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12691 |          storage::TexBufferEXT.aliased(addr_of!(storage::TexBufferARB));
[INFO] [stdout]       |                                        ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12692:38
[INFO] [stdout]       |
[INFO] [stdout] 12692 |          storage::TexImage3D.aliased(&storage::TexImage3DEXT);
[INFO] [stdout]       |                                      ^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12692 |          storage::TexImage3D.aliased(addr_of!(storage::TexImage3DEXT));
[INFO] [stdout]       |                                      ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12693:41
[INFO] [stdout]       |
[INFO] [stdout] 12693 |          storage::TexImage3DEXT.aliased(&storage::TexImage3D);
[INFO] [stdout]       |                                         ^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12693 |          storage::TexImage3DEXT.aliased(addr_of!(storage::TexImage3D));
[INFO] [stdout]       |                                         ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12694:43
[INFO] [stdout]       |
[INFO] [stdout] 12694 |          storage::TexParameterIiv.aliased(&storage::TexParameterIivEXT);
[INFO] [stdout]       |                                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12694 |          storage::TexParameterIiv.aliased(addr_of!(storage::TexParameterIivEXT));
[INFO] [stdout]       |                                           ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12695:46
[INFO] [stdout]       |
[INFO] [stdout] 12695 |          storage::TexParameterIivEXT.aliased(&storage::TexParameterIiv);
[INFO] [stdout]       |                                              ^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12695 |          storage::TexParameterIivEXT.aliased(addr_of!(storage::TexParameterIiv));
[INFO] [stdout]       |                                              ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12696:44
[INFO] [stdout]       |
[INFO] [stdout] 12696 |          storage::TexParameterIuiv.aliased(&storage::TexParameterIuivEXT);
[INFO] [stdout]       |                                            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12696 |          storage::TexParameterIuiv.aliased(addr_of!(storage::TexParameterIuivEXT));
[INFO] [stdout]       |                                            ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12697:47
[INFO] [stdout]       |
[INFO] [stdout] 12697 |          storage::TexParameterIuivEXT.aliased(&storage::TexParameterIuiv);
[INFO] [stdout]       |                                               ^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12697 |          storage::TexParameterIuivEXT.aliased(addr_of!(storage::TexParameterIuiv));
[INFO] [stdout]       |                                               ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12698:40
[INFO] [stdout]       |
[INFO] [stdout] 12698 |          storage::TexStorage1D.aliased(&storage::TexStorage1DEXT);
[INFO] [stdout]       |                                        ^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12698 |          storage::TexStorage1D.aliased(addr_of!(storage::TexStorage1DEXT));
[INFO] [stdout]       |                                        ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12699:43
[INFO] [stdout]       |
[INFO] [stdout] 12699 |          storage::TexStorage1DEXT.aliased(&storage::TexStorage1D);
[INFO] [stdout]       |                                           ^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12699 |          storage::TexStorage1DEXT.aliased(addr_of!(storage::TexStorage1D));
[INFO] [stdout]       |                                           ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12700:40
[INFO] [stdout]       |
[INFO] [stdout] 12700 |          storage::TexStorage2D.aliased(&storage::TexStorage2DEXT);
[INFO] [stdout]       |                                        ^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12700 |          storage::TexStorage2D.aliased(addr_of!(storage::TexStorage2DEXT));
[INFO] [stdout]       |                                        ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12701:43
[INFO] [stdout]       |
[INFO] [stdout] 12701 |          storage::TexStorage2DEXT.aliased(&storage::TexStorage2D);
[INFO] [stdout]       |                                           ^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12701 |          storage::TexStorage2DEXT.aliased(addr_of!(storage::TexStorage2D));
[INFO] [stdout]       |                                           ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12702:40
[INFO] [stdout]       |
[INFO] [stdout] 12702 |          storage::TexStorage3D.aliased(&storage::TexStorage3DEXT);
[INFO] [stdout]       |                                        ^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12702 |          storage::TexStorage3D.aliased(addr_of!(storage::TexStorage3DEXT));
[INFO] [stdout]       |                                        ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12703:43
[INFO] [stdout]       |
[INFO] [stdout] 12703 |          storage::TexStorage3DEXT.aliased(&storage::TexStorage3D);
[INFO] [stdout]       |                                           ^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12703 |          storage::TexStorage3DEXT.aliased(addr_of!(storage::TexStorage3D));
[INFO] [stdout]       |                                           ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12704:41
[INFO] [stdout]       |
[INFO] [stdout] 12704 |          storage::TexSubImage1D.aliased(&storage::TexSubImage1DEXT);
[INFO] [stdout]       |                                         ^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12704 |          storage::TexSubImage1D.aliased(addr_of!(storage::TexSubImage1DEXT));
[INFO] [stdout]       |                                         ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12705:44
[INFO] [stdout]       |
[INFO] [stdout] 12705 |          storage::TexSubImage1DEXT.aliased(&storage::TexSubImage1D);
[INFO] [stdout]       |                                            ^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12705 |          storage::TexSubImage1DEXT.aliased(addr_of!(storage::TexSubImage1D));
[INFO] [stdout]       |                                            ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12706:41
[INFO] [stdout]       |
[INFO] [stdout] 12706 |          storage::TexSubImage2D.aliased(&storage::TexSubImage2DEXT);
[INFO] [stdout]       |                                         ^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12706 |          storage::TexSubImage2D.aliased(addr_of!(storage::TexSubImage2DEXT));
[INFO] [stdout]       |                                         ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12707:44
[INFO] [stdout]       |
[INFO] [stdout] 12707 |          storage::TexSubImage2DEXT.aliased(&storage::TexSubImage2D);
[INFO] [stdout]       |                                            ^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12707 |          storage::TexSubImage2DEXT.aliased(addr_of!(storage::TexSubImage2D));
[INFO] [stdout]       |                                            ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12708:41
[INFO] [stdout]       |
[INFO] [stdout] 12708 |          storage::TexSubImage3D.aliased(&storage::TexSubImage3DEXT);
[INFO] [stdout]       |                                         ^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12708 |          storage::TexSubImage3D.aliased(addr_of!(storage::TexSubImage3DEXT));
[INFO] [stdout]       |                                         ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12709:44
[INFO] [stdout]       |
[INFO] [stdout] 12709 |          storage::TexSubImage3DEXT.aliased(&storage::TexSubImage3D);
[INFO] [stdout]       |                                            ^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12709 |          storage::TexSubImage3DEXT.aliased(addr_of!(storage::TexSubImage3D));
[INFO] [stdout]       |                                            ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12710:53
[INFO] [stdout]       |
[INFO] [stdout] 12710 |          storage::TransformFeedbackVaryings.aliased(&storage::TransformFeedbackVaryingsEXT);
[INFO] [stdout]       |                                                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12710 |          storage::TransformFeedbackVaryings.aliased(addr_of!(storage::TransformFeedbackVaryingsEXT));
[INFO] [stdout]       |                                                     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12711:56
[INFO] [stdout]       |
[INFO] [stdout] 12711 |          storage::TransformFeedbackVaryingsEXT.aliased(&storage::TransformFeedbackVaryings);
[INFO] [stdout]       |                                                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12711 |          storage::TransformFeedbackVaryingsEXT.aliased(addr_of!(storage::TransformFeedbackVaryings));
[INFO] [stdout]       |                                                        ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12712:37
[INFO] [stdout]       |
[INFO] [stdout] 12712 |          storage::Uniform1f.aliased(&storage::Uniform1fARB);
[INFO] [stdout]       |                                     ^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12712 |          storage::Uniform1f.aliased(addr_of!(storage::Uniform1fARB));
[INFO] [stdout]       |                                     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12713:40
[INFO] [stdout]       |
[INFO] [stdout] 12713 |          storage::Uniform1fARB.aliased(&storage::Uniform1f);
[INFO] [stdout]       |                                        ^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12713 |          storage::Uniform1fARB.aliased(addr_of!(storage::Uniform1f));
[INFO] [stdout]       |                                        ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12714:38
[INFO] [stdout]       |
[INFO] [stdout] 12714 |          storage::Uniform1fv.aliased(&storage::Uniform1fvARB);
[INFO] [stdout]       |                                      ^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12714 |          storage::Uniform1fv.aliased(addr_of!(storage::Uniform1fvARB));
[INFO] [stdout]       |                                      ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12715:41
[INFO] [stdout]       |
[INFO] [stdout] 12715 |          storage::Uniform1fvARB.aliased(&storage::Uniform1fv);
[INFO] [stdout]       |                                         ^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12715 |          storage::Uniform1fvARB.aliased(addr_of!(storage::Uniform1fv));
[INFO] [stdout]       |                                         ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12716:37
[INFO] [stdout]       |
[INFO] [stdout] 12716 |          storage::Uniform1i.aliased(&storage::Uniform1iARB);
[INFO] [stdout]       |                                     ^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12716 |          storage::Uniform1i.aliased(addr_of!(storage::Uniform1iARB));
[INFO] [stdout]       |                                     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12717:40
[INFO] [stdout]       |
[INFO] [stdout] 12717 |          storage::Uniform1iARB.aliased(&storage::Uniform1i);
[INFO] [stdout]       |                                        ^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12717 |          storage::Uniform1iARB.aliased(addr_of!(storage::Uniform1i));
[INFO] [stdout]       |                                        ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12718:38
[INFO] [stdout]       |
[INFO] [stdout] 12718 |          storage::Uniform1iv.aliased(&storage::Uniform1ivARB);
[INFO] [stdout]       |                                      ^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12718 |          storage::Uniform1iv.aliased(addr_of!(storage::Uniform1ivARB));
[INFO] [stdout]       |                                      ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12719:41
[INFO] [stdout]       |
[INFO] [stdout] 12719 |          storage::Uniform1ivARB.aliased(&storage::Uniform1iv);
[INFO] [stdout]       |                                         ^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12719 |          storage::Uniform1ivARB.aliased(addr_of!(storage::Uniform1iv));
[INFO] [stdout]       |                                         ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12720:38
[INFO] [stdout]       |
[INFO] [stdout] 12720 |          storage::Uniform1ui.aliased(&storage::Uniform1uiEXT);
[INFO] [stdout]       |                                      ^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12720 |          storage::Uniform1ui.aliased(addr_of!(storage::Uniform1uiEXT));
[INFO] [stdout]       |                                      ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12721:41
[INFO] [stdout]       |
[INFO] [stdout] 12721 |          storage::Uniform1uiEXT.aliased(&storage::Uniform1ui);
[INFO] [stdout]       |                                         ^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12721 |          storage::Uniform1uiEXT.aliased(addr_of!(storage::Uniform1ui));
[INFO] [stdout]       |                                         ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12722:39
[INFO] [stdout]       |
[INFO] [stdout] 12722 |          storage::Uniform1uiv.aliased(&storage::Uniform1uivEXT);
[INFO] [stdout]       |                                       ^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12722 |          storage::Uniform1uiv.aliased(addr_of!(storage::Uniform1uivEXT));
[INFO] [stdout]       |                                       ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12723:42
[INFO] [stdout]       |
[INFO] [stdout] 12723 |          storage::Uniform1uivEXT.aliased(&storage::Uniform1uiv);
[INFO] [stdout]       |                                          ^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12723 |          storage::Uniform1uivEXT.aliased(addr_of!(storage::Uniform1uiv));
[INFO] [stdout]       |                                          ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12724:37
[INFO] [stdout]       |
[INFO] [stdout] 12724 |          storage::Uniform2f.aliased(&storage::Uniform2fARB);
[INFO] [stdout]       |                                     ^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12724 |          storage::Uniform2f.aliased(addr_of!(storage::Uniform2fARB));
[INFO] [stdout]       |                                     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12725:40
[INFO] [stdout]       |
[INFO] [stdout] 12725 |          storage::Uniform2fARB.aliased(&storage::Uniform2f);
[INFO] [stdout]       |                                        ^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12725 |          storage::Uniform2fARB.aliased(addr_of!(storage::Uniform2f));
[INFO] [stdout]       |                                        ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12726:38
[INFO] [stdout]       |
[INFO] [stdout] 12726 |          storage::Uniform2fv.aliased(&storage::Uniform2fvARB);
[INFO] [stdout]       |                                      ^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12726 |          storage::Uniform2fv.aliased(addr_of!(storage::Uniform2fvARB));
[INFO] [stdout]       |                                      ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12727:41
[INFO] [stdout]       |
[INFO] [stdout] 12727 |          storage::Uniform2fvARB.aliased(&storage::Uniform2fv);
[INFO] [stdout]       |                                         ^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12727 |          storage::Uniform2fvARB.aliased(addr_of!(storage::Uniform2fv));
[INFO] [stdout]       |                                         ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12728:37
[INFO] [stdout]       |
[INFO] [stdout] 12728 |          storage::Uniform2i.aliased(&storage::Uniform2iARB);
[INFO] [stdout]       |                                     ^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12728 |          storage::Uniform2i.aliased(addr_of!(storage::Uniform2iARB));
[INFO] [stdout]       |                                     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12729:40
[INFO] [stdout]       |
[INFO] [stdout] 12729 |          storage::Uniform2iARB.aliased(&storage::Uniform2i);
[INFO] [stdout]       |                                        ^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12729 |          storage::Uniform2iARB.aliased(addr_of!(storage::Uniform2i));
[INFO] [stdout]       |                                        ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12730:38
[INFO] [stdout]       |
[INFO] [stdout] 12730 |          storage::Uniform2iv.aliased(&storage::Uniform2ivARB);
[INFO] [stdout]       |                                      ^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12730 |          storage::Uniform2iv.aliased(addr_of!(storage::Uniform2ivARB));
[INFO] [stdout]       |                                      ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12731:41
[INFO] [stdout]       |
[INFO] [stdout] 12731 |          storage::Uniform2ivARB.aliased(&storage::Uniform2iv);
[INFO] [stdout]       |                                         ^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12731 |          storage::Uniform2ivARB.aliased(addr_of!(storage::Uniform2iv));
[INFO] [stdout]       |                                         ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12732:38
[INFO] [stdout]       |
[INFO] [stdout] 12732 |          storage::Uniform2ui.aliased(&storage::Uniform2uiEXT);
[INFO] [stdout]       |                                      ^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12732 |          storage::Uniform2ui.aliased(addr_of!(storage::Uniform2uiEXT));
[INFO] [stdout]       |                                      ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12733:41
[INFO] [stdout]       |
[INFO] [stdout] 12733 |          storage::Uniform2uiEXT.aliased(&storage::Uniform2ui);
[INFO] [stdout]       |                                         ^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12733 |          storage::Uniform2uiEXT.aliased(addr_of!(storage::Uniform2ui));
[INFO] [stdout]       |                                         ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12734:39
[INFO] [stdout]       |
[INFO] [stdout] 12734 |          storage::Uniform2uiv.aliased(&storage::Uniform2uivEXT);
[INFO] [stdout]       |                                       ^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12734 |          storage::Uniform2uiv.aliased(addr_of!(storage::Uniform2uivEXT));
[INFO] [stdout]       |                                       ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12735:42
[INFO] [stdout]       |
[INFO] [stdout] 12735 |          storage::Uniform2uivEXT.aliased(&storage::Uniform2uiv);
[INFO] [stdout]       |                                          ^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12735 |          storage::Uniform2uivEXT.aliased(addr_of!(storage::Uniform2uiv));
[INFO] [stdout]       |                                          ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12736:37
[INFO] [stdout]       |
[INFO] [stdout] 12736 |          storage::Uniform3f.aliased(&storage::Uniform3fARB);
[INFO] [stdout]       |                                     ^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12736 |          storage::Uniform3f.aliased(addr_of!(storage::Uniform3fARB));
[INFO] [stdout]       |                                     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12737:40
[INFO] [stdout]       |
[INFO] [stdout] 12737 |          storage::Uniform3fARB.aliased(&storage::Uniform3f);
[INFO] [stdout]       |                                        ^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12737 |          storage::Uniform3fARB.aliased(addr_of!(storage::Uniform3f));
[INFO] [stdout]       |                                        ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12738:38
[INFO] [stdout]       |
[INFO] [stdout] 12738 |          storage::Uniform3fv.aliased(&storage::Uniform3fvARB);
[INFO] [stdout]       |                                      ^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12738 |          storage::Uniform3fv.aliased(addr_of!(storage::Uniform3fvARB));
[INFO] [stdout]       |                                      ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12739:41
[INFO] [stdout]       |
[INFO] [stdout] 12739 |          storage::Uniform3fvARB.aliased(&storage::Uniform3fv);
[INFO] [stdout]       |                                         ^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12739 |          storage::Uniform3fvARB.aliased(addr_of!(storage::Uniform3fv));
[INFO] [stdout]       |                                         ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12740:37
[INFO] [stdout]       |
[INFO] [stdout] 12740 |          storage::Uniform3i.aliased(&storage::Uniform3iARB);
[INFO] [stdout]       |                                     ^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12740 |          storage::Uniform3i.aliased(addr_of!(storage::Uniform3iARB));
[INFO] [stdout]       |                                     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12741:40
[INFO] [stdout]       |
[INFO] [stdout] 12741 |          storage::Uniform3iARB.aliased(&storage::Uniform3i);
[INFO] [stdout]       |                                        ^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12741 |          storage::Uniform3iARB.aliased(addr_of!(storage::Uniform3i));
[INFO] [stdout]       |                                        ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12742:38
[INFO] [stdout]       |
[INFO] [stdout] 12742 |          storage::Uniform3iv.aliased(&storage::Uniform3ivARB);
[INFO] [stdout]       |                                      ^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12742 |          storage::Uniform3iv.aliased(addr_of!(storage::Uniform3ivARB));
[INFO] [stdout]       |                                      ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12743:41
[INFO] [stdout]       |
[INFO] [stdout] 12743 |          storage::Uniform3ivARB.aliased(&storage::Uniform3iv);
[INFO] [stdout]       |                                         ^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12743 |          storage::Uniform3ivARB.aliased(addr_of!(storage::Uniform3iv));
[INFO] [stdout]       |                                         ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12744:38
[INFO] [stdout]       |
[INFO] [stdout] 12744 |          storage::Uniform3ui.aliased(&storage::Uniform3uiEXT);
[INFO] [stdout]       |                                      ^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12744 |          storage::Uniform3ui.aliased(addr_of!(storage::Uniform3uiEXT));
[INFO] [stdout]       |                                      ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12745:41
[INFO] [stdout]       |
[INFO] [stdout] 12745 |          storage::Uniform3uiEXT.aliased(&storage::Uniform3ui);
[INFO] [stdout]       |                                         ^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12745 |          storage::Uniform3uiEXT.aliased(addr_of!(storage::Uniform3ui));
[INFO] [stdout]       |                                         ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12746:39
[INFO] [stdout]       |
[INFO] [stdout] 12746 |          storage::Uniform3uiv.aliased(&storage::Uniform3uivEXT);
[INFO] [stdout]       |                                       ^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12746 |          storage::Uniform3uiv.aliased(addr_of!(storage::Uniform3uivEXT));
[INFO] [stdout]       |                                       ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12747:42
[INFO] [stdout]       |
[INFO] [stdout] 12747 |          storage::Uniform3uivEXT.aliased(&storage::Uniform3uiv);
[INFO] [stdout]       |                                          ^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12747 |          storage::Uniform3uivEXT.aliased(addr_of!(storage::Uniform3uiv));
[INFO] [stdout]       |                                          ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12748:37
[INFO] [stdout]       |
[INFO] [stdout] 12748 |          storage::Uniform4f.aliased(&storage::Uniform4fARB);
[INFO] [stdout]       |                                     ^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12748 |          storage::Uniform4f.aliased(addr_of!(storage::Uniform4fARB));
[INFO] [stdout]       |                                     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12749:40
[INFO] [stdout]       |
[INFO] [stdout] 12749 |          storage::Uniform4fARB.aliased(&storage::Uniform4f);
[INFO] [stdout]       |                                        ^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12749 |          storage::Uniform4fARB.aliased(addr_of!(storage::Uniform4f));
[INFO] [stdout]       |                                        ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12750:38
[INFO] [stdout]       |
[INFO] [stdout] 12750 |          storage::Uniform4fv.aliased(&storage::Uniform4fvARB);
[INFO] [stdout]       |                                      ^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12750 |          storage::Uniform4fv.aliased(addr_of!(storage::Uniform4fvARB));
[INFO] [stdout]       |                                      ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12751:41
[INFO] [stdout]       |
[INFO] [stdout] 12751 |          storage::Uniform4fvARB.aliased(&storage::Uniform4fv);
[INFO] [stdout]       |                                         ^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12751 |          storage::Uniform4fvARB.aliased(addr_of!(storage::Uniform4fv));
[INFO] [stdout]       |                                         ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12752:37
[INFO] [stdout]       |
[INFO] [stdout] 12752 |          storage::Uniform4i.aliased(&storage::Uniform4iARB);
[INFO] [stdout]       |                                     ^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12752 |          storage::Uniform4i.aliased(addr_of!(storage::Uniform4iARB));
[INFO] [stdout]       |                                     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12753:40
[INFO] [stdout]       |
[INFO] [stdout] 12753 |          storage::Uniform4iARB.aliased(&storage::Uniform4i);
[INFO] [stdout]       |                                        ^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12753 |          storage::Uniform4iARB.aliased(addr_of!(storage::Uniform4i));
[INFO] [stdout]       |                                        ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12754:38
[INFO] [stdout]       |
[INFO] [stdout] 12754 |          storage::Uniform4iv.aliased(&storage::Uniform4ivARB);
[INFO] [stdout]       |                                      ^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12754 |          storage::Uniform4iv.aliased(addr_of!(storage::Uniform4ivARB));
[INFO] [stdout]       |                                      ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12755:41
[INFO] [stdout]       |
[INFO] [stdout] 12755 |          storage::Uniform4ivARB.aliased(&storage::Uniform4iv);
[INFO] [stdout]       |                                         ^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12755 |          storage::Uniform4ivARB.aliased(addr_of!(storage::Uniform4iv));
[INFO] [stdout]       |                                         ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12756:38
[INFO] [stdout]       |
[INFO] [stdout] 12756 |          storage::Uniform4ui.aliased(&storage::Uniform4uiEXT);
[INFO] [stdout]       |                                      ^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12756 |          storage::Uniform4ui.aliased(addr_of!(storage::Uniform4uiEXT));
[INFO] [stdout]       |                                      ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12757:41
[INFO] [stdout]       |
[INFO] [stdout] 12757 |          storage::Uniform4uiEXT.aliased(&storage::Uniform4ui);
[INFO] [stdout]       |                                         ^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12757 |          storage::Uniform4uiEXT.aliased(addr_of!(storage::Uniform4ui));
[INFO] [stdout]       |                                         ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12758:39
[INFO] [stdout]       |
[INFO] [stdout] 12758 |          storage::Uniform4uiv.aliased(&storage::Uniform4uivEXT);
[INFO] [stdout]       |                                       ^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12758 |          storage::Uniform4uiv.aliased(addr_of!(storage::Uniform4uivEXT));
[INFO] [stdout]       |                                       ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12759:42
[INFO] [stdout]       |
[INFO] [stdout] 12759 |          storage::Uniform4uivEXT.aliased(&storage::Uniform4uiv);
[INFO] [stdout]       |                                          ^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12759 |          storage::Uniform4uivEXT.aliased(addr_of!(storage::Uniform4uiv));
[INFO] [stdout]       |                                          ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12760:44
[INFO] [stdout]       |
[INFO] [stdout] 12760 |          storage::UniformMatrix2fv.aliased(&storage::UniformMatrix2fvARB);
[INFO] [stdout]       |                                            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12760 |          storage::UniformMatrix2fv.aliased(addr_of!(storage::UniformMatrix2fvARB));
[INFO] [stdout]       |                                            ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12761:47
[INFO] [stdout]       |
[INFO] [stdout] 12761 |          storage::UniformMatrix2fvARB.aliased(&storage::UniformMatrix2fv);
[INFO] [stdout]       |                                               ^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12761 |          storage::UniformMatrix2fvARB.aliased(addr_of!(storage::UniformMatrix2fv));
[INFO] [stdout]       |                                               ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12762:44
[INFO] [stdout]       |
[INFO] [stdout] 12762 |          storage::UniformMatrix3fv.aliased(&storage::UniformMatrix3fvARB);
[INFO] [stdout]       |                                            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12762 |          storage::UniformMatrix3fv.aliased(addr_of!(storage::UniformMatrix3fvARB));
[INFO] [stdout]       |                                            ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12763:47
[INFO] [stdout]       |
[INFO] [stdout] 12763 |          storage::UniformMatrix3fvARB.aliased(&storage::UniformMatrix3fv);
[INFO] [stdout]       |                                               ^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12763 |          storage::UniformMatrix3fvARB.aliased(addr_of!(storage::UniformMatrix3fv));
[INFO] [stdout]       |                                               ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12764:44
[INFO] [stdout]       |
[INFO] [stdout] 12764 |          storage::UniformMatrix4fv.aliased(&storage::UniformMatrix4fvARB);
[INFO] [stdout]       |                                            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12764 |          storage::UniformMatrix4fv.aliased(addr_of!(storage::UniformMatrix4fvARB));
[INFO] [stdout]       |                                            ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12765:47
[INFO] [stdout]       |
[INFO] [stdout] 12765 |          storage::UniformMatrix4fvARB.aliased(&storage::UniformMatrix4fv);
[INFO] [stdout]       |                                               ^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12765 |          storage::UniformMatrix4fvARB.aliased(addr_of!(storage::UniformMatrix4fv));
[INFO] [stdout]       |                                               ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12766:39
[INFO] [stdout]       |
[INFO] [stdout] 12766 |          storage::UnmapBuffer.aliased(&storage::UnmapBufferARB);
[INFO] [stdout]       |                                       ^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12766 |          storage::UnmapBuffer.aliased(addr_of!(storage::UnmapBufferARB));
[INFO] [stdout]       |                                       ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12767:42
[INFO] [stdout]       |
[INFO] [stdout] 12767 |          storage::UnmapBufferARB.aliased(&storage::UnmapBuffer);
[INFO] [stdout]       |                                          ^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12767 |          storage::UnmapBufferARB.aliased(addr_of!(storage::UnmapBuffer));
[INFO] [stdout]       |                                          ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12768:38
[INFO] [stdout]       |
[INFO] [stdout] 12768 |          storage::UseProgram.aliased(&storage::UseProgramObjectARB);
[INFO] [stdout]       |                                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12768 |          storage::UseProgram.aliased(addr_of!(storage::UseProgramObjectARB));
[INFO] [stdout]       |                                      ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12769:47
[INFO] [stdout]       |
[INFO] [stdout] 12769 |          storage::UseProgramObjectARB.aliased(&storage::UseProgram);
[INFO] [stdout]       |                                               ^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12769 |          storage::UseProgramObjectARB.aliased(addr_of!(storage::UseProgram));
[INFO] [stdout]       |                                               ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12770:43
[INFO] [stdout]       |
[INFO] [stdout] 12770 |          storage::ValidateProgram.aliased(&storage::ValidateProgramARB);
[INFO] [stdout]       |                                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12770 |          storage::ValidateProgram.aliased(addr_of!(storage::ValidateProgramARB));
[INFO] [stdout]       |                                           ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12771:46
[INFO] [stdout]       |
[INFO] [stdout] 12771 |          storage::ValidateProgramARB.aliased(&storage::ValidateProgram);
[INFO] [stdout]       |                                              ^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12771 |          storage::ValidateProgramARB.aliased(addr_of!(storage::ValidateProgram));
[INFO] [stdout]       |                                              ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12772:42
[INFO] [stdout]       |
[INFO] [stdout] 12772 |          storage::VertexAttrib1d.aliased(&storage::VertexAttrib1dARB);
[INFO] [stdout]       |                                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12772 |          storage::VertexAttrib1d.aliased(addr_of!(storage::VertexAttrib1dARB));
[INFO] [stdout]       |                                          ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12773:42
[INFO] [stdout]       |
[INFO] [stdout] 12773 |          storage::VertexAttrib1d.aliased(&storage::VertexAttrib1dNV);
[INFO] [stdout]       |                                          ^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12773 |          storage::VertexAttrib1d.aliased(addr_of!(storage::VertexAttrib1dNV));
[INFO] [stdout]       |                                          ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12774:45
[INFO] [stdout]       |
[INFO] [stdout] 12774 |          storage::VertexAttrib1dARB.aliased(&storage::VertexAttrib1d);
[INFO] [stdout]       |                                             ^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12774 |          storage::VertexAttrib1dARB.aliased(addr_of!(storage::VertexAttrib1d));
[INFO] [stdout]       |                                             ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12775:45
[INFO] [stdout]       |
[INFO] [stdout] 12775 |          storage::VertexAttrib1dARB.aliased(&storage::VertexAttrib1dNV);
[INFO] [stdout]       |                                             ^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12775 |          storage::VertexAttrib1dARB.aliased(addr_of!(storage::VertexAttrib1dNV));
[INFO] [stdout]       |                                             ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12776:44
[INFO] [stdout]       |
[INFO] [stdout] 12776 |          storage::VertexAttrib1dNV.aliased(&storage::VertexAttrib1d);
[INFO] [stdout]       |                                            ^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12776 |          storage::VertexAttrib1dNV.aliased(addr_of!(storage::VertexAttrib1d));
[INFO] [stdout]       |                                            ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12777:44
[INFO] [stdout]       |
[INFO] [stdout] 12777 |          storage::VertexAttrib1dNV.aliased(&storage::VertexAttrib1dARB);
[INFO] [stdout]       |                                            ^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12777 |          storage::VertexAttrib1dNV.aliased(addr_of!(storage::VertexAttrib1dARB));
[INFO] [stdout]       |                                            ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12778:43
[INFO] [stdout]       |
[INFO] [stdout] 12778 |          storage::VertexAttrib1dv.aliased(&storage::VertexAttrib1dvARB);
[INFO] [stdout]       |                                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12778 |          storage::VertexAttrib1dv.aliased(addr_of!(storage::VertexAttrib1dvARB));
[INFO] [stdout]       |                                           ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12779:43
[INFO] [stdout]       |
[INFO] [stdout] 12779 |          storage::VertexAttrib1dv.aliased(&storage::VertexAttrib1dvNV);
[INFO] [stdout]       |                                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12779 |          storage::VertexAttrib1dv.aliased(addr_of!(storage::VertexAttrib1dvNV));
[INFO] [stdout]       |                                           ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12780:46
[INFO] [stdout]       |
[INFO] [stdout] 12780 |          storage::VertexAttrib1dvARB.aliased(&storage::VertexAttrib1dv);
[INFO] [stdout]       |                                              ^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12780 |          storage::VertexAttrib1dvARB.aliased(addr_of!(storage::VertexAttrib1dv));
[INFO] [stdout]       |                                              ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12781:46
[INFO] [stdout]       |
[INFO] [stdout] 12781 |          storage::VertexAttrib1dvARB.aliased(&storage::VertexAttrib1dvNV);
[INFO] [stdout]       |                                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12781 |          storage::VertexAttrib1dvARB.aliased(addr_of!(storage::VertexAttrib1dvNV));
[INFO] [stdout]       |                                              ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12782:45
[INFO] [stdout]       |
[INFO] [stdout] 12782 |          storage::VertexAttrib1dvNV.aliased(&storage::VertexAttrib1dv);
[INFO] [stdout]       |                                             ^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12782 |          storage::VertexAttrib1dvNV.aliased(addr_of!(storage::VertexAttrib1dv));
[INFO] [stdout]       |                                             ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12783:45
[INFO] [stdout]       |
[INFO] [stdout] 12783 |          storage::VertexAttrib1dvNV.aliased(&storage::VertexAttrib1dvARB);
[INFO] [stdout]       |                                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12783 |          storage::VertexAttrib1dvNV.aliased(addr_of!(storage::VertexAttrib1dvARB));
[INFO] [stdout]       |                                             ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12784:42
[INFO] [stdout]       |
[INFO] [stdout] 12784 |          storage::VertexAttrib1f.aliased(&storage::VertexAttrib1fARB);
[INFO] [stdout]       |                                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12784 |          storage::VertexAttrib1f.aliased(addr_of!(storage::VertexAttrib1fARB));
[INFO] [stdout]       |                                          ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12785:42
[INFO] [stdout]       |
[INFO] [stdout] 12785 |          storage::VertexAttrib1f.aliased(&storage::VertexAttrib1fNV);
[INFO] [stdout]       |                                          ^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12785 |          storage::VertexAttrib1f.aliased(addr_of!(storage::VertexAttrib1fNV));
[INFO] [stdout]       |                                          ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12786:45
[INFO] [stdout]       |
[INFO] [stdout] 12786 |          storage::VertexAttrib1fARB.aliased(&storage::VertexAttrib1f);
[INFO] [stdout]       |                                             ^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12786 |          storage::VertexAttrib1fARB.aliased(addr_of!(storage::VertexAttrib1f));
[INFO] [stdout]       |                                             ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12787:45
[INFO] [stdout]       |
[INFO] [stdout] 12787 |          storage::VertexAttrib1fARB.aliased(&storage::VertexAttrib1fNV);
[INFO] [stdout]       |                                             ^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12787 |          storage::VertexAttrib1fARB.aliased(addr_of!(storage::VertexAttrib1fNV));
[INFO] [stdout]       |                                             ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12788:44
[INFO] [stdout]       |
[INFO] [stdout] 12788 |          storage::VertexAttrib1fNV.aliased(&storage::VertexAttrib1f);
[INFO] [stdout]       |                                            ^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12788 |          storage::VertexAttrib1fNV.aliased(addr_of!(storage::VertexAttrib1f));
[INFO] [stdout]       |                                            ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12789:44
[INFO] [stdout]       |
[INFO] [stdout] 12789 |          storage::VertexAttrib1fNV.aliased(&storage::VertexAttrib1fARB);
[INFO] [stdout]       |                                            ^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12789 |          storage::VertexAttrib1fNV.aliased(addr_of!(storage::VertexAttrib1fARB));
[INFO] [stdout]       |                                            ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12790:43
[INFO] [stdout]       |
[INFO] [stdout] 12790 |          storage::VertexAttrib1fv.aliased(&storage::VertexAttrib1fvARB);
[INFO] [stdout]       |                                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12790 |          storage::VertexAttrib1fv.aliased(addr_of!(storage::VertexAttrib1fvARB));
[INFO] [stdout]       |                                           ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12791:43
[INFO] [stdout]       |
[INFO] [stdout] 12791 |          storage::VertexAttrib1fv.aliased(&storage::VertexAttrib1fvNV);
[INFO] [stdout]       |                                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12791 |          storage::VertexAttrib1fv.aliased(addr_of!(storage::VertexAttrib1fvNV));
[INFO] [stdout]       |                                           ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12792:46
[INFO] [stdout]       |
[INFO] [stdout] 12792 |          storage::VertexAttrib1fvARB.aliased(&storage::VertexAttrib1fv);
[INFO] [stdout]       |                                              ^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12792 |          storage::VertexAttrib1fvARB.aliased(addr_of!(storage::VertexAttrib1fv));
[INFO] [stdout]       |                                              ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12793:46
[INFO] [stdout]       |
[INFO] [stdout] 12793 |          storage::VertexAttrib1fvARB.aliased(&storage::VertexAttrib1fvNV);
[INFO] [stdout]       |                                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12793 |          storage::VertexAttrib1fvARB.aliased(addr_of!(storage::VertexAttrib1fvNV));
[INFO] [stdout]       |                                              ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12794:45
[INFO] [stdout]       |
[INFO] [stdout] 12794 |          storage::VertexAttrib1fvNV.aliased(&storage::VertexAttrib1fv);
[INFO] [stdout]       |                                             ^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12794 |          storage::VertexAttrib1fvNV.aliased(addr_of!(storage::VertexAttrib1fv));
[INFO] [stdout]       |                                             ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12795:45
[INFO] [stdout]       |
[INFO] [stdout] 12795 |          storage::VertexAttrib1fvNV.aliased(&storage::VertexAttrib1fvARB);
[INFO] [stdout]       |                                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12795 |          storage::VertexAttrib1fvNV.aliased(addr_of!(storage::VertexAttrib1fvARB));
[INFO] [stdout]       |                                             ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12796:42
[INFO] [stdout]       |
[INFO] [stdout] 12796 |          storage::VertexAttrib1s.aliased(&storage::VertexAttrib1sARB);
[INFO] [stdout]       |                                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12796 |          storage::VertexAttrib1s.aliased(addr_of!(storage::VertexAttrib1sARB));
[INFO] [stdout]       |                                          ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12797:42
[INFO] [stdout]       |
[INFO] [stdout] 12797 |          storage::VertexAttrib1s.aliased(&storage::VertexAttrib1sNV);
[INFO] [stdout]       |                                          ^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12797 |          storage::VertexAttrib1s.aliased(addr_of!(storage::VertexAttrib1sNV));
[INFO] [stdout]       |                                          ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12798:45
[INFO] [stdout]       |
[INFO] [stdout] 12798 |          storage::VertexAttrib1sARB.aliased(&storage::VertexAttrib1s);
[INFO] [stdout]       |                                             ^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12798 |          storage::VertexAttrib1sARB.aliased(addr_of!(storage::VertexAttrib1s));
[INFO] [stdout]       |                                             ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12799:45
[INFO] [stdout]       |
[INFO] [stdout] 12799 |          storage::VertexAttrib1sARB.aliased(&storage::VertexAttrib1sNV);
[INFO] [stdout]       |                                             ^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12799 |          storage::VertexAttrib1sARB.aliased(addr_of!(storage::VertexAttrib1sNV));
[INFO] [stdout]       |                                             ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12800:44
[INFO] [stdout]       |
[INFO] [stdout] 12800 |          storage::VertexAttrib1sNV.aliased(&storage::VertexAttrib1s);
[INFO] [stdout]       |                                            ^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12800 |          storage::VertexAttrib1sNV.aliased(addr_of!(storage::VertexAttrib1s));
[INFO] [stdout]       |                                            ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12801:44
[INFO] [stdout]       |
[INFO] [stdout] 12801 |          storage::VertexAttrib1sNV.aliased(&storage::VertexAttrib1sARB);
[INFO] [stdout]       |                                            ^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12801 |          storage::VertexAttrib1sNV.aliased(addr_of!(storage::VertexAttrib1sARB));
[INFO] [stdout]       |                                            ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12802:43
[INFO] [stdout]       |
[INFO] [stdout] 12802 |          storage::VertexAttrib1sv.aliased(&storage::VertexAttrib1svARB);
[INFO] [stdout]       |                                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12802 |          storage::VertexAttrib1sv.aliased(addr_of!(storage::VertexAttrib1svARB));
[INFO] [stdout]       |                                           ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12803:43
[INFO] [stdout]       |
[INFO] [stdout] 12803 |          storage::VertexAttrib1sv.aliased(&storage::VertexAttrib1svNV);
[INFO] [stdout]       |                                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12803 |          storage::VertexAttrib1sv.aliased(addr_of!(storage::VertexAttrib1svNV));
[INFO] [stdout]       |                                           ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12804:46
[INFO] [stdout]       |
[INFO] [stdout] 12804 |          storage::VertexAttrib1svARB.aliased(&storage::VertexAttrib1sv);
[INFO] [stdout]       |                                              ^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12804 |          storage::VertexAttrib1svARB.aliased(addr_of!(storage::VertexAttrib1sv));
[INFO] [stdout]       |                                              ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12805:46
[INFO] [stdout]       |
[INFO] [stdout] 12805 |          storage::VertexAttrib1svARB.aliased(&storage::VertexAttrib1svNV);
[INFO] [stdout]       |                                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12805 |          storage::VertexAttrib1svARB.aliased(addr_of!(storage::VertexAttrib1svNV));
[INFO] [stdout]       |                                              ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12806:45
[INFO] [stdout]       |
[INFO] [stdout] 12806 |          storage::VertexAttrib1svNV.aliased(&storage::VertexAttrib1sv);
[INFO] [stdout]       |                                             ^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12806 |          storage::VertexAttrib1svNV.aliased(addr_of!(storage::VertexAttrib1sv));
[INFO] [stdout]       |                                             ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12807:45
[INFO] [stdout]       |
[INFO] [stdout] 12807 |          storage::VertexAttrib1svNV.aliased(&storage::VertexAttrib1svARB);
[INFO] [stdout]       |                                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12807 |          storage::VertexAttrib1svNV.aliased(addr_of!(storage::VertexAttrib1svARB));
[INFO] [stdout]       |                                             ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12808:42
[INFO] [stdout]       |
[INFO] [stdout] 12808 |          storage::VertexAttrib2d.aliased(&storage::VertexAttrib2dARB);
[INFO] [stdout]       |                                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12808 |          storage::VertexAttrib2d.aliased(addr_of!(storage::VertexAttrib2dARB));
[INFO] [stdout]       |                                          ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12809:42
[INFO] [stdout]       |
[INFO] [stdout] 12809 |          storage::VertexAttrib2d.aliased(&storage::VertexAttrib2dNV);
[INFO] [stdout]       |                                          ^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12809 |          storage::VertexAttrib2d.aliased(addr_of!(storage::VertexAttrib2dNV));
[INFO] [stdout]       |                                          ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12810:45
[INFO] [stdout]       |
[INFO] [stdout] 12810 |          storage::VertexAttrib2dARB.aliased(&storage::VertexAttrib2d);
[INFO] [stdout]       |                                             ^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12810 |          storage::VertexAttrib2dARB.aliased(addr_of!(storage::VertexAttrib2d));
[INFO] [stdout]       |                                             ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12811:45
[INFO] [stdout]       |
[INFO] [stdout] 12811 |          storage::VertexAttrib2dARB.aliased(&storage::VertexAttrib2dNV);
[INFO] [stdout]       |                                             ^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12811 |          storage::VertexAttrib2dARB.aliased(addr_of!(storage::VertexAttrib2dNV));
[INFO] [stdout]       |                                             ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12812:44
[INFO] [stdout]       |
[INFO] [stdout] 12812 |          storage::VertexAttrib2dNV.aliased(&storage::VertexAttrib2d);
[INFO] [stdout]       |                                            ^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12812 |          storage::VertexAttrib2dNV.aliased(addr_of!(storage::VertexAttrib2d));
[INFO] [stdout]       |                                            ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12813:44
[INFO] [stdout]       |
[INFO] [stdout] 12813 |          storage::VertexAttrib2dNV.aliased(&storage::VertexAttrib2dARB);
[INFO] [stdout]       |                                            ^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12813 |          storage::VertexAttrib2dNV.aliased(addr_of!(storage::VertexAttrib2dARB));
[INFO] [stdout]       |                                            ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12814:43
[INFO] [stdout]       |
[INFO] [stdout] 12814 |          storage::VertexAttrib2dv.aliased(&storage::VertexAttrib2dvARB);
[INFO] [stdout]       |                                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12814 |          storage::VertexAttrib2dv.aliased(addr_of!(storage::VertexAttrib2dvARB));
[INFO] [stdout]       |                                           ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12815:43
[INFO] [stdout]       |
[INFO] [stdout] 12815 |          storage::VertexAttrib2dv.aliased(&storage::VertexAttrib2dvNV);
[INFO] [stdout]       |                                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12815 |          storage::VertexAttrib2dv.aliased(addr_of!(storage::VertexAttrib2dvNV));
[INFO] [stdout]       |                                           ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12816:46
[INFO] [stdout]       |
[INFO] [stdout] 12816 |          storage::VertexAttrib2dvARB.aliased(&storage::VertexAttrib2dv);
[INFO] [stdout]       |                                              ^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12816 |          storage::VertexAttrib2dvARB.aliased(addr_of!(storage::VertexAttrib2dv));
[INFO] [stdout]       |                                              ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12817:46
[INFO] [stdout]       |
[INFO] [stdout] 12817 |          storage::VertexAttrib2dvARB.aliased(&storage::VertexAttrib2dvNV);
[INFO] [stdout]       |                                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12817 |          storage::VertexAttrib2dvARB.aliased(addr_of!(storage::VertexAttrib2dvNV));
[INFO] [stdout]       |                                              ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12818:45
[INFO] [stdout]       |
[INFO] [stdout] 12818 |          storage::VertexAttrib2dvNV.aliased(&storage::VertexAttrib2dv);
[INFO] [stdout]       |                                             ^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12818 |          storage::VertexAttrib2dvNV.aliased(addr_of!(storage::VertexAttrib2dv));
[INFO] [stdout]       |                                             ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12819:45
[INFO] [stdout]       |
[INFO] [stdout] 12819 |          storage::VertexAttrib2dvNV.aliased(&storage::VertexAttrib2dvARB);
[INFO] [stdout]       |                                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12819 |          storage::VertexAttrib2dvNV.aliased(addr_of!(storage::VertexAttrib2dvARB));
[INFO] [stdout]       |                                             ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12820:42
[INFO] [stdout]       |
[INFO] [stdout] 12820 |          storage::VertexAttrib2f.aliased(&storage::VertexAttrib2fARB);
[INFO] [stdout]       |                                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12820 |          storage::VertexAttrib2f.aliased(addr_of!(storage::VertexAttrib2fARB));
[INFO] [stdout]       |                                          ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12821:42
[INFO] [stdout]       |
[INFO] [stdout] 12821 |          storage::VertexAttrib2f.aliased(&storage::VertexAttrib2fNV);
[INFO] [stdout]       |                                          ^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12821 |          storage::VertexAttrib2f.aliased(addr_of!(storage::VertexAttrib2fNV));
[INFO] [stdout]       |                                          ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12822:45
[INFO] [stdout]       |
[INFO] [stdout] 12822 |          storage::VertexAttrib2fARB.aliased(&storage::VertexAttrib2f);
[INFO] [stdout]       |                                             ^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12822 |          storage::VertexAttrib2fARB.aliased(addr_of!(storage::VertexAttrib2f));
[INFO] [stdout]       |                                             ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12823:45
[INFO] [stdout]       |
[INFO] [stdout] 12823 |          storage::VertexAttrib2fARB.aliased(&storage::VertexAttrib2fNV);
[INFO] [stdout]       |                                             ^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12823 |          storage::VertexAttrib2fARB.aliased(addr_of!(storage::VertexAttrib2fNV));
[INFO] [stdout]       |                                             ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12824:44
[INFO] [stdout]       |
[INFO] [stdout] 12824 |          storage::VertexAttrib2fNV.aliased(&storage::VertexAttrib2f);
[INFO] [stdout]       |                                            ^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12824 |          storage::VertexAttrib2fNV.aliased(addr_of!(storage::VertexAttrib2f));
[INFO] [stdout]       |                                            ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12825:44
[INFO] [stdout]       |
[INFO] [stdout] 12825 |          storage::VertexAttrib2fNV.aliased(&storage::VertexAttrib2fARB);
[INFO] [stdout]       |                                            ^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12825 |          storage::VertexAttrib2fNV.aliased(addr_of!(storage::VertexAttrib2fARB));
[INFO] [stdout]       |                                            ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12826:43
[INFO] [stdout]       |
[INFO] [stdout] 12826 |          storage::VertexAttrib2fv.aliased(&storage::VertexAttrib2fvARB);
[INFO] [stdout]       |                                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12826 |          storage::VertexAttrib2fv.aliased(addr_of!(storage::VertexAttrib2fvARB));
[INFO] [stdout]       |                                           ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12827:43
[INFO] [stdout]       |
[INFO] [stdout] 12827 |          storage::VertexAttrib2fv.aliased(&storage::VertexAttrib2fvNV);
[INFO] [stdout]       |                                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12827 |          storage::VertexAttrib2fv.aliased(addr_of!(storage::VertexAttrib2fvNV));
[INFO] [stdout]       |                                           ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12828:46
[INFO] [stdout]       |
[INFO] [stdout] 12828 |          storage::VertexAttrib2fvARB.aliased(&storage::VertexAttrib2fv);
[INFO] [stdout]       |                                              ^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12828 |          storage::VertexAttrib2fvARB.aliased(addr_of!(storage::VertexAttrib2fv));
[INFO] [stdout]       |                                              ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12829:46
[INFO] [stdout]       |
[INFO] [stdout] 12829 |          storage::VertexAttrib2fvARB.aliased(&storage::VertexAttrib2fvNV);
[INFO] [stdout]       |                                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12829 |          storage::VertexAttrib2fvARB.aliased(addr_of!(storage::VertexAttrib2fvNV));
[INFO] [stdout]       |                                              ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12830:45
[INFO] [stdout]       |
[INFO] [stdout] 12830 |          storage::VertexAttrib2fvNV.aliased(&storage::VertexAttrib2fv);
[INFO] [stdout]       |                                             ^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12830 |          storage::VertexAttrib2fvNV.aliased(addr_of!(storage::VertexAttrib2fv));
[INFO] [stdout]       |                                             ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12831:45
[INFO] [stdout]       |
[INFO] [stdout] 12831 |          storage::VertexAttrib2fvNV.aliased(&storage::VertexAttrib2fvARB);
[INFO] [stdout]       |                                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12831 |          storage::VertexAttrib2fvNV.aliased(addr_of!(storage::VertexAttrib2fvARB));
[INFO] [stdout]       |                                             ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12832:42
[INFO] [stdout]       |
[INFO] [stdout] 12832 |          storage::VertexAttrib2s.aliased(&storage::VertexAttrib2sARB);
[INFO] [stdout]       |                                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12832 |          storage::VertexAttrib2s.aliased(addr_of!(storage::VertexAttrib2sARB));
[INFO] [stdout]       |                                          ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12833:42
[INFO] [stdout]       |
[INFO] [stdout] 12833 |          storage::VertexAttrib2s.aliased(&storage::VertexAttrib2sNV);
[INFO] [stdout]       |                                          ^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12833 |          storage::VertexAttrib2s.aliased(addr_of!(storage::VertexAttrib2sNV));
[INFO] [stdout]       |                                          ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12834:45
[INFO] [stdout]       |
[INFO] [stdout] 12834 |          storage::VertexAttrib2sARB.aliased(&storage::VertexAttrib2s);
[INFO] [stdout]       |                                             ^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12834 |          storage::VertexAttrib2sARB.aliased(addr_of!(storage::VertexAttrib2s));
[INFO] [stdout]       |                                             ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12835:45
[INFO] [stdout]       |
[INFO] [stdout] 12835 |          storage::VertexAttrib2sARB.aliased(&storage::VertexAttrib2sNV);
[INFO] [stdout]       |                                             ^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12835 |          storage::VertexAttrib2sARB.aliased(addr_of!(storage::VertexAttrib2sNV));
[INFO] [stdout]       |                                             ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12836:44
[INFO] [stdout]       |
[INFO] [stdout] 12836 |          storage::VertexAttrib2sNV.aliased(&storage::VertexAttrib2s);
[INFO] [stdout]       |                                            ^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12836 |          storage::VertexAttrib2sNV.aliased(addr_of!(storage::VertexAttrib2s));
[INFO] [stdout]       |                                            ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12837:44
[INFO] [stdout]       |
[INFO] [stdout] 12837 |          storage::VertexAttrib2sNV.aliased(&storage::VertexAttrib2sARB);
[INFO] [stdout]       |                                            ^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12837 |          storage::VertexAttrib2sNV.aliased(addr_of!(storage::VertexAttrib2sARB));
[INFO] [stdout]       |                                            ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12838:43
[INFO] [stdout]       |
[INFO] [stdout] 12838 |          storage::VertexAttrib2sv.aliased(&storage::VertexAttrib2svARB);
[INFO] [stdout]       |                                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12838 |          storage::VertexAttrib2sv.aliased(addr_of!(storage::VertexAttrib2svARB));
[INFO] [stdout]       |                                           ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12839:43
[INFO] [stdout]       |
[INFO] [stdout] 12839 |          storage::VertexAttrib2sv.aliased(&storage::VertexAttrib2svNV);
[INFO] [stdout]       |                                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12839 |          storage::VertexAttrib2sv.aliased(addr_of!(storage::VertexAttrib2svNV));
[INFO] [stdout]       |                                           ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12840:46
[INFO] [stdout]       |
[INFO] [stdout] 12840 |          storage::VertexAttrib2svARB.aliased(&storage::VertexAttrib2sv);
[INFO] [stdout]       |                                              ^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12840 |          storage::VertexAttrib2svARB.aliased(addr_of!(storage::VertexAttrib2sv));
[INFO] [stdout]       |                                              ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12841:46
[INFO] [stdout]       |
[INFO] [stdout] 12841 |          storage::VertexAttrib2svARB.aliased(&storage::VertexAttrib2svNV);
[INFO] [stdout]       |                                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12841 |          storage::VertexAttrib2svARB.aliased(addr_of!(storage::VertexAttrib2svNV));
[INFO] [stdout]       |                                              ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12842:45
[INFO] [stdout]       |
[INFO] [stdout] 12842 |          storage::VertexAttrib2svNV.aliased(&storage::VertexAttrib2sv);
[INFO] [stdout]       |                                             ^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12842 |          storage::VertexAttrib2svNV.aliased(addr_of!(storage::VertexAttrib2sv));
[INFO] [stdout]       |                                             ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12843:45
[INFO] [stdout]       |
[INFO] [stdout] 12843 |          storage::VertexAttrib2svNV.aliased(&storage::VertexAttrib2svARB);
[INFO] [stdout]       |                                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12843 |          storage::VertexAttrib2svNV.aliased(addr_of!(storage::VertexAttrib2svARB));
[INFO] [stdout]       |                                             ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12844:42
[INFO] [stdout]       |
[INFO] [stdout] 12844 |          storage::VertexAttrib3d.aliased(&storage::VertexAttrib3dARB);
[INFO] [stdout]       |                                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12844 |          storage::VertexAttrib3d.aliased(addr_of!(storage::VertexAttrib3dARB));
[INFO] [stdout]       |                                          ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12845:42
[INFO] [stdout]       |
[INFO] [stdout] 12845 |          storage::VertexAttrib3d.aliased(&storage::VertexAttrib3dNV);
[INFO] [stdout]       |                                          ^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12845 |          storage::VertexAttrib3d.aliased(addr_of!(storage::VertexAttrib3dNV));
[INFO] [stdout]       |                                          ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12846:45
[INFO] [stdout]       |
[INFO] [stdout] 12846 |          storage::VertexAttrib3dARB.aliased(&storage::VertexAttrib3d);
[INFO] [stdout]       |                                             ^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12846 |          storage::VertexAttrib3dARB.aliased(addr_of!(storage::VertexAttrib3d));
[INFO] [stdout]       |                                             ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12847:45
[INFO] [stdout]       |
[INFO] [stdout] 12847 |          storage::VertexAttrib3dARB.aliased(&storage::VertexAttrib3dNV);
[INFO] [stdout]       |                                             ^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12847 |          storage::VertexAttrib3dARB.aliased(addr_of!(storage::VertexAttrib3dNV));
[INFO] [stdout]       |                                             ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12848:44
[INFO] [stdout]       |
[INFO] [stdout] 12848 |          storage::VertexAttrib3dNV.aliased(&storage::VertexAttrib3d);
[INFO] [stdout]       |                                            ^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12848 |          storage::VertexAttrib3dNV.aliased(addr_of!(storage::VertexAttrib3d));
[INFO] [stdout]       |                                            ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12849:44
[INFO] [stdout]       |
[INFO] [stdout] 12849 |          storage::VertexAttrib3dNV.aliased(&storage::VertexAttrib3dARB);
[INFO] [stdout]       |                                            ^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12849 |          storage::VertexAttrib3dNV.aliased(addr_of!(storage::VertexAttrib3dARB));
[INFO] [stdout]       |                                            ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12850:43
[INFO] [stdout]       |
[INFO] [stdout] 12850 |          storage::VertexAttrib3dv.aliased(&storage::VertexAttrib3dvARB);
[INFO] [stdout]       |                                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12850 |          storage::VertexAttrib3dv.aliased(addr_of!(storage::VertexAttrib3dvARB));
[INFO] [stdout]       |                                           ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12851:43
[INFO] [stdout]       |
[INFO] [stdout] 12851 |          storage::VertexAttrib3dv.aliased(&storage::VertexAttrib3dvNV);
[INFO] [stdout]       |                                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12851 |          storage::VertexAttrib3dv.aliased(addr_of!(storage::VertexAttrib3dvNV));
[INFO] [stdout]       |                                           ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12852:46
[INFO] [stdout]       |
[INFO] [stdout] 12852 |          storage::VertexAttrib3dvARB.aliased(&storage::VertexAttrib3dv);
[INFO] [stdout]       |                                              ^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12852 |          storage::VertexAttrib3dvARB.aliased(addr_of!(storage::VertexAttrib3dv));
[INFO] [stdout]       |                                              ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12853:46
[INFO] [stdout]       |
[INFO] [stdout] 12853 |          storage::VertexAttrib3dvARB.aliased(&storage::VertexAttrib3dvNV);
[INFO] [stdout]       |                                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12853 |          storage::VertexAttrib3dvARB.aliased(addr_of!(storage::VertexAttrib3dvNV));
[INFO] [stdout]       |                                              ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12854:45
[INFO] [stdout]       |
[INFO] [stdout] 12854 |          storage::VertexAttrib3dvNV.aliased(&storage::VertexAttrib3dv);
[INFO] [stdout]       |                                             ^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12854 |          storage::VertexAttrib3dvNV.aliased(addr_of!(storage::VertexAttrib3dv));
[INFO] [stdout]       |                                             ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12855:45
[INFO] [stdout]       |
[INFO] [stdout] 12855 |          storage::VertexAttrib3dvNV.aliased(&storage::VertexAttrib3dvARB);
[INFO] [stdout]       |                                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12855 |          storage::VertexAttrib3dvNV.aliased(addr_of!(storage::VertexAttrib3dvARB));
[INFO] [stdout]       |                                             ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12856:42
[INFO] [stdout]       |
[INFO] [stdout] 12856 |          storage::VertexAttrib3f.aliased(&storage::VertexAttrib3fARB);
[INFO] [stdout]       |                                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12856 |          storage::VertexAttrib3f.aliased(addr_of!(storage::VertexAttrib3fARB));
[INFO] [stdout]       |                                          ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12857:42
[INFO] [stdout]       |
[INFO] [stdout] 12857 |          storage::VertexAttrib3f.aliased(&storage::VertexAttrib3fNV);
[INFO] [stdout]       |                                          ^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12857 |          storage::VertexAttrib3f.aliased(addr_of!(storage::VertexAttrib3fNV));
[INFO] [stdout]       |                                          ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12858:45
[INFO] [stdout]       |
[INFO] [stdout] 12858 |          storage::VertexAttrib3fARB.aliased(&storage::VertexAttrib3f);
[INFO] [stdout]       |                                             ^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12858 |          storage::VertexAttrib3fARB.aliased(addr_of!(storage::VertexAttrib3f));
[INFO] [stdout]       |                                             ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12859:45
[INFO] [stdout]       |
[INFO] [stdout] 12859 |          storage::VertexAttrib3fARB.aliased(&storage::VertexAttrib3fNV);
[INFO] [stdout]       |                                             ^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12859 |          storage::VertexAttrib3fARB.aliased(addr_of!(storage::VertexAttrib3fNV));
[INFO] [stdout]       |                                             ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12860:44
[INFO] [stdout]       |
[INFO] [stdout] 12860 |          storage::VertexAttrib3fNV.aliased(&storage::VertexAttrib3f);
[INFO] [stdout]       |                                            ^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12860 |          storage::VertexAttrib3fNV.aliased(addr_of!(storage::VertexAttrib3f));
[INFO] [stdout]       |                                            ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12861:44
[INFO] [stdout]       |
[INFO] [stdout] 12861 |          storage::VertexAttrib3fNV.aliased(&storage::VertexAttrib3fARB);
[INFO] [stdout]       |                                            ^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12861 |          storage::VertexAttrib3fNV.aliased(addr_of!(storage::VertexAttrib3fARB));
[INFO] [stdout]       |                                            ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12862:43
[INFO] [stdout]       |
[INFO] [stdout] 12862 |          storage::VertexAttrib3fv.aliased(&storage::VertexAttrib3fvARB);
[INFO] [stdout]       |                                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12862 |          storage::VertexAttrib3fv.aliased(addr_of!(storage::VertexAttrib3fvARB));
[INFO] [stdout]       |                                           ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12863:43
[INFO] [stdout]       |
[INFO] [stdout] 12863 |          storage::VertexAttrib3fv.aliased(&storage::VertexAttrib3fvNV);
[INFO] [stdout]       |                                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12863 |          storage::VertexAttrib3fv.aliased(addr_of!(storage::VertexAttrib3fvNV));
[INFO] [stdout]       |                                           ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12864:46
[INFO] [stdout]       |
[INFO] [stdout] 12864 |          storage::VertexAttrib3fvARB.aliased(&storage::VertexAttrib3fv);
[INFO] [stdout]       |                                              ^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12864 |          storage::VertexAttrib3fvARB.aliased(addr_of!(storage::VertexAttrib3fv));
[INFO] [stdout]       |                                              ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12865:46
[INFO] [stdout]       |
[INFO] [stdout] 12865 |          storage::VertexAttrib3fvARB.aliased(&storage::VertexAttrib3fvNV);
[INFO] [stdout]       |                                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12865 |          storage::VertexAttrib3fvARB.aliased(addr_of!(storage::VertexAttrib3fvNV));
[INFO] [stdout]       |                                              ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12866:45
[INFO] [stdout]       |
[INFO] [stdout] 12866 |          storage::VertexAttrib3fvNV.aliased(&storage::VertexAttrib3fv);
[INFO] [stdout]       |                                             ^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12866 |          storage::VertexAttrib3fvNV.aliased(addr_of!(storage::VertexAttrib3fv));
[INFO] [stdout]       |                                             ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12867:45
[INFO] [stdout]       |
[INFO] [stdout] 12867 |          storage::VertexAttrib3fvNV.aliased(&storage::VertexAttrib3fvARB);
[INFO] [stdout]       |                                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12867 |          storage::VertexAttrib3fvNV.aliased(addr_of!(storage::VertexAttrib3fvARB));
[INFO] [stdout]       |                                             ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12868:42
[INFO] [stdout]       |
[INFO] [stdout] 12868 |          storage::VertexAttrib3s.aliased(&storage::VertexAttrib3sARB);
[INFO] [stdout]       |                                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12868 |          storage::VertexAttrib3s.aliased(addr_of!(storage::VertexAttrib3sARB));
[INFO] [stdout]       |                                          ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12869:42
[INFO] [stdout]       |
[INFO] [stdout] 12869 |          storage::VertexAttrib3s.aliased(&storage::VertexAttrib3sNV);
[INFO] [stdout]       |                                          ^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12869 |          storage::VertexAttrib3s.aliased(addr_of!(storage::VertexAttrib3sNV));
[INFO] [stdout]       |                                          ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12870:45
[INFO] [stdout]       |
[INFO] [stdout] 12870 |          storage::VertexAttrib3sARB.aliased(&storage::VertexAttrib3s);
[INFO] [stdout]       |                                             ^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12870 |          storage::VertexAttrib3sARB.aliased(addr_of!(storage::VertexAttrib3s));
[INFO] [stdout]       |                                             ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12871:45
[INFO] [stdout]       |
[INFO] [stdout] 12871 |          storage::VertexAttrib3sARB.aliased(&storage::VertexAttrib3sNV);
[INFO] [stdout]       |                                             ^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12871 |          storage::VertexAttrib3sARB.aliased(addr_of!(storage::VertexAttrib3sNV));
[INFO] [stdout]       |                                             ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12872:44
[INFO] [stdout]       |
[INFO] [stdout] 12872 |          storage::VertexAttrib3sNV.aliased(&storage::VertexAttrib3s);
[INFO] [stdout]       |                                            ^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12872 |          storage::VertexAttrib3sNV.aliased(addr_of!(storage::VertexAttrib3s));
[INFO] [stdout]       |                                            ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12873:44
[INFO] [stdout]       |
[INFO] [stdout] 12873 |          storage::VertexAttrib3sNV.aliased(&storage::VertexAttrib3sARB);
[INFO] [stdout]       |                                            ^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12873 |          storage::VertexAttrib3sNV.aliased(addr_of!(storage::VertexAttrib3sARB));
[INFO] [stdout]       |                                            ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12874:43
[INFO] [stdout]       |
[INFO] [stdout] 12874 |          storage::VertexAttrib3sv.aliased(&storage::VertexAttrib3svARB);
[INFO] [stdout]       |                                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12874 |          storage::VertexAttrib3sv.aliased(addr_of!(storage::VertexAttrib3svARB));
[INFO] [stdout]       |                                           ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12875:43
[INFO] [stdout]       |
[INFO] [stdout] 12875 |          storage::VertexAttrib3sv.aliased(&storage::VertexAttrib3svNV);
[INFO] [stdout]       |                                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12875 |          storage::VertexAttrib3sv.aliased(addr_of!(storage::VertexAttrib3svNV));
[INFO] [stdout]       |                                           ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12876:46
[INFO] [stdout]       |
[INFO] [stdout] 12876 |          storage::VertexAttrib3svARB.aliased(&storage::VertexAttrib3sv);
[INFO] [stdout]       |                                              ^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12876 |          storage::VertexAttrib3svARB.aliased(addr_of!(storage::VertexAttrib3sv));
[INFO] [stdout]       |                                              ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12877:46
[INFO] [stdout]       |
[INFO] [stdout] 12877 |          storage::VertexAttrib3svARB.aliased(&storage::VertexAttrib3svNV);
[INFO] [stdout]       |                                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12877 |          storage::VertexAttrib3svARB.aliased(addr_of!(storage::VertexAttrib3svNV));
[INFO] [stdout]       |                                              ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12878:45
[INFO] [stdout]       |
[INFO] [stdout] 12878 |          storage::VertexAttrib3svNV.aliased(&storage::VertexAttrib3sv);
[INFO] [stdout]       |                                             ^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12878 |          storage::VertexAttrib3svNV.aliased(addr_of!(storage::VertexAttrib3sv));
[INFO] [stdout]       |                                             ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12879:45
[INFO] [stdout]       |
[INFO] [stdout] 12879 |          storage::VertexAttrib3svNV.aliased(&storage::VertexAttrib3svARB);
[INFO] [stdout]       |                                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12879 |          storage::VertexAttrib3svNV.aliased(addr_of!(storage::VertexAttrib3svARB));
[INFO] [stdout]       |                                             ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12880:43
[INFO] [stdout]       |
[INFO] [stdout] 12880 |          storage::VertexAttrib4bv.aliased(&storage::VertexAttrib4bvARB);
[INFO] [stdout]       |                                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12880 |          storage::VertexAttrib4bv.aliased(addr_of!(storage::VertexAttrib4bvARB));
[INFO] [stdout]       |                                           ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12881:46
[INFO] [stdout]       |
[INFO] [stdout] 12881 |          storage::VertexAttrib4bvARB.aliased(&storage::VertexAttrib4bv);
[INFO] [stdout]       |                                              ^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12881 |          storage::VertexAttrib4bvARB.aliased(addr_of!(storage::VertexAttrib4bv));
[INFO] [stdout]       |                                              ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12882:42
[INFO] [stdout]       |
[INFO] [stdout] 12882 |          storage::VertexAttrib4d.aliased(&storage::VertexAttrib4dARB);
[INFO] [stdout]       |                                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[INFO] [stdout] help: shared references are dangerous since if there's any kind of mutation of that static while the reference lives, that's UB; use `addr_of!` instead to create a raw pointer
[INFO] [stdout]       |
[INFO] [stdout] 12882 |          storage::VertexAttrib4d.aliased(addr_of!(storage::VertexAttrib4dARB));
[INFO] [stdout]       |                                          ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: shared reference of mutable static is discouraged
[INFO] [stdout]      --> 3rdparty/glad-gl/src/gl.rs:12883:42
[INFO] [stdout]       |
[INFO] [stdout] 12883 |          storage::VertexAttrib4d.aliased(&storage::VertexAttrib4dNV);
[INFO] [stdout]       |                                          ^^^^^^^^^^^^^^^^^^^^^^^^^^ shared reference of mutable static
[INFO] [stdout]       |
[INFO] [stdout]       = note: for more information, see issue #114447 <https://github.com/rust-lang/rust/issues/114447>
[INFO] [stdout]       = note: reference of mutable static is a hard error from 2024 edition
[INFO] [stdout]       = note: mutable statics can be written to by multiple threads: aliasing violations or data races will cause undefined behavior
[WARN] too many lines in the log, truncating it
