[INFO] fetching crate matrixstack 0.1.4...
[INFO] checking matrixstack-0.1.4 against master#c2f2db79ca3024f68d22b45aa22b570775c2c4ad for pr-124157
[INFO] extracting crate matrixstack 0.1.4 into /workspace/builds/worker-2-tc1/source
[INFO] validating manifest of crates.io crate matrixstack 0.1.4 on toolchain c2f2db79ca3024f68d22b45aa22b570775c2c4ad
[INFO] running `Command { std: CARGO_HOME="/workspace/cargo-home" RUSTUP_HOME="/workspace/rustup-home" "/workspace/cargo-home/bin/cargo" "+c2f2db79ca3024f68d22b45aa22b570775c2c4ad" "metadata" "--manifest-path" "Cargo.toml" "--no-deps", kill_on_drop: false }`
[INFO] started tweaking crates.io crate matrixstack 0.1.4
[INFO] finished tweaking crates.io crate matrixstack 0.1.4
[INFO] tweaked toml for crates.io crate matrixstack 0.1.4 written to /workspace/builds/worker-2-tc1/source/Cargo.toml
[INFO] running `Command { std: CARGO_HOME="/workspace/cargo-home" RUSTUP_HOME="/workspace/rustup-home" "/workspace/cargo-home/bin/cargo" "+c2f2db79ca3024f68d22b45aa22b570775c2c4ad" "generate-lockfile" "--manifest-path" "Cargo.toml", kill_on_drop: false }`
[INFO] [stderr]     Updating crates.io index
[INFO] [stderr]      Locking 16 packages to latest compatible versions
[INFO] [stderr]       Adding cgmath v0.10.0 (latest: v0.18.0)
[INFO] [stderr]       Adding num-traits v0.1.43 (latest: v0.2.18)
[INFO] [stderr]       Adding rand v0.3.23 (latest: v0.8.5)
[INFO] [stderr]       Adding rand v0.4.6 (latest: v0.8.5)
[INFO] [stderr]       Adding rand_core v0.3.1 (latest: v0.6.4)
[INFO] [stderr]       Adding rand_core v0.4.2 (latest: v0.6.4)
[INFO] [stderr]       Adding rdrand v0.4.0 (latest: v0.8.3)
[INFO] running `Command { std: CARGO_HOME="/workspace/cargo-home" RUSTUP_HOME="/workspace/rustup-home" "/workspace/cargo-home/bin/cargo" "+c2f2db79ca3024f68d22b45aa22b570775c2c4ad" "fetch" "--manifest-path" "Cargo.toml", kill_on_drop: false }`
[INFO] [stderr]  Downloading crates ...
[INFO] [stderr]   Downloaded cgmath v0.10.0
[INFO] running `Command { std: "docker" "create" "-v" "/var/lib/crater-agent-workspace/builds/worker-2-tc1/target:/opt/rustwide/target:rw,Z" "-v" "/var/lib/crater-agent-workspace/builds/worker-2-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:99613afd962a8cfa530ec1899472a458bd015a1ab0af876cf7eb06f6006d81ea" "/opt/rustwide/cargo-home/bin/cargo" "+c2f2db79ca3024f68d22b45aa22b570775c2c4ad" "metadata" "--no-deps" "--format-version=1", kill_on_drop: false }`
[INFO] [stdout] 8ea57c91b5d864e655f0805fdcfa4e149b46e19c54367244624076eea7653dd2
[INFO] running `Command { std: "docker" "start" "-a" "8ea57c91b5d864e655f0805fdcfa4e149b46e19c54367244624076eea7653dd2", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "inspect" "8ea57c91b5d864e655f0805fdcfa4e149b46e19c54367244624076eea7653dd2", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "rm" "-f" "8ea57c91b5d864e655f0805fdcfa4e149b46e19c54367244624076eea7653dd2", kill_on_drop: false }`
[INFO] [stdout] 8ea57c91b5d864e655f0805fdcfa4e149b46e19c54367244624076eea7653dd2
[INFO] running `Command { std: "docker" "create" "-v" "/var/lib/crater-agent-workspace/builds/worker-2-tc1/target:/opt/rustwide/target:rw,Z" "-v" "/var/lib/crater-agent-workspace/builds/worker-2-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=forbid" "-e" "RUSTDOCFLAGS=--cap-lints=forbid" "-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:99613afd962a8cfa530ec1899472a458bd015a1ab0af876cf7eb06f6006d81ea" "/opt/rustwide/cargo-home/bin/cargo" "+c2f2db79ca3024f68d22b45aa22b570775c2c4ad" "check" "--frozen" "--all" "--all-targets" "--message-format=json", kill_on_drop: false }`
[INFO] [stdout] e295fcaaf10aaf7b118d868e31478cd9ea3cf2c1788621b030c0c4a14748f326
[INFO] running `Command { std: "docker" "start" "-a" "e295fcaaf10aaf7b118d868e31478cd9ea3cf2c1788621b030c0c4a14748f326", kill_on_drop: false }`
[INFO] [stderr]     Checking rustc-serialize v0.3.25
[INFO] [stderr]     Checking rand v0.4.6
[INFO] [stderr]     Checking num-traits v0.1.43
[INFO] [stderr]     Checking rand v0.3.23
[INFO] [stderr]     Checking cgmath v0.10.0
[INFO] [stdout] error[E0277]: the trait bound `S: Copy` is not satisfied
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/rotation.rs:146:5
[INFO] [stdout]     |
[INFO] [stdout] 143 | #[cfg_attr(feature = "rustc-serialize", derive(RustcEncodable, RustcDecodable))]
[INFO] [stdout]     |                                                --------------
[INFO] [stdout]     |                                                |
[INFO] [stdout]     |                                                required by a bound introduced by this call
[INFO] [stdout]     |                                                in this derive macro expansion
[INFO] [stdout] ...
[INFO] [stdout] 146 |     mat: Matrix2<S>
[INFO] [stdout]     |     ^^^^^^^^^^^^^^^ the trait `Copy` is not implemented for `S`, which is required by `&Matrix2<S>: Encodable`
[INFO] [stdout]     |
[INFO] [stdout] note: required for `Matrix2<S>` to implement `Encodable`
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/matrix.rs:39:48
[INFO] [stdout]     |
[INFO] [stdout] 39  | #[cfg_attr(feature = "rustc-serialize", derive(RustcEncodable, RustcDecodable))]
[INFO] [stdout]     |                                                ^^^^^^^^^^^^^^ unsatisfied trait bound introduced in this `derive` macro
[INFO] [stdout]     = note: 1 redundant requirement hidden
[INFO] [stdout]     = note: required for `&Matrix2<S>` to implement `Encodable`
[INFO] [stdout]     = note: this error originates in the derive macro `RustcEncodable` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: consider restricting type parameter `S`
[INFO] [stdout]     |
[INFO] [stdout] 145 | pub struct Basis2<S: std::marker::Copy> {
[INFO] [stdout]     |                    +++++++++++++++++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0277]: the trait bound `S: Copy` is not satisfied
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/rotation.rs:146:5
[INFO] [stdout]     |
[INFO] [stdout] 143 | #[cfg_attr(feature = "rustc-serialize", derive(RustcEncodable, RustcDecodable))]
[INFO] [stdout]     |                                                                -------------- in this derive macro expansion
[INFO] [stdout] ...
[INFO] [stdout] 146 |     mat: Matrix2<S>
[INFO] [stdout]     |     ^^^^^^^^^^^^^^^ the trait `Copy` is not implemented for `S`, which is required by `Matrix2<_>: Decodable`
[INFO] [stdout]     |
[INFO] [stdout] note: required for `Matrix2<S>` to implement `Decodable`
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/matrix.rs:39:64
[INFO] [stdout]     |
[INFO] [stdout] 39  | #[cfg_attr(feature = "rustc-serialize", derive(RustcEncodable, RustcDecodable))]
[INFO] [stdout]     |                                                                ^^^^^^^^^^^^^^ unsatisfied trait bound introduced in this `derive` macro
[INFO] [stdout]     = note: this error originates in the derive macro `RustcDecodable` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: consider restricting type parameter `S`
[INFO] [stdout]     |
[INFO] [stdout] 145 | pub struct Basis2<S: std::marker::Copy> {
[INFO] [stdout]     |                    +++++++++++++++++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0277]: the trait bound `S: Copy` is not satisfied
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/rotation.rs:143:64
[INFO] [stdout]     |
[INFO] [stdout] 143 | #[cfg_attr(feature = "rustc-serialize", derive(RustcEncodable, RustcDecodable))]
[INFO] [stdout]     |                                                                ^^^^^^^^^^^^^^ the trait `Copy` is not implemented for `S`, which is required by `Matrix2<_>: Decodable`
[INFO] [stdout]     |
[INFO] [stdout] note: required for `Matrix2<S>` to implement `Decodable`
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/matrix.rs:39:64
[INFO] [stdout]     |
[INFO] [stdout] 39  | #[cfg_attr(feature = "rustc-serialize", derive(RustcEncodable, RustcDecodable))]
[INFO] [stdout]     |                                                                ^^^^^^^^^^^^^^ unsatisfied trait bound introduced in this `derive` macro
[INFO] [stdout]     = note: this error originates in the derive macro `RustcDecodable` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: consider restricting type parameter `S`
[INFO] [stdout]     |
[INFO] [stdout] 145 | pub struct Basis2<S: std::marker::Copy> {
[INFO] [stdout]     |                    +++++++++++++++++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0369]: binary operation `==` cannot be applied to type `Matrix2<S>`
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/rotation.rs:146:5
[INFO] [stdout]     |
[INFO] [stdout] 142 | #[derive(PartialEq, Copy, Clone)]
[INFO] [stdout]     |          --------- in this derive macro expansion
[INFO] [stdout] ...
[INFO] [stdout] 146 |     mat: Matrix2<S>
[INFO] [stdout]     |     ^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this error originates in the derive macro `PartialEq` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: consider restricting type parameter `S`
[INFO] [stdout]     |
[INFO] [stdout] 145 | pub struct Basis2<S: std::marker::Copy> {
[INFO] [stdout]     |                    +++++++++++++++++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0277]: the trait bound `S: Copy` is not satisfied
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/rotation.rs:146:5
[INFO] [stdout]     |
[INFO] [stdout] 142 | #[derive(PartialEq, Copy, Clone)]
[INFO] [stdout]     |                           ----- in this derive macro expansion
[INFO] [stdout] ...
[INFO] [stdout] 146 |     mat: Matrix2<S>
[INFO] [stdout]     |     ^^^^^^^^^^^^^^^ the trait `Copy` is not implemented for `S`, which is required by `Matrix2<S>: Clone`
[INFO] [stdout]     |
[INFO] [stdout] note: required for `Matrix2<S>` to implement `Clone`
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/matrix.rs:38:16
[INFO] [stdout]     |
[INFO] [stdout] 38  | #[derive(Copy, Clone, PartialEq)]
[INFO] [stdout]     |                ^^^^^ unsatisfied trait bound introduced in this `derive` macro
[INFO] [stdout]     = note: this error originates in the derive macro `Clone` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: consider restricting type parameter `S`
[INFO] [stdout]     |
[INFO] [stdout] 145 | pub struct Basis2<S: std::marker::Copy> {
[INFO] [stdout]     |                    +++++++++++++++++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0277]: the trait bound `S: Copy` is not satisfied
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/rotation.rs:220:5
[INFO] [stdout]     |
[INFO] [stdout] 217 | #[cfg_attr(feature = "rustc-serialize", derive(RustcEncodable, RustcDecodable))]
[INFO] [stdout]     |                                                --------------
[INFO] [stdout]     |                                                |
[INFO] [stdout]     |                                                required by a bound introduced by this call
[INFO] [stdout]     |                                                in this derive macro expansion
[INFO] [stdout] ...
[INFO] [stdout] 220 |     mat: Matrix3<S>
[INFO] [stdout]     |     ^^^^^^^^^^^^^^^ the trait `Copy` is not implemented for `S`, which is required by `&Matrix3<S>: Encodable`
[INFO] [stdout]     |
[INFO] [stdout] note: required for `Matrix3<S>` to implement `Encodable`
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/matrix.rs:53:48
[INFO] [stdout]     |
[INFO] [stdout] 53  | #[cfg_attr(feature = "rustc-serialize", derive(RustcEncodable, RustcDecodable))]
[INFO] [stdout]     |                                                ^^^^^^^^^^^^^^ unsatisfied trait bound introduced in this `derive` macro
[INFO] [stdout]     = note: 1 redundant requirement hidden
[INFO] [stdout]     = note: required for `&Matrix3<S>` to implement `Encodable`
[INFO] [stdout]     = note: this error originates in the derive macro `RustcEncodable` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: consider restricting type parameter `S`
[INFO] [stdout]     |
[INFO] [stdout] 219 | pub struct Basis3<S: std::marker::Copy> {
[INFO] [stdout]     |                    +++++++++++++++++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0277]: the trait bound `S: Copy` is not satisfied
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/rotation.rs:220:5
[INFO] [stdout]     |
[INFO] [stdout] 217 | #[cfg_attr(feature = "rustc-serialize", derive(RustcEncodable, RustcDecodable))]
[INFO] [stdout]     |                                                                -------------- in this derive macro expansion
[INFO] [stdout] ...
[INFO] [stdout] 220 |     mat: Matrix3<S>
[INFO] [stdout]     |     ^^^^^^^^^^^^^^^ the trait `Copy` is not implemented for `S`, which is required by `Matrix3<_>: Decodable`
[INFO] [stdout]     |
[INFO] [stdout] note: required for `Matrix3<S>` to implement `Decodable`
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/matrix.rs:53:64
[INFO] [stdout]     |
[INFO] [stdout] 53  | #[cfg_attr(feature = "rustc-serialize", derive(RustcEncodable, RustcDecodable))]
[INFO] [stdout]     |                                                                ^^^^^^^^^^^^^^ unsatisfied trait bound introduced in this `derive` macro
[INFO] [stdout]     = note: this error originates in the derive macro `RustcDecodable` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: consider restricting type parameter `S`
[INFO] [stdout]     |
[INFO] [stdout] 219 | pub struct Basis3<S: std::marker::Copy> {
[INFO] [stdout]     |                    +++++++++++++++++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0277]: the trait bound `S: Copy` is not satisfied
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/rotation.rs:217:64
[INFO] [stdout]     |
[INFO] [stdout] 217 | #[cfg_attr(feature = "rustc-serialize", derive(RustcEncodable, RustcDecodable))]
[INFO] [stdout]     |                                                                ^^^^^^^^^^^^^^ the trait `Copy` is not implemented for `S`, which is required by `Matrix3<_>: Decodable`
[INFO] [stdout]     |
[INFO] [stdout] note: required for `Matrix3<S>` to implement `Decodable`
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/matrix.rs:53:64
[INFO] [stdout]     |
[INFO] [stdout] 53  | #[cfg_attr(feature = "rustc-serialize", derive(RustcEncodable, RustcDecodable))]
[INFO] [stdout]     |                                                                ^^^^^^^^^^^^^^ unsatisfied trait bound introduced in this `derive` macro
[INFO] [stdout]     = note: this error originates in the derive macro `RustcDecodable` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: consider restricting type parameter `S`
[INFO] [stdout]     |
[INFO] [stdout] 219 | pub struct Basis3<S: std::marker::Copy> {
[INFO] [stdout]     |                    +++++++++++++++++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0369]: binary operation `==` cannot be applied to type `Matrix3<S>`
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/rotation.rs:220:5
[INFO] [stdout]     |
[INFO] [stdout] 216 | #[derive(PartialEq, Copy, Clone)]
[INFO] [stdout]     |          --------- in this derive macro expansion
[INFO] [stdout] ...
[INFO] [stdout] 220 |     mat: Matrix3<S>
[INFO] [stdout]     |     ^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this error originates in the derive macro `PartialEq` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: consider restricting type parameter `S`
[INFO] [stdout]     |
[INFO] [stdout] 219 | pub struct Basis3<S: std::marker::Copy> {
[INFO] [stdout]     |                    +++++++++++++++++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0277]: the trait bound `S: Copy` is not satisfied
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/rotation.rs:220:5
[INFO] [stdout]     |
[INFO] [stdout] 216 | #[derive(PartialEq, Copy, Clone)]
[INFO] [stdout]     |                           ----- in this derive macro expansion
[INFO] [stdout] ...
[INFO] [stdout] 220 |     mat: Matrix3<S>
[INFO] [stdout]     |     ^^^^^^^^^^^^^^^ the trait `Copy` is not implemented for `S`, which is required by `Matrix3<S>: Clone`
[INFO] [stdout]     |
[INFO] [stdout] note: required for `Matrix3<S>` to implement `Clone`
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/matrix.rs:52:16
[INFO] [stdout]     |
[INFO] [stdout] 52  | #[derive(Copy, Clone, PartialEq)]
[INFO] [stdout]     |                ^^^^^ unsatisfied trait bound introduced in this `derive` macro
[INFO] [stdout]     = note: this error originates in the derive macro `Clone` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: consider restricting type parameter `S`
[INFO] [stdout]     |
[INFO] [stdout] 219 | pub struct Basis3<S: std::marker::Copy> {
[INFO] [stdout]     |                    +++++++++++++++++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0277]: the trait bound `S: Copy` is not satisfied
[INFO] [stdout]   --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/projection.rs:73:5
[INFO] [stdout]    |
[INFO] [stdout] 70 | #[cfg_attr(feature = "rustc-serialize", derive(RustcEncodable, RustcDecodable))]
[INFO] [stdout]    |                                                --------------
[INFO] [stdout]    |                                                |
[INFO] [stdout]    |                                                required by a bound introduced by this call
[INFO] [stdout]    |                                                in this derive macro expansion
[INFO] [stdout] ...
[INFO] [stdout] 73 |     pub fovy:   Rad<S>,
[INFO] [stdout]    |     ^^^^^^^^^^^^^^^^^^ the trait `Copy` is not implemented for `S`, which is required by `&Rad<S>: Encodable`
[INFO] [stdout]    |
[INFO] [stdout] note: required for `Rad<S>` to implement `Encodable`
[INFO] [stdout]   --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/angle.rs:36:48
[INFO] [stdout]    |
[INFO] [stdout] 36 | #[cfg_attr(feature = "rustc-serialize", derive(RustcEncodable, RustcDecodable))]
[INFO] [stdout]    |                                                ^^^^^^^^^^^^^^ unsatisfied trait bound introduced in this `derive` macro
[INFO] [stdout]    = note: 1 redundant requirement hidden
[INFO] [stdout]    = note: required for `&Rad<S>` to implement `Encodable`
[INFO] [stdout]    = note: this error originates in the derive macro `RustcEncodable` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: consider restricting type parameter `S`
[INFO] [stdout]    |
[INFO] [stdout] 72 | pub struct PerspectiveFov<S: std::marker::Copy> {
[INFO] [stdout]    |                            +++++++++++++++++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0277]: the trait bound `S: Copy` is not satisfied
[INFO] [stdout]   --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/projection.rs:73:5
[INFO] [stdout]    |
[INFO] [stdout] 70 | #[cfg_attr(feature = "rustc-serialize", derive(RustcEncodable, RustcDecodable))]
[INFO] [stdout]    |                                                                -------------- in this derive macro expansion
[INFO] [stdout] ...
[INFO] [stdout] 73 |     pub fovy:   Rad<S>,
[INFO] [stdout]    |     ^^^^^^^^^^^^^^^^^^ the trait `Copy` is not implemented for `S`, which is required by `Rad<_>: Decodable`
[INFO] [stdout]    |
[INFO] [stdout] note: required for `Rad<S>` to implement `Decodable`
[INFO] [stdout]   --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/angle.rs:36:64
[INFO] [stdout]    |
[INFO] [stdout] 36 | #[cfg_attr(feature = "rustc-serialize", derive(RustcEncodable, RustcDecodable))]
[INFO] [stdout]    |                                                                ^^^^^^^^^^^^^^ unsatisfied trait bound introduced in this `derive` macro
[INFO] [stdout]    = note: this error originates in the derive macro `RustcDecodable` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: consider restricting type parameter `S`
[INFO] [stdout]    |
[INFO] [stdout] 72 | pub struct PerspectiveFov<S: std::marker::Copy> {
[INFO] [stdout]    |                            +++++++++++++++++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0277]: the trait bound `S: Copy` is not satisfied
[INFO] [stdout]   --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/projection.rs:70:64
[INFO] [stdout]    |
[INFO] [stdout] 70 | #[cfg_attr(feature = "rustc-serialize", derive(RustcEncodable, RustcDecodable))]
[INFO] [stdout]    |                                                                ^^^^^^^^^^^^^^ the trait `Copy` is not implemented for `S`, which is required by `Rad<_>: Decodable`
[INFO] [stdout]    |
[INFO] [stdout] note: required for `Rad<S>` to implement `Decodable`
[INFO] [stdout]   --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/angle.rs:36:64
[INFO] [stdout]    |
[INFO] [stdout] 36 | #[cfg_attr(feature = "rustc-serialize", derive(RustcEncodable, RustcDecodable))]
[INFO] [stdout]    |                                                                ^^^^^^^^^^^^^^ unsatisfied trait bound introduced in this `derive` macro
[INFO] [stdout]    = note: this error originates in the derive macro `RustcDecodable` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: consider restricting type parameter `S`
[INFO] [stdout]    |
[INFO] [stdout] 72 | pub struct PerspectiveFov<S: std::marker::Copy> {
[INFO] [stdout]    |                            +++++++++++++++++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0277]: the trait bound `S: Copy` is not satisfied
[INFO] [stdout]   --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/projection.rs:73:5
[INFO] [stdout]    |
[INFO] [stdout] 69 | #[derive(Copy, Clone, Debug, PartialEq)]
[INFO] [stdout]    |                ----- in this derive macro expansion
[INFO] [stdout] ...
[INFO] [stdout] 73 |     pub fovy:   Rad<S>,
[INFO] [stdout]    |     ^^^^^^^^^^^^^^^^^^ the trait `Copy` is not implemented for `S`, which is required by `Rad<S>: Clone`
[INFO] [stdout]    |
[INFO] [stdout] note: required for `Rad<S>` to implement `Clone`
[INFO] [stdout]   --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/angle.rs:35:16
[INFO] [stdout]    |
[INFO] [stdout] 35 | #[derive(Copy, Clone, PartialEq, PartialOrd)]
[INFO] [stdout]    |                ^^^^^ unsatisfied trait bound introduced in this `derive` macro
[INFO] [stdout]    = note: this error originates in the derive macro `Clone` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: consider restricting type parameter `S`
[INFO] [stdout]    |
[INFO] [stdout] 72 | pub struct PerspectiveFov<S: std::marker::Copy> {
[INFO] [stdout]    |                            +++++++++++++++++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0369]: binary operation `==` cannot be applied to type `Rad<S>`
[INFO] [stdout]   --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/projection.rs:73:5
[INFO] [stdout]    |
[INFO] [stdout] 69 | #[derive(Copy, Clone, Debug, PartialEq)]
[INFO] [stdout]    |                              --------- in this derive macro expansion
[INFO] [stdout] ...
[INFO] [stdout] 73 |     pub fovy:   Rad<S>,
[INFO] [stdout]    |     ^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this error originates in the derive macro `PartialEq` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: consider restricting type parameter `S`
[INFO] [stdout]    |
[INFO] [stdout] 72 | pub struct PerspectiveFov<S: std::marker::Copy> {
[INFO] [stdout]    |                            +++++++++++++++++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/matrix.rs:240:22
[INFO] [stdout]     |
[INFO] [stdout] 240 |         Matrix4::new(s.x.clone(), u.x.clone(), -f.x.clone(), S::zero(),
[INFO] [stdout]     |                      ^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/matrix.rs:240:35
[INFO] [stdout]     |
[INFO] [stdout] 240 |         Matrix4::new(s.x.clone(), u.x.clone(), -f.x.clone(), S::zero(),
[INFO] [stdout]     |                                   ^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/matrix.rs:240:49
[INFO] [stdout]     |
[INFO] [stdout] 240 |         Matrix4::new(s.x.clone(), u.x.clone(), -f.x.clone(), S::zero(),
[INFO] [stdout]     |                                                 ^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/matrix.rs:241:22
[INFO] [stdout]     |
[INFO] [stdout] 241 |                      s.y.clone(), u.y.clone(), -f.y.clone(), S::zero(),
[INFO] [stdout]     |                      ^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/matrix.rs:241:35
[INFO] [stdout]     |
[INFO] [stdout] 241 |                      s.y.clone(), u.y.clone(), -f.y.clone(), S::zero(),
[INFO] [stdout]     |                                   ^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/matrix.rs:241:49
[INFO] [stdout]     |
[INFO] [stdout] 241 |                      s.y.clone(), u.y.clone(), -f.y.clone(), S::zero(),
[INFO] [stdout]     |                                                 ^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/matrix.rs:242:22
[INFO] [stdout]     |
[INFO] [stdout] 242 |                      s.z.clone(), u.z.clone(), -f.z.clone(), S::zero(),
[INFO] [stdout]     |                      ^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/matrix.rs:242:35
[INFO] [stdout]     |
[INFO] [stdout] 242 |                      s.z.clone(), u.z.clone(), -f.z.clone(), S::zero(),
[INFO] [stdout]     |                                   ^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/matrix.rs:242:49
[INFO] [stdout]     |
[INFO] [stdout] 242 |                      s.z.clone(), u.z.clone(), -f.z.clone(), S::zero(),
[INFO] [stdout]     |                                                 ^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/matrix.rs:682:45
[INFO] [stdout]     |
[INFO] [stdout] 682 |                     0 => Matrix3::from_cols(t.y.truncate_n(j), t.z.truncate_n(j), t.w.truncate_n(j)),
[INFO] [stdout]     |                                             ^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/matrix.rs:682:64
[INFO] [stdout]     |
[INFO] [stdout] 682 |                     0 => Matrix3::from_cols(t.y.truncate_n(j), t.z.truncate_n(j), t.w.truncate_n(j)),
[INFO] [stdout]     |                                                                ^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/matrix.rs:682:83
[INFO] [stdout]     |
[INFO] [stdout] 682 |                     0 => Matrix3::from_cols(t.y.truncate_n(j), t.z.truncate_n(j), t.w.truncate_n(j)),
[INFO] [stdout]     |                                                                                   ^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/matrix.rs:683:45
[INFO] [stdout]     |
[INFO] [stdout] 683 |                     1 => Matrix3::from_cols(t.x.truncate_n(j), t.z.truncate_n(j), t.w.truncate_n(j)),
[INFO] [stdout]     |                                             ^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/matrix.rs:683:64
[INFO] [stdout]     |
[INFO] [stdout] 683 |                     1 => Matrix3::from_cols(t.x.truncate_n(j), t.z.truncate_n(j), t.w.truncate_n(j)),
[INFO] [stdout]     |                                                                ^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/matrix.rs:683:83
[INFO] [stdout]     |
[INFO] [stdout] 683 |                     1 => Matrix3::from_cols(t.x.truncate_n(j), t.z.truncate_n(j), t.w.truncate_n(j)),
[INFO] [stdout]     |                                                                                   ^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/matrix.rs:684:45
[INFO] [stdout]     |
[INFO] [stdout] 684 |                     2 => Matrix3::from_cols(t.x.truncate_n(j), t.y.truncate_n(j), t.w.truncate_n(j)),
[INFO] [stdout]     |                                             ^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/matrix.rs:684:64
[INFO] [stdout]     |
[INFO] [stdout] 684 |                     2 => Matrix3::from_cols(t.x.truncate_n(j), t.y.truncate_n(j), t.w.truncate_n(j)),
[INFO] [stdout]     |                                                                ^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/matrix.rs:684:83
[INFO] [stdout]     |
[INFO] [stdout] 684 |                     2 => Matrix3::from_cols(t.x.truncate_n(j), t.y.truncate_n(j), t.w.truncate_n(j)),
[INFO] [stdout]     |                                                                                   ^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/matrix.rs:685:45
[INFO] [stdout]     |
[INFO] [stdout] 685 |                     3 => Matrix3::from_cols(t.x.truncate_n(j), t.y.truncate_n(j), t.z.truncate_n(j)),
[INFO] [stdout]     |                                             ^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/matrix.rs:685:64
[INFO] [stdout]     |
[INFO] [stdout] 685 |                     3 => Matrix3::from_cols(t.x.truncate_n(j), t.y.truncate_n(j), t.z.truncate_n(j)),
[INFO] [stdout]     |                                                                ^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/matrix.rs:685:83
[INFO] [stdout]     |
[INFO] [stdout] 685 |                     3 => Matrix3::from_cols(t.x.truncate_n(j), t.y.truncate_n(j), t.z.truncate_n(j)),
[INFO] [stdout]     |                                                                                   ^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/matrix.rs:871:50
[INFO] [stdout]     |
[INFO] [stdout] 871 |             fn mul_assign(&mut self, scalar) { $(self.$field *= scalar);+ }
[INFO] [stdout]     |                                                  ^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 926 | impl_operators!(Matrix2, Vector2 { x: 0, y: 1 });
[INFO] [stdout]     | ------------------------------------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_operators` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/matrix.rs:874:50
[INFO] [stdout]     |
[INFO] [stdout] 874 |             fn div_assign(&mut self, scalar) { $(self.$field /= scalar);+ }
[INFO] [stdout]     |                                                  ^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 926 | impl_operators!(Matrix2, Vector2 { x: 0, y: 1 });
[INFO] [stdout]     | ------------------------------------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_operators` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/matrix.rs:877:50
[INFO] [stdout]     |
[INFO] [stdout] 877 |             fn rem_assign(&mut self, scalar) { $(self.$field %= scalar);+ }
[INFO] [stdout]     |                                                  ^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 926 | impl_operators!(Matrix2, Vector2 { x: 0, y: 1 });
[INFO] [stdout]     | ------------------------------------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_operators` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/matrix.rs:887:62
[INFO] [stdout]     |
[INFO] [stdout] 887 |             fn add_assign(&mut self, other: $MatrixN<S>) { $(self.$field += other.$field);+ }
[INFO] [stdout]     |                                                              ^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 926 | impl_operators!(Matrix2, Vector2 { x: 0, y: 1 });
[INFO] [stdout]     | ------------------------------------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_operators` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/matrix.rs:890:62
[INFO] [stdout]     |
[INFO] [stdout] 890 |             fn sub_assign(&mut self, other: $MatrixN<S>) { $(self.$field -= other.$field);+ }
[INFO] [stdout]     |                                                              ^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 926 | impl_operators!(Matrix2, Vector2 { x: 0, y: 1 });
[INFO] [stdout]     | ------------------------------------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_operators` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/matrix.rs:871:50
[INFO] [stdout]     |
[INFO] [stdout] 871 |             fn mul_assign(&mut self, scalar) { $(self.$field *= scalar);+ }
[INFO] [stdout]     |                                                  ^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 927 | impl_operators!(Matrix3, Vector3 { x: 0, y: 1, z: 2 });
[INFO] [stdout]     | ------------------------------------------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_operators` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/matrix.rs:874:50
[INFO] [stdout]     |
[INFO] [stdout] 874 |             fn div_assign(&mut self, scalar) { $(self.$field /= scalar);+ }
[INFO] [stdout]     |                                                  ^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 927 | impl_operators!(Matrix3, Vector3 { x: 0, y: 1, z: 2 });
[INFO] [stdout]     | ------------------------------------------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_operators` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/matrix.rs:877:50
[INFO] [stdout]     |
[INFO] [stdout] 877 |             fn rem_assign(&mut self, scalar) { $(self.$field %= scalar);+ }
[INFO] [stdout]     |                                                  ^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 927 | impl_operators!(Matrix3, Vector3 { x: 0, y: 1, z: 2 });
[INFO] [stdout]     | ------------------------------------------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_operators` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/matrix.rs:887:62
[INFO] [stdout]     |
[INFO] [stdout] 887 |             fn add_assign(&mut self, other: $MatrixN<S>) { $(self.$field += other.$field);+ }
[INFO] [stdout]     |                                                              ^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 927 | impl_operators!(Matrix3, Vector3 { x: 0, y: 1, z: 2 });
[INFO] [stdout]     | ------------------------------------------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_operators` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/matrix.rs:890:62
[INFO] [stdout]     |
[INFO] [stdout] 890 |             fn sub_assign(&mut self, other: $MatrixN<S>) { $(self.$field -= other.$field);+ }
[INFO] [stdout]     |                                                              ^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 927 | impl_operators!(Matrix3, Vector3 { x: 0, y: 1, z: 2 });
[INFO] [stdout]     | ------------------------------------------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_operators` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/matrix.rs:871:50
[INFO] [stdout]     |
[INFO] [stdout] 871 |             fn mul_assign(&mut self, scalar) { $(self.$field *= scalar);+ }
[INFO] [stdout]     |                                                  ^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 928 | impl_operators!(Matrix4, Vector4 { x: 0, y: 1, z: 2, w: 3 });
[INFO] [stdout]     | ------------------------------------------------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_operators` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/matrix.rs:874:50
[INFO] [stdout]     |
[INFO] [stdout] 874 |             fn div_assign(&mut self, scalar) { $(self.$field /= scalar);+ }
[INFO] [stdout]     |                                                  ^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 928 | impl_operators!(Matrix4, Vector4 { x: 0, y: 1, z: 2, w: 3 });
[INFO] [stdout]     | ------------------------------------------------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_operators` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/matrix.rs:877:50
[INFO] [stdout]     |
[INFO] [stdout] 877 |             fn rem_assign(&mut self, scalar) { $(self.$field %= scalar);+ }
[INFO] [stdout]     |                                                  ^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 928 | impl_operators!(Matrix4, Vector4 { x: 0, y: 1, z: 2, w: 3 });
[INFO] [stdout]     | ------------------------------------------------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_operators` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/matrix.rs:887:62
[INFO] [stdout]     |
[INFO] [stdout] 887 |             fn add_assign(&mut self, other: $MatrixN<S>) { $(self.$field += other.$field);+ }
[INFO] [stdout]     |                                                              ^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 928 | impl_operators!(Matrix4, Vector4 { x: 0, y: 1, z: 2, w: 3 });
[INFO] [stdout]     | ------------------------------------------------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_operators` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/matrix.rs:890:62
[INFO] [stdout]     |
[INFO] [stdout] 890 |             fn sub_assign(&mut self, other: $MatrixN<S>) { $(self.$field -= other.$field);+ }
[INFO] [stdout]     |                                                              ^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 928 | impl_operators!(Matrix4, Vector4 { x: 0, y: 1, z: 2, w: 3 });
[INFO] [stdout]     | ------------------------------------------------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_operators` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/quaternion.rs:190:40
[INFO] [stdout]     |
[INFO] [stdout] 190 |     fn mul_assign(&mut self, scalar) { self.s *= scalar; self.v *= scalar; }
[INFO] [stdout]     |                                        ^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/quaternion.rs:190:58
[INFO] [stdout]     |
[INFO] [stdout] 190 |     fn mul_assign(&mut self, scalar) { self.s *= scalar; self.v *= scalar; }
[INFO] [stdout]     |                                                          ^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/quaternion.rs:199:40
[INFO] [stdout]     |
[INFO] [stdout] 199 |     fn div_assign(&mut self, scalar) { self.s /= scalar; self.v /= scalar; }
[INFO] [stdout]     |                                        ^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/quaternion.rs:199:58
[INFO] [stdout]     |
[INFO] [stdout] 199 |     fn div_assign(&mut self, scalar) { self.s /= scalar; self.v /= scalar; }
[INFO] [stdout]     |                                                          ^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/quaternion.rs:208:40
[INFO] [stdout]     |
[INFO] [stdout] 208 |     fn rem_assign(&mut self, scalar) { self.s %= scalar; self.v %= scalar; }
[INFO] [stdout]     |                                        ^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/quaternion.rs:208:58
[INFO] [stdout]     |
[INFO] [stdout] 208 |     fn rem_assign(&mut self, scalar) { self.s %= scalar; self.v %= scalar; }
[INFO] [stdout]     |                                                          ^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/quaternion.rs:226:39
[INFO] [stdout]     |
[INFO] [stdout] 226 |     fn add_assign(&mut self, other) { self.s += other.s; self.v += other.v; }
[INFO] [stdout]     |                                       ^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/quaternion.rs:226:58
[INFO] [stdout]     |
[INFO] [stdout] 226 |     fn add_assign(&mut self, other) { self.s += other.s; self.v += other.v; }
[INFO] [stdout]     |                                                          ^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/quaternion.rs:235:39
[INFO] [stdout]     |
[INFO] [stdout] 235 |     fn sub_assign(&mut self, other) { self.s -= other.s; self.v -= other.v; }
[INFO] [stdout]     |                                       ^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/quaternion.rs:235:58
[INFO] [stdout]     |
[INFO] [stdout] 235 |     fn sub_assign(&mut self, other) { self.s -= other.s; self.v -= other.v; }
[INFO] [stdout]     |                                                          ^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/quaternion.rs:277:9
[INFO] [stdout]     |
[INFO] [stdout] 277 |         self.s.approx_eq_eps(&other.s, epsilon) &&
[INFO] [stdout]     |         ^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/quaternion.rs:277:30
[INFO] [stdout]     |
[INFO] [stdout] 277 |         self.s.approx_eq_eps(&other.s, epsilon) &&
[INFO] [stdout]     |                              ^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/quaternion.rs:278:9
[INFO] [stdout]     |
[INFO] [stdout] 278 |         self.v.approx_eq_eps(&other.v, epsilon)
[INFO] [stdout]     |         ^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/quaternion.rs:278:30
[INFO] [stdout]     |
[INFO] [stdout] 278 |         self.v.approx_eq_eps(&other.v, epsilon)
[INFO] [stdout]     |                              ^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/vector.rs:179:19
[INFO] [stdout]     |
[INFO] [stdout] 179 |                 $(self.$field.approx_eq_eps(&other.$field, epsilon))&&+
[INFO] [stdout]     |                   ^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 288 | impl_vector!(Vector1 { x }, 1, vec1);
[INFO] [stdout]     | ------------------------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_vector` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/vector.rs:179:45
[INFO] [stdout]     |
[INFO] [stdout] 179 |                 $(self.$field.approx_eq_eps(&other.$field, epsilon))&&+
[INFO] [stdout]     |                                             ^^^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 288 | impl_vector!(Vector1 { x }, 1, vec1);
[INFO] [stdout]     | ------------------------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_vector` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/vector.rs:194:49
[INFO] [stdout]     |
[INFO] [stdout] 194 |             fn add_assign(&mut self, other) { $(self.$field += other.$field);+ }
[INFO] [stdout]     |                                                 ^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 288 | impl_vector!(Vector1 { x }, 1, vec1);
[INFO] [stdout]     | ------------------------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_vector` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/vector.rs:201:49
[INFO] [stdout]     |
[INFO] [stdout] 201 |             fn sub_assign(&mut self, other) { $(self.$field -= other.$field);+ }
[INFO] [stdout]     |                                                 ^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 288 | impl_vector!(Vector1 { x }, 1, vec1);
[INFO] [stdout]     | ------------------------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_vector` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/vector.rs:208:50
[INFO] [stdout]     |
[INFO] [stdout] 208 |             fn mul_assign(&mut self, scalar) { $(self.$field *= scalar);+ }
[INFO] [stdout]     |                                                  ^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 288 | impl_vector!(Vector1 { x }, 1, vec1);
[INFO] [stdout]     | ------------------------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_vector` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/vector.rs:215:50
[INFO] [stdout]     |
[INFO] [stdout] 215 |             fn div_assign(&mut self, scalar) { $(self.$field /= scalar);+ }
[INFO] [stdout]     |                                                  ^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 288 | impl_vector!(Vector1 { x }, 1, vec1);
[INFO] [stdout]     | ------------------------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_vector` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/vector.rs:222:50
[INFO] [stdout]     |
[INFO] [stdout] 222 |             fn rem_assign(&mut self, scalar) { $(self.$field %= scalar);+ }
[INFO] [stdout]     |                                                  ^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 288 | impl_vector!(Vector1 { x }, 1, vec1);
[INFO] [stdout]     | ------------------------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_vector` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/vector.rs:232:83
[INFO] [stdout]     |
[INFO] [stdout] 232 |             #[inline] fn add_assign_element_wise(&mut self, rhs: $VectorN<S>) { $(self.$field += rhs.$field);+ }
[INFO] [stdout]     |                                                                                   ^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 288 | impl_vector!(Vector1 { x }, 1, vec1);
[INFO] [stdout]     | ------------------------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_vector` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/vector.rs:233:83
[INFO] [stdout]     |
[INFO] [stdout] 233 |             #[inline] fn sub_assign_element_wise(&mut self, rhs: $VectorN<S>) { $(self.$field -= rhs.$field);+ }
[INFO] [stdout]     |                                                                                   ^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 288 | impl_vector!(Vector1 { x }, 1, vec1);
[INFO] [stdout]     | ------------------------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_vector` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/vector.rs:234:83
[INFO] [stdout]     |
[INFO] [stdout] 234 |             #[inline] fn mul_assign_element_wise(&mut self, rhs: $VectorN<S>) { $(self.$field *= rhs.$field);+ }
[INFO] [stdout]     |                                                                                   ^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 288 | impl_vector!(Vector1 { x }, 1, vec1);
[INFO] [stdout]     | ------------------------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_vector` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/vector.rs:235:83
[INFO] [stdout]     |
[INFO] [stdout] 235 |             #[inline] fn div_assign_element_wise(&mut self, rhs: $VectorN<S>) { $(self.$field /= rhs.$field);+ }
[INFO] [stdout]     |                                                                                   ^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 288 | impl_vector!(Vector1 { x }, 1, vec1);
[INFO] [stdout]     | ------------------------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_vector` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/vector.rs:236:83
[INFO] [stdout]     |
[INFO] [stdout] 236 |             #[inline] fn rem_assign_element_wise(&mut self, rhs: $VectorN<S>) { $(self.$field %= rhs.$field);+ }
[INFO] [stdout]     |                                                                                   ^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 288 | impl_vector!(Vector1 { x }, 1, vec1);
[INFO] [stdout]     | ------------------------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_vector` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/vector.rs:246:73
[INFO] [stdout]     |
[INFO] [stdout] 246 |             #[inline] fn add_assign_element_wise(&mut self, rhs: S) { $(self.$field += rhs);+ }
[INFO] [stdout]     |                                                                         ^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 288 | impl_vector!(Vector1 { x }, 1, vec1);
[INFO] [stdout]     | ------------------------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_vector` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/vector.rs:247:73
[INFO] [stdout]     |
[INFO] [stdout] 247 |             #[inline] fn sub_assign_element_wise(&mut self, rhs: S) { $(self.$field -= rhs);+ }
[INFO] [stdout]     |                                                                         ^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 288 | impl_vector!(Vector1 { x }, 1, vec1);
[INFO] [stdout]     | ------------------------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_vector` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/vector.rs:248:73
[INFO] [stdout]     |
[INFO] [stdout] 248 |             #[inline] fn mul_assign_element_wise(&mut self, rhs: S) { $(self.$field *= rhs);+ }
[INFO] [stdout]     |                                                                         ^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 288 | impl_vector!(Vector1 { x }, 1, vec1);
[INFO] [stdout]     | ------------------------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_vector` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/vector.rs:249:73
[INFO] [stdout]     |
[INFO] [stdout] 249 |             #[inline] fn div_assign_element_wise(&mut self, rhs: S) { $(self.$field /= rhs);+ }
[INFO] [stdout]     |                                                                         ^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 288 | impl_vector!(Vector1 { x }, 1, vec1);
[INFO] [stdout]     | ------------------------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_vector` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/vector.rs:250:73
[INFO] [stdout]     |
[INFO] [stdout] 250 |             #[inline] fn rem_assign_element_wise(&mut self, rhs: S) { $(self.$field %= rhs);+ }
[INFO] [stdout]     |                                                                         ^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 288 | impl_vector!(Vector1 { x }, 1, vec1);
[INFO] [stdout]     | ------------------------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_vector` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/vector.rs:179:19
[INFO] [stdout]     |
[INFO] [stdout] 179 |                 $(self.$field.approx_eq_eps(&other.$field, epsilon))&&+
[INFO] [stdout]     |                   ^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 289 | impl_vector!(Vector2 { x, y }, 2, vec2);
[INFO] [stdout]     | --------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_vector` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/vector.rs:179:45
[INFO] [stdout]     |
[INFO] [stdout] 179 |                 $(self.$field.approx_eq_eps(&other.$field, epsilon))&&+
[INFO] [stdout]     |                                             ^^^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 289 | impl_vector!(Vector2 { x, y }, 2, vec2);
[INFO] [stdout]     | --------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_vector` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/vector.rs:194:49
[INFO] [stdout]     |
[INFO] [stdout] 194 |             fn add_assign(&mut self, other) { $(self.$field += other.$field);+ }
[INFO] [stdout]     |                                                 ^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 289 | impl_vector!(Vector2 { x, y }, 2, vec2);
[INFO] [stdout]     | --------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_vector` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/vector.rs:201:49
[INFO] [stdout]     |
[INFO] [stdout] 201 |             fn sub_assign(&mut self, other) { $(self.$field -= other.$field);+ }
[INFO] [stdout]     |                                                 ^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 289 | impl_vector!(Vector2 { x, y }, 2, vec2);
[INFO] [stdout]     | --------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_vector` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/vector.rs:208:50
[INFO] [stdout]     |
[INFO] [stdout] 208 |             fn mul_assign(&mut self, scalar) { $(self.$field *= scalar);+ }
[INFO] [stdout]     |                                                  ^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 289 | impl_vector!(Vector2 { x, y }, 2, vec2);
[INFO] [stdout]     | --------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_vector` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/vector.rs:215:50
[INFO] [stdout]     |
[INFO] [stdout] 215 |             fn div_assign(&mut self, scalar) { $(self.$field /= scalar);+ }
[INFO] [stdout]     |                                                  ^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 289 | impl_vector!(Vector2 { x, y }, 2, vec2);
[INFO] [stdout]     | --------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_vector` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/vector.rs:222:50
[INFO] [stdout]     |
[INFO] [stdout] 222 |             fn rem_assign(&mut self, scalar) { $(self.$field %= scalar);+ }
[INFO] [stdout]     |                                                  ^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 289 | impl_vector!(Vector2 { x, y }, 2, vec2);
[INFO] [stdout]     | --------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_vector` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/vector.rs:232:83
[INFO] [stdout]     |
[INFO] [stdout] 232 |             #[inline] fn add_assign_element_wise(&mut self, rhs: $VectorN<S>) { $(self.$field += rhs.$field);+ }
[INFO] [stdout]     |                                                                                   ^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 289 | impl_vector!(Vector2 { x, y }, 2, vec2);
[INFO] [stdout]     | --------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_vector` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/vector.rs:233:83
[INFO] [stdout]     |
[INFO] [stdout] 233 |             #[inline] fn sub_assign_element_wise(&mut self, rhs: $VectorN<S>) { $(self.$field -= rhs.$field);+ }
[INFO] [stdout]     |                                                                                   ^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 289 | impl_vector!(Vector2 { x, y }, 2, vec2);
[INFO] [stdout]     | --------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_vector` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/vector.rs:234:83
[INFO] [stdout]     |
[INFO] [stdout] 234 |             #[inline] fn mul_assign_element_wise(&mut self, rhs: $VectorN<S>) { $(self.$field *= rhs.$field);+ }
[INFO] [stdout]     |                                                                                   ^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 289 | impl_vector!(Vector2 { x, y }, 2, vec2);
[INFO] [stdout]     | --------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_vector` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/vector.rs:235:83
[INFO] [stdout]     |
[INFO] [stdout] 235 |             #[inline] fn div_assign_element_wise(&mut self, rhs: $VectorN<S>) { $(self.$field /= rhs.$field);+ }
[INFO] [stdout]     |                                                                                   ^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 289 | impl_vector!(Vector2 { x, y }, 2, vec2);
[INFO] [stdout]     | --------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_vector` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/vector.rs:236:83
[INFO] [stdout]     |
[INFO] [stdout] 236 |             #[inline] fn rem_assign_element_wise(&mut self, rhs: $VectorN<S>) { $(self.$field %= rhs.$field);+ }
[INFO] [stdout]     |                                                                                   ^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 289 | impl_vector!(Vector2 { x, y }, 2, vec2);
[INFO] [stdout]     | --------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_vector` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/vector.rs:246:73
[INFO] [stdout]     |
[INFO] [stdout] 246 |             #[inline] fn add_assign_element_wise(&mut self, rhs: S) { $(self.$field += rhs);+ }
[INFO] [stdout]     |                                                                         ^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 289 | impl_vector!(Vector2 { x, y }, 2, vec2);
[INFO] [stdout]     | --------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_vector` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/vector.rs:247:73
[INFO] [stdout]     |
[INFO] [stdout] 247 |             #[inline] fn sub_assign_element_wise(&mut self, rhs: S) { $(self.$field -= rhs);+ }
[INFO] [stdout]     |                                                                         ^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 289 | impl_vector!(Vector2 { x, y }, 2, vec2);
[INFO] [stdout]     | --------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_vector` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/vector.rs:248:73
[INFO] [stdout]     |
[INFO] [stdout] 248 |             #[inline] fn mul_assign_element_wise(&mut self, rhs: S) { $(self.$field *= rhs);+ }
[INFO] [stdout]     |                                                                         ^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 289 | impl_vector!(Vector2 { x, y }, 2, vec2);
[INFO] [stdout]     | --------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_vector` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/vector.rs:249:73
[INFO] [stdout]     |
[INFO] [stdout] 249 |             #[inline] fn div_assign_element_wise(&mut self, rhs: S) { $(self.$field /= rhs);+ }
[INFO] [stdout]     |                                                                         ^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 289 | impl_vector!(Vector2 { x, y }, 2, vec2);
[INFO] [stdout]     | --------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_vector` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/vector.rs:250:73
[INFO] [stdout]     |
[INFO] [stdout] 250 |             #[inline] fn rem_assign_element_wise(&mut self, rhs: S) { $(self.$field %= rhs);+ }
[INFO] [stdout]     |                                                                         ^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 289 | impl_vector!(Vector2 { x, y }, 2, vec2);
[INFO] [stdout]     | --------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_vector` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/vector.rs:179:19
[INFO] [stdout]     |
[INFO] [stdout] 179 |                 $(self.$field.approx_eq_eps(&other.$field, epsilon))&&+
[INFO] [stdout]     |                   ^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 290 | impl_vector!(Vector3 { x, y, z }, 3, vec3);
[INFO] [stdout]     | ------------------------------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_vector` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/vector.rs:179:45
[INFO] [stdout]     |
[INFO] [stdout] 179 |                 $(self.$field.approx_eq_eps(&other.$field, epsilon))&&+
[INFO] [stdout]     |                                             ^^^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 290 | impl_vector!(Vector3 { x, y, z }, 3, vec3);
[INFO] [stdout]     | ------------------------------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_vector` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/vector.rs:194:49
[INFO] [stdout]     |
[INFO] [stdout] 194 |             fn add_assign(&mut self, other) { $(self.$field += other.$field);+ }
[INFO] [stdout]     |                                                 ^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 290 | impl_vector!(Vector3 { x, y, z }, 3, vec3);
[INFO] [stdout]     | ------------------------------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_vector` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/vector.rs:201:49
[INFO] [stdout]     |
[INFO] [stdout] 201 |             fn sub_assign(&mut self, other) { $(self.$field -= other.$field);+ }
[INFO] [stdout]     |                                                 ^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 290 | impl_vector!(Vector3 { x, y, z }, 3, vec3);
[INFO] [stdout]     | ------------------------------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_vector` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/vector.rs:208:50
[INFO] [stdout]     |
[INFO] [stdout] 208 |             fn mul_assign(&mut self, scalar) { $(self.$field *= scalar);+ }
[INFO] [stdout]     |                                                  ^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 290 | impl_vector!(Vector3 { x, y, z }, 3, vec3);
[INFO] [stdout]     | ------------------------------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_vector` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/vector.rs:215:50
[INFO] [stdout]     |
[INFO] [stdout] 215 |             fn div_assign(&mut self, scalar) { $(self.$field /= scalar);+ }
[INFO] [stdout]     |                                                  ^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 290 | impl_vector!(Vector3 { x, y, z }, 3, vec3);
[INFO] [stdout]     | ------------------------------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_vector` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/vector.rs:222:50
[INFO] [stdout]     |
[INFO] [stdout] 222 |             fn rem_assign(&mut self, scalar) { $(self.$field %= scalar);+ }
[INFO] [stdout]     |                                                  ^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 290 | impl_vector!(Vector3 { x, y, z }, 3, vec3);
[INFO] [stdout]     | ------------------------------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_vector` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/vector.rs:232:83
[INFO] [stdout]     |
[INFO] [stdout] 232 |             #[inline] fn add_assign_element_wise(&mut self, rhs: $VectorN<S>) { $(self.$field += rhs.$field);+ }
[INFO] [stdout]     |                                                                                   ^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 290 | impl_vector!(Vector3 { x, y, z }, 3, vec3);
[INFO] [stdout]     | ------------------------------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_vector` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/vector.rs:233:83
[INFO] [stdout]     |
[INFO] [stdout] 233 |             #[inline] fn sub_assign_element_wise(&mut self, rhs: $VectorN<S>) { $(self.$field -= rhs.$field);+ }
[INFO] [stdout]     |                                                                                   ^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 290 | impl_vector!(Vector3 { x, y, z }, 3, vec3);
[INFO] [stdout]     | ------------------------------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_vector` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/vector.rs:234:83
[INFO] [stdout]     |
[INFO] [stdout] 234 |             #[inline] fn mul_assign_element_wise(&mut self, rhs: $VectorN<S>) { $(self.$field *= rhs.$field);+ }
[INFO] [stdout]     |                                                                                   ^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 290 | impl_vector!(Vector3 { x, y, z }, 3, vec3);
[INFO] [stdout]     | ------------------------------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_vector` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/vector.rs:235:83
[INFO] [stdout]     |
[INFO] [stdout] 235 |             #[inline] fn div_assign_element_wise(&mut self, rhs: $VectorN<S>) { $(self.$field /= rhs.$field);+ }
[INFO] [stdout]     |                                                                                   ^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 290 | impl_vector!(Vector3 { x, y, z }, 3, vec3);
[INFO] [stdout]     | ------------------------------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_vector` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/vector.rs:236:83
[INFO] [stdout]     |
[INFO] [stdout] 236 |             #[inline] fn rem_assign_element_wise(&mut self, rhs: $VectorN<S>) { $(self.$field %= rhs.$field);+ }
[INFO] [stdout]     |                                                                                   ^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 290 | impl_vector!(Vector3 { x, y, z }, 3, vec3);
[INFO] [stdout]     | ------------------------------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_vector` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/vector.rs:246:73
[INFO] [stdout]     |
[INFO] [stdout] 246 |             #[inline] fn add_assign_element_wise(&mut self, rhs: S) { $(self.$field += rhs);+ }
[INFO] [stdout]     |                                                                         ^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 290 | impl_vector!(Vector3 { x, y, z }, 3, vec3);
[INFO] [stdout]     | ------------------------------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_vector` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/vector.rs:247:73
[INFO] [stdout]     |
[INFO] [stdout] 247 |             #[inline] fn sub_assign_element_wise(&mut self, rhs: S) { $(self.$field -= rhs);+ }
[INFO] [stdout]     |                                                                         ^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 290 | impl_vector!(Vector3 { x, y, z }, 3, vec3);
[INFO] [stdout]     | ------------------------------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_vector` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/vector.rs:248:73
[INFO] [stdout]     |
[INFO] [stdout] 248 |             #[inline] fn mul_assign_element_wise(&mut self, rhs: S) { $(self.$field *= rhs);+ }
[INFO] [stdout]     |                                                                         ^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 290 | impl_vector!(Vector3 { x, y, z }, 3, vec3);
[INFO] [stdout]     | ------------------------------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_vector` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/vector.rs:249:73
[INFO] [stdout]     |
[INFO] [stdout] 249 |             #[inline] fn div_assign_element_wise(&mut self, rhs: S) { $(self.$field /= rhs);+ }
[INFO] [stdout]     |                                                                         ^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 290 | impl_vector!(Vector3 { x, y, z }, 3, vec3);
[INFO] [stdout]     | ------------------------------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_vector` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/vector.rs:250:73
[INFO] [stdout]     |
[INFO] [stdout] 250 |             #[inline] fn rem_assign_element_wise(&mut self, rhs: S) { $(self.$field %= rhs);+ }
[INFO] [stdout]     |                                                                         ^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 290 | impl_vector!(Vector3 { x, y, z }, 3, vec3);
[INFO] [stdout]     | ------------------------------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_vector` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/vector.rs:179:19
[INFO] [stdout]     |
[INFO] [stdout] 179 |                 $(self.$field.approx_eq_eps(&other.$field, epsilon))&&+
[INFO] [stdout]     |                   ^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 291 | impl_vector!(Vector4 { x, y, z, w }, 4, vec4);
[INFO] [stdout]     | --------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_vector` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/vector.rs:179:45
[INFO] [stdout]     |
[INFO] [stdout] 179 |                 $(self.$field.approx_eq_eps(&other.$field, epsilon))&&+
[INFO] [stdout]     |                                             ^^^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 291 | impl_vector!(Vector4 { x, y, z, w }, 4, vec4);
[INFO] [stdout]     | --------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_vector` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/vector.rs:194:49
[INFO] [stdout]     |
[INFO] [stdout] 194 |             fn add_assign(&mut self, other) { $(self.$field += other.$field);+ }
[INFO] [stdout]     |                                                 ^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 291 | impl_vector!(Vector4 { x, y, z, w }, 4, vec4);
[INFO] [stdout]     | --------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_vector` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/vector.rs:201:49
[INFO] [stdout]     |
[INFO] [stdout] 201 |             fn sub_assign(&mut self, other) { $(self.$field -= other.$field);+ }
[INFO] [stdout]     |                                                 ^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 291 | impl_vector!(Vector4 { x, y, z, w }, 4, vec4);
[INFO] [stdout]     | --------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_vector` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/vector.rs:208:50
[INFO] [stdout]     |
[INFO] [stdout] 208 |             fn mul_assign(&mut self, scalar) { $(self.$field *= scalar);+ }
[INFO] [stdout]     |                                                  ^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 291 | impl_vector!(Vector4 { x, y, z, w }, 4, vec4);
[INFO] [stdout]     | --------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_vector` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/vector.rs:215:50
[INFO] [stdout]     |
[INFO] [stdout] 215 |             fn div_assign(&mut self, scalar) { $(self.$field /= scalar);+ }
[INFO] [stdout]     |                                                  ^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 291 | impl_vector!(Vector4 { x, y, z, w }, 4, vec4);
[INFO] [stdout]     | --------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_vector` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/vector.rs:222:50
[INFO] [stdout]     |
[INFO] [stdout] 222 |             fn rem_assign(&mut self, scalar) { $(self.$field %= scalar);+ }
[INFO] [stdout]     |                                                  ^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 291 | impl_vector!(Vector4 { x, y, z, w }, 4, vec4);
[INFO] [stdout]     | --------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_vector` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/vector.rs:232:83
[INFO] [stdout]     |
[INFO] [stdout] 232 |             #[inline] fn add_assign_element_wise(&mut self, rhs: $VectorN<S>) { $(self.$field += rhs.$field);+ }
[INFO] [stdout]     |                                                                                   ^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 291 | impl_vector!(Vector4 { x, y, z, w }, 4, vec4);
[INFO] [stdout]     | --------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_vector` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/vector.rs:233:83
[INFO] [stdout]     |
[INFO] [stdout] 233 |             #[inline] fn sub_assign_element_wise(&mut self, rhs: $VectorN<S>) { $(self.$field -= rhs.$field);+ }
[INFO] [stdout]     |                                                                                   ^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 291 | impl_vector!(Vector4 { x, y, z, w }, 4, vec4);
[INFO] [stdout]     | --------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_vector` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/vector.rs:234:83
[INFO] [stdout]     |
[INFO] [stdout] 234 |             #[inline] fn mul_assign_element_wise(&mut self, rhs: $VectorN<S>) { $(self.$field *= rhs.$field);+ }
[INFO] [stdout]     |                                                                                   ^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 291 | impl_vector!(Vector4 { x, y, z, w }, 4, vec4);
[INFO] [stdout]     | --------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_vector` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/vector.rs:235:83
[INFO] [stdout]     |
[INFO] [stdout] 235 |             #[inline] fn div_assign_element_wise(&mut self, rhs: $VectorN<S>) { $(self.$field /= rhs.$field);+ }
[INFO] [stdout]     |                                                                                   ^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 291 | impl_vector!(Vector4 { x, y, z, w }, 4, vec4);
[INFO] [stdout]     | --------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_vector` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/vector.rs:236:83
[INFO] [stdout]     |
[INFO] [stdout] 236 |             #[inline] fn rem_assign_element_wise(&mut self, rhs: $VectorN<S>) { $(self.$field %= rhs.$field);+ }
[INFO] [stdout]     |                                                                                   ^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 291 | impl_vector!(Vector4 { x, y, z, w }, 4, vec4);
[INFO] [stdout]     | --------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_vector` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/vector.rs:246:73
[INFO] [stdout]     |
[INFO] [stdout] 246 |             #[inline] fn add_assign_element_wise(&mut self, rhs: S) { $(self.$field += rhs);+ }
[INFO] [stdout]     |                                                                         ^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 291 | impl_vector!(Vector4 { x, y, z, w }, 4, vec4);
[INFO] [stdout]     | --------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_vector` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/vector.rs:247:73
[INFO] [stdout]     |
[INFO] [stdout] 247 |             #[inline] fn sub_assign_element_wise(&mut self, rhs: S) { $(self.$field -= rhs);+ }
[INFO] [stdout]     |                                                                         ^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 291 | impl_vector!(Vector4 { x, y, z, w }, 4, vec4);
[INFO] [stdout]     | --------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_vector` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/vector.rs:248:73
[INFO] [stdout]     |
[INFO] [stdout] 248 |             #[inline] fn mul_assign_element_wise(&mut self, rhs: S) { $(self.$field *= rhs);+ }
[INFO] [stdout]     |                                                                         ^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 291 | impl_vector!(Vector4 { x, y, z, w }, 4, vec4);
[INFO] [stdout]     | --------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_vector` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/vector.rs:249:73
[INFO] [stdout]     |
[INFO] [stdout] 249 |             #[inline] fn div_assign_element_wise(&mut self, rhs: S) { $(self.$field /= rhs);+ }
[INFO] [stdout]     |                                                                         ^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 291 | impl_vector!(Vector4 { x, y, z, w }, 4, vec4);
[INFO] [stdout]     | --------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_vector` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/vector.rs:250:73
[INFO] [stdout]     |
[INFO] [stdout] 250 |             #[inline] fn rem_assign_element_wise(&mut self, rhs: S) { $(self.$field %= rhs);+ }
[INFO] [stdout]     |                                                                         ^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 291 | impl_vector!(Vector4 { x, y, z, w }, 4, vec4);
[INFO] [stdout]     | --------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_vector` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/angle.rs:132:47
[INFO] [stdout]     |
[INFO] [stdout] 132 |             fn add_assign(&mut self, other) { self.s += other.s; }
[INFO] [stdout]     |                                               ^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 178 | impl_angle!(Rad, "{:?} rad", f64::consts::PI * 2.0, f64::consts::PI);
[INFO] [stdout]     | -------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_angle` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/angle.rs:135:47
[INFO] [stdout]     |
[INFO] [stdout] 135 |             fn sub_assign(&mut self, other) { self.s -= other.s; }
[INFO] [stdout]     |                                               ^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 178 | impl_angle!(Rad, "{:?} rad", f64::consts::PI * 2.0, f64::consts::PI);
[INFO] [stdout]     | -------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_angle` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/angle.rs:138:47
[INFO] [stdout]     |
[INFO] [stdout] 138 |             fn rem_assign(&mut self, other) { self.s %= other.s; }
[INFO] [stdout]     |                                               ^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 178 | impl_angle!(Rad, "{:?} rad", f64::consts::PI * 2.0, f64::consts::PI);
[INFO] [stdout]     | -------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_angle` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/angle.rs:148:48
[INFO] [stdout]     |
[INFO] [stdout] 148 |             fn mul_assign(&mut self, scalar) { self.s *= scalar; }
[INFO] [stdout]     |                                                ^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 178 | impl_angle!(Rad, "{:?} rad", f64::consts::PI * 2.0, f64::consts::PI);
[INFO] [stdout]     | -------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_angle` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/angle.rs:151:48
[INFO] [stdout]     |
[INFO] [stdout] 151 |             fn div_assign(&mut self, scalar) { self.s /= scalar; }
[INFO] [stdout]     |                                                ^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 178 | impl_angle!(Rad, "{:?} rad", f64::consts::PI * 2.0, f64::consts::PI);
[INFO] [stdout]     | -------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_angle` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/angle.rs:159:17
[INFO] [stdout]     |
[INFO] [stdout] 159 |                 self.s.approx_eq_eps(&other.s, epsilon)
[INFO] [stdout]     |                 ^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 178 | impl_angle!(Rad, "{:?} rad", f64::consts::PI * 2.0, f64::consts::PI);
[INFO] [stdout]     | -------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_angle` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/angle.rs:159:38
[INFO] [stdout]     |
[INFO] [stdout] 159 |                 self.s.approx_eq_eps(&other.s, epsilon)
[INFO] [stdout]     |                                      ^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 178 | impl_angle!(Rad, "{:?} rad", f64::consts::PI * 2.0, f64::consts::PI);
[INFO] [stdout]     | -------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_angle` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/angle.rs:172:33
[INFO] [stdout]     |
[INFO] [stdout] 172 |                 write!(f, $fmt, self.s)
[INFO] [stdout]     |                                 ^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 178 | impl_angle!(Rad, "{:?} rad", f64::consts::PI * 2.0, f64::consts::PI);
[INFO] [stdout]     | -------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `$crate::format_args` which comes from the expansion of the macro `impl_angle` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/angle.rs:132:47
[INFO] [stdout]     |
[INFO] [stdout] 132 |             fn add_assign(&mut self, other) { self.s += other.s; }
[INFO] [stdout]     |                                               ^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 179 | impl_angle!(Deg, "{:?}°", 360, 180);
[INFO] [stdout]     | ----------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_angle` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/angle.rs:135:47
[INFO] [stdout]     |
[INFO] [stdout] 135 |             fn sub_assign(&mut self, other) { self.s -= other.s; }
[INFO] [stdout]     |                                               ^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 179 | impl_angle!(Deg, "{:?}°", 360, 180);
[INFO] [stdout]     | ----------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_angle` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/angle.rs:138:47
[INFO] [stdout]     |
[INFO] [stdout] 138 |             fn rem_assign(&mut self, other) { self.s %= other.s; }
[INFO] [stdout]     |                                               ^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 179 | impl_angle!(Deg, "{:?}°", 360, 180);
[INFO] [stdout]     | ----------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_angle` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/angle.rs:148:48
[INFO] [stdout]     |
[INFO] [stdout] 148 |             fn mul_assign(&mut self, scalar) { self.s *= scalar; }
[INFO] [stdout]     |                                                ^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 179 | impl_angle!(Deg, "{:?}°", 360, 180);
[INFO] [stdout]     | ----------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_angle` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/angle.rs:151:48
[INFO] [stdout]     |
[INFO] [stdout] 151 |             fn div_assign(&mut self, scalar) { self.s /= scalar; }
[INFO] [stdout]     |                                                ^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 179 | impl_angle!(Deg, "{:?}°", 360, 180);
[INFO] [stdout]     | ----------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_angle` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/angle.rs:159:17
[INFO] [stdout]     |
[INFO] [stdout] 159 |                 self.s.approx_eq_eps(&other.s, epsilon)
[INFO] [stdout]     |                 ^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 179 | impl_angle!(Deg, "{:?}°", 360, 180);
[INFO] [stdout]     | ----------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_angle` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/angle.rs:159:38
[INFO] [stdout]     |
[INFO] [stdout] 159 |                 self.s.approx_eq_eps(&other.s, epsilon)
[INFO] [stdout]     |                                      ^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 179 | impl_angle!(Deg, "{:?}°", 360, 180);
[INFO] [stdout]     | ----------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_angle` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/angle.rs:172:33
[INFO] [stdout]     |
[INFO] [stdout] 172 |                 write!(f, $fmt, self.s)
[INFO] [stdout]     |                                 ^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 179 | impl_angle!(Deg, "{:?}°", 360, 180);
[INFO] [stdout]     | ----------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `$crate::format_args` which comes from the expansion of the macro `impl_angle` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/euler.rs:149:9
[INFO] [stdout]     |
[INFO] [stdout] 149 |         self.x.approx_eq_eps(&other.x, epsilon) &&
[INFO] [stdout]     |         ^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/euler.rs:149:30
[INFO] [stdout]     |
[INFO] [stdout] 149 |         self.x.approx_eq_eps(&other.x, epsilon) &&
[INFO] [stdout]     |                              ^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/euler.rs:150:9
[INFO] [stdout]     |
[INFO] [stdout] 150 |         self.y.approx_eq_eps(&other.y, epsilon) &&
[INFO] [stdout]     |         ^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/euler.rs:150:30
[INFO] [stdout]     |
[INFO] [stdout] 150 |         self.y.approx_eq_eps(&other.y, epsilon) &&
[INFO] [stdout]     |                              ^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/euler.rs:151:9
[INFO] [stdout]     |
[INFO] [stdout] 151 |         self.z.approx_eq_eps(&other.z, epsilon)
[INFO] [stdout]     |         ^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/euler.rs:151:30
[INFO] [stdout]     |
[INFO] [stdout] 151 |         self.z.approx_eq_eps(&other.z, epsilon)
[INFO] [stdout]     |                              ^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/point.rs:170:19
[INFO] [stdout]     |
[INFO] [stdout] 170 |                 $(self.$field.approx_eq_eps(&other.$field, epsilon))&&+
[INFO] [stdout]     |                   ^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 239 | impl_point!(Point1 { x }, Vector1, 1);
[INFO] [stdout]     | ------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_point` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/point.rs:170:45
[INFO] [stdout]     |
[INFO] [stdout] 170 |                 $(self.$field.approx_eq_eps(&other.$field, epsilon))&&+
[INFO] [stdout]     |                                             ^^^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 239 | impl_point!(Point1 { x }, Vector1, 1);
[INFO] [stdout]     | ------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_point` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/point.rs:178:50
[INFO] [stdout]     |
[INFO] [stdout] 178 |             fn add_assign(&mut self, vector) { $(self.$field += vector.$field);+ }
[INFO] [stdout]     |                                                  ^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 239 | impl_point!(Point1 { x }, Vector1, 1);
[INFO] [stdout]     | ------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_point` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/point.rs:195:50
[INFO] [stdout]     |
[INFO] [stdout] 195 |             fn mul_assign(&mut self, scalar) { $(self.$field *= scalar);+ }
[INFO] [stdout]     |                                                  ^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 239 | impl_point!(Point1 { x }, Vector1, 1);
[INFO] [stdout]     | ------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_point` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/point.rs:198:50
[INFO] [stdout]     |
[INFO] [stdout] 198 |             fn div_assign(&mut self, scalar) { $(self.$field /= scalar);+ }
[INFO] [stdout]     |                                                  ^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 239 | impl_point!(Point1 { x }, Vector1, 1);
[INFO] [stdout]     | ------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_point` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/point.rs:201:50
[INFO] [stdout]     |
[INFO] [stdout] 201 |             fn rem_assign(&mut self, scalar) { $(self.$field %= scalar);+ }
[INFO] [stdout]     |                                                  ^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 239 | impl_point!(Point1 { x }, Vector1, 1);
[INFO] [stdout]     | ------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_point` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/point.rs:170:19
[INFO] [stdout]     |
[INFO] [stdout] 170 |                 $(self.$field.approx_eq_eps(&other.$field, epsilon))&&+
[INFO] [stdout]     |                   ^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 240 | impl_point!(Point2 { x, y }, Vector2, 2);
[INFO] [stdout]     | ---------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_point` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/point.rs:170:45
[INFO] [stdout]     |
[INFO] [stdout] 170 |                 $(self.$field.approx_eq_eps(&other.$field, epsilon))&&+
[INFO] [stdout]     |                                             ^^^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 240 | impl_point!(Point2 { x, y }, Vector2, 2);
[INFO] [stdout]     | ---------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_point` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/point.rs:178:50
[INFO] [stdout]     |
[INFO] [stdout] 178 |             fn add_assign(&mut self, vector) { $(self.$field += vector.$field);+ }
[INFO] [stdout]     |                                                  ^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 240 | impl_point!(Point2 { x, y }, Vector2, 2);
[INFO] [stdout]     | ---------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_point` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/point.rs:195:50
[INFO] [stdout]     |
[INFO] [stdout] 195 |             fn mul_assign(&mut self, scalar) { $(self.$field *= scalar);+ }
[INFO] [stdout]     |                                                  ^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 240 | impl_point!(Point2 { x, y }, Vector2, 2);
[INFO] [stdout]     | ---------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_point` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/point.rs:198:50
[INFO] [stdout]     |
[INFO] [stdout] 198 |             fn div_assign(&mut self, scalar) { $(self.$field /= scalar);+ }
[INFO] [stdout]     |                                                  ^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 240 | impl_point!(Point2 { x, y }, Vector2, 2);
[INFO] [stdout]     | ---------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_point` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/point.rs:201:50
[INFO] [stdout]     |
[INFO] [stdout] 201 |             fn rem_assign(&mut self, scalar) { $(self.$field %= scalar);+ }
[INFO] [stdout]     |                                                  ^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 240 | impl_point!(Point2 { x, y }, Vector2, 2);
[INFO] [stdout]     | ---------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_point` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/point.rs:170:19
[INFO] [stdout]     |
[INFO] [stdout] 170 |                 $(self.$field.approx_eq_eps(&other.$field, epsilon))&&+
[INFO] [stdout]     |                   ^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 241 | impl_point!(Point3 { x, y, z }, Vector3, 3);
[INFO] [stdout]     | ------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_point` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/point.rs:170:45
[INFO] [stdout]     |
[INFO] [stdout] 170 |                 $(self.$field.approx_eq_eps(&other.$field, epsilon))&&+
[INFO] [stdout]     |                                             ^^^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 241 | impl_point!(Point3 { x, y, z }, Vector3, 3);
[INFO] [stdout]     | ------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_point` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/point.rs:178:50
[INFO] [stdout]     |
[INFO] [stdout] 178 |             fn add_assign(&mut self, vector) { $(self.$field += vector.$field);+ }
[INFO] [stdout]     |                                                  ^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 241 | impl_point!(Point3 { x, y, z }, Vector3, 3);
[INFO] [stdout]     | ------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_point` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/point.rs:195:50
[INFO] [stdout]     |
[INFO] [stdout] 195 |             fn mul_assign(&mut self, scalar) { $(self.$field *= scalar);+ }
[INFO] [stdout]     |                                                  ^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 241 | impl_point!(Point3 { x, y, z }, Vector3, 3);
[INFO] [stdout]     | ------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_point` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/point.rs:198:50
[INFO] [stdout]     |
[INFO] [stdout] 198 |             fn div_assign(&mut self, scalar) { $(self.$field /= scalar);+ }
[INFO] [stdout]     |                                                  ^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 241 | impl_point!(Point3 { x, y, z }, Vector3, 3);
[INFO] [stdout]     | ------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_point` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/point.rs:201:50
[INFO] [stdout]     |
[INFO] [stdout] 201 |             fn rem_assign(&mut self, scalar) { $(self.$field %= scalar);+ }
[INFO] [stdout]     |                                                  ^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 241 | impl_point!(Point3 { x, y, z }, Vector3, 3);
[INFO] [stdout]     | ------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_point` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: aborting due to 173 previous errors
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] Some errors have detailed explanations: E0277, E0369, E0793.
[INFO] [stdout] 
[INFO] [stdout] For more information about an error, try `rustc --explain E0277`.
[INFO] [stdout] 
[INFO] [stderr] error: could not compile `cgmath` (lib) due to 174 previous errors; 40 warnings emitted
[INFO] running `Command { std: "docker" "inspect" "e295fcaaf10aaf7b118d868e31478cd9ea3cf2c1788621b030c0c4a14748f326", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "rm" "-f" "e295fcaaf10aaf7b118d868e31478cd9ea3cf2c1788621b030c0c4a14748f326", kill_on_drop: false }`
[INFO] [stdout] e295fcaaf10aaf7b118d868e31478cd9ea3cf2c1788621b030c0c4a14748f326
[INFO] checking matrixstack-0.1.4 against try#9c7b5f5b6b8ec32bbbcf9f07fc0e5208da6c5f88 for pr-124157
[INFO] extracting crate matrixstack 0.1.4 into /workspace/builds/worker-2-tc2/source
[INFO] validating manifest of crates.io crate matrixstack 0.1.4 on toolchain 9c7b5f5b6b8ec32bbbcf9f07fc0e5208da6c5f88
[INFO] running `Command { std: CARGO_HOME="/workspace/cargo-home" RUSTUP_HOME="/workspace/rustup-home" "/workspace/cargo-home/bin/cargo" "+9c7b5f5b6b8ec32bbbcf9f07fc0e5208da6c5f88" "metadata" "--manifest-path" "Cargo.toml" "--no-deps", kill_on_drop: false }`
[INFO] started tweaking crates.io crate matrixstack 0.1.4
[INFO] finished tweaking crates.io crate matrixstack 0.1.4
[INFO] tweaked toml for crates.io crate matrixstack 0.1.4 written to /workspace/builds/worker-2-tc2/source/Cargo.toml
[INFO] running `Command { std: CARGO_HOME="/workspace/cargo-home" RUSTUP_HOME="/workspace/rustup-home" "/workspace/cargo-home/bin/cargo" "+9c7b5f5b6b8ec32bbbcf9f07fc0e5208da6c5f88" "generate-lockfile" "--manifest-path" "Cargo.toml", kill_on_drop: false }`
[INFO] [stderr]     Updating crates.io index
[INFO] [stderr]      Locking 16 packages to latest compatible versions
[INFO] [stderr]       Adding cgmath v0.10.0 (latest: v0.18.0)
[INFO] [stderr]       Adding num-traits v0.1.43 (latest: v0.2.18)
[INFO] [stderr]       Adding rand v0.3.23 (latest: v0.8.5)
[INFO] [stderr]       Adding rand v0.4.6 (latest: v0.8.5)
[INFO] [stderr]       Adding rand_core v0.3.1 (latest: v0.6.4)
[INFO] [stderr]       Adding rand_core v0.4.2 (latest: v0.6.4)
[INFO] [stderr]       Adding rdrand v0.4.0 (latest: v0.8.3)
[INFO] running `Command { std: CARGO_HOME="/workspace/cargo-home" RUSTUP_HOME="/workspace/rustup-home" "/workspace/cargo-home/bin/cargo" "+9c7b5f5b6b8ec32bbbcf9f07fc0e5208da6c5f88" "fetch" "--manifest-path" "Cargo.toml", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "create" "-v" "/var/lib/crater-agent-workspace/builds/worker-2-tc2/target:/opt/rustwide/target:rw,Z" "-v" "/var/lib/crater-agent-workspace/builds/worker-2-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:99613afd962a8cfa530ec1899472a458bd015a1ab0af876cf7eb06f6006d81ea" "/opt/rustwide/cargo-home/bin/cargo" "+9c7b5f5b6b8ec32bbbcf9f07fc0e5208da6c5f88" "metadata" "--no-deps" "--format-version=1", kill_on_drop: false }`
[INFO] [stdout] 9a87d97f706068fb00515c96e5b2be84043ad1227ebae8f63fbecb7e2b1cfd30
[INFO] running `Command { std: "docker" "start" "-a" "9a87d97f706068fb00515c96e5b2be84043ad1227ebae8f63fbecb7e2b1cfd30", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "inspect" "9a87d97f706068fb00515c96e5b2be84043ad1227ebae8f63fbecb7e2b1cfd30", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "rm" "-f" "9a87d97f706068fb00515c96e5b2be84043ad1227ebae8f63fbecb7e2b1cfd30", kill_on_drop: false }`
[INFO] [stdout] 9a87d97f706068fb00515c96e5b2be84043ad1227ebae8f63fbecb7e2b1cfd30
[INFO] running `Command { std: "docker" "create" "-v" "/var/lib/crater-agent-workspace/builds/worker-2-tc2/target:/opt/rustwide/target:rw,Z" "-v" "/var/lib/crater-agent-workspace/builds/worker-2-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=forbid" "-e" "RUSTDOCFLAGS=--cap-lints=forbid" "-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:99613afd962a8cfa530ec1899472a458bd015a1ab0af876cf7eb06f6006d81ea" "/opt/rustwide/cargo-home/bin/cargo" "+9c7b5f5b6b8ec32bbbcf9f07fc0e5208da6c5f88" "check" "--frozen" "--all" "--all-targets" "--message-format=json", kill_on_drop: false }`
[INFO] [stdout] 5a2e7092c08e5cd1fdd02b06f517fb99883977f9a50644f82357cda0af283e2f
[INFO] running `Command { std: "docker" "start" "-a" "5a2e7092c08e5cd1fdd02b06f517fb99883977f9a50644f82357cda0af283e2f", kill_on_drop: false }`
[INFO] [stderr]     Checking rustc-serialize v0.3.25
[INFO] [stderr]     Checking rand v0.4.6
[INFO] [stderr]     Checking num-traits v0.1.43
[INFO] [stderr]     Checking rand v0.3.23
[INFO] [stderr]     Checking cgmath v0.10.0
[INFO] [stdout] error[E0277]: the trait bound `S: Copy` is not satisfied
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/rotation.rs:146:5
[INFO] [stdout]     |
[INFO] [stdout] 143 | #[cfg_attr(feature = "rustc-serialize", derive(RustcEncodable, RustcDecodable))]
[INFO] [stdout]     |                                                --------------
[INFO] [stdout]     |                                                |
[INFO] [stdout]     |                                                required by a bound introduced by this call
[INFO] [stdout]     |                                                in this derive macro expansion
[INFO] [stdout] ...
[INFO] [stdout] 146 |     mat: Matrix2<S>
[INFO] [stdout]     |     ^^^^^^^^^^^^^^^ the trait `Copy` is not implemented for `S`, which is required by `&Matrix2<S>: Encodable`
[INFO] [stdout]     |
[INFO] [stdout] note: required for `Matrix2<S>` to implement `Encodable`
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/matrix.rs:39:48
[INFO] [stdout]     |
[INFO] [stdout] 39  | #[cfg_attr(feature = "rustc-serialize", derive(RustcEncodable, RustcDecodable))]
[INFO] [stdout]     |                                                ^^^^^^^^^^^^^^ unsatisfied trait bound introduced in this `derive` macro
[INFO] [stdout]     = note: 1 redundant requirement hidden
[INFO] [stdout]     = note: required for `&Matrix2<S>` to implement `Encodable`
[INFO] [stdout]     = note: this error originates in the derive macro `RustcEncodable` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: consider restricting type parameter `S`
[INFO] [stdout]     |
[INFO] [stdout] 145 | pub struct Basis2<S: std::marker::Copy> {
[INFO] [stdout]     |                    +++++++++++++++++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0277]: the trait bound `S: Copy` is not satisfied
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/rotation.rs:146:5
[INFO] [stdout]     |
[INFO] [stdout] 143 | #[cfg_attr(feature = "rustc-serialize", derive(RustcEncodable, RustcDecodable))]
[INFO] [stdout]     |                                                                -------------- in this derive macro expansion
[INFO] [stdout] ...
[INFO] [stdout] 146 |     mat: Matrix2<S>
[INFO] [stdout]     |     ^^^^^^^^^^^^^^^ the trait `Copy` is not implemented for `S`, which is required by `Matrix2<_>: Decodable`
[INFO] [stdout]     |
[INFO] [stdout] note: required for `Matrix2<S>` to implement `Decodable`
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/matrix.rs:39:64
[INFO] [stdout]     |
[INFO] [stdout] 39  | #[cfg_attr(feature = "rustc-serialize", derive(RustcEncodable, RustcDecodable))]
[INFO] [stdout]     |                                                                ^^^^^^^^^^^^^^ unsatisfied trait bound introduced in this `derive` macro
[INFO] [stdout]     = note: this error originates in the derive macro `RustcDecodable` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: consider restricting type parameter `S`
[INFO] [stdout]     |
[INFO] [stdout] 145 | pub struct Basis2<S: std::marker::Copy> {
[INFO] [stdout]     |                    +++++++++++++++++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0277]: the trait bound `S: Copy` is not satisfied
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/rotation.rs:143:64
[INFO] [stdout]     |
[INFO] [stdout] 143 | #[cfg_attr(feature = "rustc-serialize", derive(RustcEncodable, RustcDecodable))]
[INFO] [stdout]     |                                                                ^^^^^^^^^^^^^^ the trait `Copy` is not implemented for `S`, which is required by `Matrix2<_>: Decodable`
[INFO] [stdout]     |
[INFO] [stdout] note: required for `Matrix2<S>` to implement `Decodable`
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/matrix.rs:39:64
[INFO] [stdout]     |
[INFO] [stdout] 39  | #[cfg_attr(feature = "rustc-serialize", derive(RustcEncodable, RustcDecodable))]
[INFO] [stdout]     |                                                                ^^^^^^^^^^^^^^ unsatisfied trait bound introduced in this `derive` macro
[INFO] [stdout]     = note: this error originates in the derive macro `RustcDecodable` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: consider restricting type parameter `S`
[INFO] [stdout]     |
[INFO] [stdout] 145 | pub struct Basis2<S: std::marker::Copy> {
[INFO] [stdout]     |                    +++++++++++++++++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0369]: binary operation `==` cannot be applied to type `Matrix2<S>`
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/rotation.rs:146:5
[INFO] [stdout]     |
[INFO] [stdout] 142 | #[derive(PartialEq, Copy, Clone)]
[INFO] [stdout]     |          --------- in this derive macro expansion
[INFO] [stdout] ...
[INFO] [stdout] 146 |     mat: Matrix2<S>
[INFO] [stdout]     |     ^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this error originates in the derive macro `PartialEq` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: consider restricting type parameter `S`
[INFO] [stdout]     |
[INFO] [stdout] 145 | pub struct Basis2<S: std::marker::Copy> {
[INFO] [stdout]     |                    +++++++++++++++++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0277]: the trait bound `S: Copy` is not satisfied
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/rotation.rs:146:5
[INFO] [stdout]     |
[INFO] [stdout] 142 | #[derive(PartialEq, Copy, Clone)]
[INFO] [stdout]     |                           ----- in this derive macro expansion
[INFO] [stdout] ...
[INFO] [stdout] 146 |     mat: Matrix2<S>
[INFO] [stdout]     |     ^^^^^^^^^^^^^^^ the trait `Copy` is not implemented for `S`, which is required by `Matrix2<S>: Clone`
[INFO] [stdout]     |
[INFO] [stdout] note: required for `Matrix2<S>` to implement `Clone`
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/matrix.rs:38:16
[INFO] [stdout]     |
[INFO] [stdout] 38  | #[derive(Copy, Clone, PartialEq)]
[INFO] [stdout]     |                ^^^^^ unsatisfied trait bound introduced in this `derive` macro
[INFO] [stdout]     = note: this error originates in the derive macro `Clone` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: consider restricting type parameter `S`
[INFO] [stdout]     |
[INFO] [stdout] 145 | pub struct Basis2<S: std::marker::Copy> {
[INFO] [stdout]     |                    +++++++++++++++++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0277]: the trait bound `S: Copy` is not satisfied
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/rotation.rs:220:5
[INFO] [stdout]     |
[INFO] [stdout] 217 | #[cfg_attr(feature = "rustc-serialize", derive(RustcEncodable, RustcDecodable))]
[INFO] [stdout]     |                                                --------------
[INFO] [stdout]     |                                                |
[INFO] [stdout]     |                                                required by a bound introduced by this call
[INFO] [stdout]     |                                                in this derive macro expansion
[INFO] [stdout] ...
[INFO] [stdout] 220 |     mat: Matrix3<S>
[INFO] [stdout]     |     ^^^^^^^^^^^^^^^ the trait `Copy` is not implemented for `S`, which is required by `&Matrix3<S>: Encodable`
[INFO] [stdout]     |
[INFO] [stdout] note: required for `Matrix3<S>` to implement `Encodable`
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/matrix.rs:53:48
[INFO] [stdout]     |
[INFO] [stdout] 53  | #[cfg_attr(feature = "rustc-serialize", derive(RustcEncodable, RustcDecodable))]
[INFO] [stdout]     |                                                ^^^^^^^^^^^^^^ unsatisfied trait bound introduced in this `derive` macro
[INFO] [stdout]     = note: 1 redundant requirement hidden
[INFO] [stdout]     = note: required for `&Matrix3<S>` to implement `Encodable`
[INFO] [stdout]     = note: this error originates in the derive macro `RustcEncodable` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: consider restricting type parameter `S`
[INFO] [stdout]     |
[INFO] [stdout] 219 | pub struct Basis3<S: std::marker::Copy> {
[INFO] [stdout]     |                    +++++++++++++++++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0277]: the trait bound `S: Copy` is not satisfied
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/rotation.rs:220:5
[INFO] [stdout]     |
[INFO] [stdout] 217 | #[cfg_attr(feature = "rustc-serialize", derive(RustcEncodable, RustcDecodable))]
[INFO] [stdout]     |                                                                -------------- in this derive macro expansion
[INFO] [stdout] ...
[INFO] [stdout] 220 |     mat: Matrix3<S>
[INFO] [stdout]     |     ^^^^^^^^^^^^^^^ the trait `Copy` is not implemented for `S`, which is required by `Matrix3<_>: Decodable`
[INFO] [stdout]     |
[INFO] [stdout] note: required for `Matrix3<S>` to implement `Decodable`
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/matrix.rs:53:64
[INFO] [stdout]     |
[INFO] [stdout] 53  | #[cfg_attr(feature = "rustc-serialize", derive(RustcEncodable, RustcDecodable))]
[INFO] [stdout]     |                                                                ^^^^^^^^^^^^^^ unsatisfied trait bound introduced in this `derive` macro
[INFO] [stdout]     = note: this error originates in the derive macro `RustcDecodable` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: consider restricting type parameter `S`
[INFO] [stdout]     |
[INFO] [stdout] 219 | pub struct Basis3<S: std::marker::Copy> {
[INFO] [stdout]     |                    +++++++++++++++++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0277]: the trait bound `S: Copy` is not satisfied
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/rotation.rs:217:64
[INFO] [stdout]     |
[INFO] [stdout] 217 | #[cfg_attr(feature = "rustc-serialize", derive(RustcEncodable, RustcDecodable))]
[INFO] [stdout]     |                                                                ^^^^^^^^^^^^^^ the trait `Copy` is not implemented for `S`, which is required by `Matrix3<_>: Decodable`
[INFO] [stdout]     |
[INFO] [stdout] note: required for `Matrix3<S>` to implement `Decodable`
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/matrix.rs:53:64
[INFO] [stdout]     |
[INFO] [stdout] 53  | #[cfg_attr(feature = "rustc-serialize", derive(RustcEncodable, RustcDecodable))]
[INFO] [stdout]     |                                                                ^^^^^^^^^^^^^^ unsatisfied trait bound introduced in this `derive` macro
[INFO] [stdout]     = note: this error originates in the derive macro `RustcDecodable` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: consider restricting type parameter `S`
[INFO] [stdout]     |
[INFO] [stdout] 219 | pub struct Basis3<S: std::marker::Copy> {
[INFO] [stdout]     |                    +++++++++++++++++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0369]: binary operation `==` cannot be applied to type `Matrix3<S>`
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/rotation.rs:220:5
[INFO] [stdout]     |
[INFO] [stdout] 216 | #[derive(PartialEq, Copy, Clone)]
[INFO] [stdout]     |          --------- in this derive macro expansion
[INFO] [stdout] ...
[INFO] [stdout] 220 |     mat: Matrix3<S>
[INFO] [stdout]     |     ^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this error originates in the derive macro `PartialEq` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: consider restricting type parameter `S`
[INFO] [stdout]     |
[INFO] [stdout] 219 | pub struct Basis3<S: std::marker::Copy> {
[INFO] [stdout]     |                    +++++++++++++++++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0277]: the trait bound `S: Copy` is not satisfied
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/rotation.rs:220:5
[INFO] [stdout]     |
[INFO] [stdout] 216 | #[derive(PartialEq, Copy, Clone)]
[INFO] [stdout]     |                           ----- in this derive macro expansion
[INFO] [stdout] ...
[INFO] [stdout] 220 |     mat: Matrix3<S>
[INFO] [stdout]     |     ^^^^^^^^^^^^^^^ the trait `Copy` is not implemented for `S`, which is required by `Matrix3<S>: Clone`
[INFO] [stdout]     |
[INFO] [stdout] note: required for `Matrix3<S>` to implement `Clone`
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/matrix.rs:52:16
[INFO] [stdout]     |
[INFO] [stdout] 52  | #[derive(Copy, Clone, PartialEq)]
[INFO] [stdout]     |                ^^^^^ unsatisfied trait bound introduced in this `derive` macro
[INFO] [stdout]     = note: this error originates in the derive macro `Clone` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: consider restricting type parameter `S`
[INFO] [stdout]     |
[INFO] [stdout] 219 | pub struct Basis3<S: std::marker::Copy> {
[INFO] [stdout]     |                    +++++++++++++++++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0277]: the trait bound `S: Copy` is not satisfied
[INFO] [stdout]   --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/projection.rs:73:5
[INFO] [stdout]    |
[INFO] [stdout] 70 | #[cfg_attr(feature = "rustc-serialize", derive(RustcEncodable, RustcDecodable))]
[INFO] [stdout]    |                                                --------------
[INFO] [stdout]    |                                                |
[INFO] [stdout]    |                                                required by a bound introduced by this call
[INFO] [stdout]    |                                                in this derive macro expansion
[INFO] [stdout] ...
[INFO] [stdout] 73 |     pub fovy:   Rad<S>,
[INFO] [stdout]    |     ^^^^^^^^^^^^^^^^^^ the trait `Copy` is not implemented for `S`, which is required by `&Rad<S>: Encodable`
[INFO] [stdout]    |
[INFO] [stdout] note: required for `Rad<S>` to implement `Encodable`
[INFO] [stdout]   --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/angle.rs:36:48
[INFO] [stdout]    |
[INFO] [stdout] 36 | #[cfg_attr(feature = "rustc-serialize", derive(RustcEncodable, RustcDecodable))]
[INFO] [stdout]    |                                                ^^^^^^^^^^^^^^ unsatisfied trait bound introduced in this `derive` macro
[INFO] [stdout]    = note: 1 redundant requirement hidden
[INFO] [stdout]    = note: required for `&Rad<S>` to implement `Encodable`
[INFO] [stdout]    = note: this error originates in the derive macro `RustcEncodable` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: consider restricting type parameter `S`
[INFO] [stdout]    |
[INFO] [stdout] 72 | pub struct PerspectiveFov<S: std::marker::Copy> {
[INFO] [stdout]    |                            +++++++++++++++++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0277]: the trait bound `S: Copy` is not satisfied
[INFO] [stdout]   --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/projection.rs:73:5
[INFO] [stdout]    |
[INFO] [stdout] 70 | #[cfg_attr(feature = "rustc-serialize", derive(RustcEncodable, RustcDecodable))]
[INFO] [stdout]    |                                                                -------------- in this derive macro expansion
[INFO] [stdout] ...
[INFO] [stdout] 73 |     pub fovy:   Rad<S>,
[INFO] [stdout]    |     ^^^^^^^^^^^^^^^^^^ the trait `Copy` is not implemented for `S`, which is required by `Rad<_>: Decodable`
[INFO] [stdout]    |
[INFO] [stdout] note: required for `Rad<S>` to implement `Decodable`
[INFO] [stdout]   --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/angle.rs:36:64
[INFO] [stdout]    |
[INFO] [stdout] 36 | #[cfg_attr(feature = "rustc-serialize", derive(RustcEncodable, RustcDecodable))]
[INFO] [stdout]    |                                                                ^^^^^^^^^^^^^^ unsatisfied trait bound introduced in this `derive` macro
[INFO] [stdout]    = note: this error originates in the derive macro `RustcDecodable` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: consider restricting type parameter `S`
[INFO] [stdout]    |
[INFO] [stdout] 72 | pub struct PerspectiveFov<S: std::marker::Copy> {
[INFO] [stdout]    |                            +++++++++++++++++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0277]: the trait bound `S: Copy` is not satisfied
[INFO] [stdout]   --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/projection.rs:70:64
[INFO] [stdout]    |
[INFO] [stdout] 70 | #[cfg_attr(feature = "rustc-serialize", derive(RustcEncodable, RustcDecodable))]
[INFO] [stdout]    |                                                                ^^^^^^^^^^^^^^ the trait `Copy` is not implemented for `S`, which is required by `Rad<_>: Decodable`
[INFO] [stdout]    |
[INFO] [stdout] note: required for `Rad<S>` to implement `Decodable`
[INFO] [stdout]   --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/angle.rs:36:64
[INFO] [stdout]    |
[INFO] [stdout] 36 | #[cfg_attr(feature = "rustc-serialize", derive(RustcEncodable, RustcDecodable))]
[INFO] [stdout]    |                                                                ^^^^^^^^^^^^^^ unsatisfied trait bound introduced in this `derive` macro
[INFO] [stdout]    = note: this error originates in the derive macro `RustcDecodable` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: consider restricting type parameter `S`
[INFO] [stdout]    |
[INFO] [stdout] 72 | pub struct PerspectiveFov<S: std::marker::Copy> {
[INFO] [stdout]    |                            +++++++++++++++++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0277]: the trait bound `S: Copy` is not satisfied
[INFO] [stdout]   --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/projection.rs:73:5
[INFO] [stdout]    |
[INFO] [stdout] 69 | #[derive(Copy, Clone, Debug, PartialEq)]
[INFO] [stdout]    |                ----- in this derive macro expansion
[INFO] [stdout] ...
[INFO] [stdout] 73 |     pub fovy:   Rad<S>,
[INFO] [stdout]    |     ^^^^^^^^^^^^^^^^^^ the trait `Copy` is not implemented for `S`, which is required by `Rad<S>: Clone`
[INFO] [stdout]    |
[INFO] [stdout] note: required for `Rad<S>` to implement `Clone`
[INFO] [stdout]   --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/angle.rs:35:16
[INFO] [stdout]    |
[INFO] [stdout] 35 | #[derive(Copy, Clone, PartialEq, PartialOrd)]
[INFO] [stdout]    |                ^^^^^ unsatisfied trait bound introduced in this `derive` macro
[INFO] [stdout]    = note: this error originates in the derive macro `Clone` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: consider restricting type parameter `S`
[INFO] [stdout]    |
[INFO] [stdout] 72 | pub struct PerspectiveFov<S: std::marker::Copy> {
[INFO] [stdout]    |                            +++++++++++++++++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0369]: binary operation `==` cannot be applied to type `Rad<S>`
[INFO] [stdout]   --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/projection.rs:73:5
[INFO] [stdout]    |
[INFO] [stdout] 69 | #[derive(Copy, Clone, Debug, PartialEq)]
[INFO] [stdout]    |                              --------- in this derive macro expansion
[INFO] [stdout] ...
[INFO] [stdout] 73 |     pub fovy:   Rad<S>,
[INFO] [stdout]    |     ^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this error originates in the derive macro `PartialEq` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: consider restricting type parameter `S`
[INFO] [stdout]    |
[INFO] [stdout] 72 | pub struct PerspectiveFov<S: std::marker::Copy> {
[INFO] [stdout]    |                            +++++++++++++++++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/matrix.rs:240:22
[INFO] [stdout]     |
[INFO] [stdout] 240 |         Matrix4::new(s.x.clone(), u.x.clone(), -f.x.clone(), S::zero(),
[INFO] [stdout]     |                      ^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/matrix.rs:240:35
[INFO] [stdout]     |
[INFO] [stdout] 240 |         Matrix4::new(s.x.clone(), u.x.clone(), -f.x.clone(), S::zero(),
[INFO] [stdout]     |                                   ^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/matrix.rs:240:49
[INFO] [stdout]     |
[INFO] [stdout] 240 |         Matrix4::new(s.x.clone(), u.x.clone(), -f.x.clone(), S::zero(),
[INFO] [stdout]     |                                                 ^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/matrix.rs:241:22
[INFO] [stdout]     |
[INFO] [stdout] 241 |                      s.y.clone(), u.y.clone(), -f.y.clone(), S::zero(),
[INFO] [stdout]     |                      ^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/matrix.rs:241:35
[INFO] [stdout]     |
[INFO] [stdout] 241 |                      s.y.clone(), u.y.clone(), -f.y.clone(), S::zero(),
[INFO] [stdout]     |                                   ^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/matrix.rs:241:49
[INFO] [stdout]     |
[INFO] [stdout] 241 |                      s.y.clone(), u.y.clone(), -f.y.clone(), S::zero(),
[INFO] [stdout]     |                                                 ^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/matrix.rs:242:22
[INFO] [stdout]     |
[INFO] [stdout] 242 |                      s.z.clone(), u.z.clone(), -f.z.clone(), S::zero(),
[INFO] [stdout]     |                      ^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/matrix.rs:242:35
[INFO] [stdout]     |
[INFO] [stdout] 242 |                      s.z.clone(), u.z.clone(), -f.z.clone(), S::zero(),
[INFO] [stdout]     |                                   ^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/matrix.rs:242:49
[INFO] [stdout]     |
[INFO] [stdout] 242 |                      s.z.clone(), u.z.clone(), -f.z.clone(), S::zero(),
[INFO] [stdout]     |                                                 ^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/matrix.rs:682:45
[INFO] [stdout]     |
[INFO] [stdout] 682 |                     0 => Matrix3::from_cols(t.y.truncate_n(j), t.z.truncate_n(j), t.w.truncate_n(j)),
[INFO] [stdout]     |                                             ^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/matrix.rs:682:64
[INFO] [stdout]     |
[INFO] [stdout] 682 |                     0 => Matrix3::from_cols(t.y.truncate_n(j), t.z.truncate_n(j), t.w.truncate_n(j)),
[INFO] [stdout]     |                                                                ^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/matrix.rs:682:83
[INFO] [stdout]     |
[INFO] [stdout] 682 |                     0 => Matrix3::from_cols(t.y.truncate_n(j), t.z.truncate_n(j), t.w.truncate_n(j)),
[INFO] [stdout]     |                                                                                   ^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/matrix.rs:683:45
[INFO] [stdout]     |
[INFO] [stdout] 683 |                     1 => Matrix3::from_cols(t.x.truncate_n(j), t.z.truncate_n(j), t.w.truncate_n(j)),
[INFO] [stdout]     |                                             ^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/matrix.rs:683:64
[INFO] [stdout]     |
[INFO] [stdout] 683 |                     1 => Matrix3::from_cols(t.x.truncate_n(j), t.z.truncate_n(j), t.w.truncate_n(j)),
[INFO] [stdout]     |                                                                ^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/matrix.rs:683:83
[INFO] [stdout]     |
[INFO] [stdout] 683 |                     1 => Matrix3::from_cols(t.x.truncate_n(j), t.z.truncate_n(j), t.w.truncate_n(j)),
[INFO] [stdout]     |                                                                                   ^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/matrix.rs:684:45
[INFO] [stdout]     |
[INFO] [stdout] 684 |                     2 => Matrix3::from_cols(t.x.truncate_n(j), t.y.truncate_n(j), t.w.truncate_n(j)),
[INFO] [stdout]     |                                             ^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/matrix.rs:684:64
[INFO] [stdout]     |
[INFO] [stdout] 684 |                     2 => Matrix3::from_cols(t.x.truncate_n(j), t.y.truncate_n(j), t.w.truncate_n(j)),
[INFO] [stdout]     |                                                                ^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/matrix.rs:684:83
[INFO] [stdout]     |
[INFO] [stdout] 684 |                     2 => Matrix3::from_cols(t.x.truncate_n(j), t.y.truncate_n(j), t.w.truncate_n(j)),
[INFO] [stdout]     |                                                                                   ^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/matrix.rs:685:45
[INFO] [stdout]     |
[INFO] [stdout] 685 |                     3 => Matrix3::from_cols(t.x.truncate_n(j), t.y.truncate_n(j), t.z.truncate_n(j)),
[INFO] [stdout]     |                                             ^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/matrix.rs:685:64
[INFO] [stdout]     |
[INFO] [stdout] 685 |                     3 => Matrix3::from_cols(t.x.truncate_n(j), t.y.truncate_n(j), t.z.truncate_n(j)),
[INFO] [stdout]     |                                                                ^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/matrix.rs:685:83
[INFO] [stdout]     |
[INFO] [stdout] 685 |                     3 => Matrix3::from_cols(t.x.truncate_n(j), t.y.truncate_n(j), t.z.truncate_n(j)),
[INFO] [stdout]     |                                                                                   ^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/matrix.rs:871:50
[INFO] [stdout]     |
[INFO] [stdout] 871 |             fn mul_assign(&mut self, scalar) { $(self.$field *= scalar);+ }
[INFO] [stdout]     |                                                  ^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 926 | impl_operators!(Matrix2, Vector2 { x: 0, y: 1 });
[INFO] [stdout]     | ------------------------------------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_operators` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/matrix.rs:874:50
[INFO] [stdout]     |
[INFO] [stdout] 874 |             fn div_assign(&mut self, scalar) { $(self.$field /= scalar);+ }
[INFO] [stdout]     |                                                  ^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 926 | impl_operators!(Matrix2, Vector2 { x: 0, y: 1 });
[INFO] [stdout]     | ------------------------------------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_operators` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/matrix.rs:877:50
[INFO] [stdout]     |
[INFO] [stdout] 877 |             fn rem_assign(&mut self, scalar) { $(self.$field %= scalar);+ }
[INFO] [stdout]     |                                                  ^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 926 | impl_operators!(Matrix2, Vector2 { x: 0, y: 1 });
[INFO] [stdout]     | ------------------------------------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_operators` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/matrix.rs:887:62
[INFO] [stdout]     |
[INFO] [stdout] 887 |             fn add_assign(&mut self, other: $MatrixN<S>) { $(self.$field += other.$field);+ }
[INFO] [stdout]     |                                                              ^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 926 | impl_operators!(Matrix2, Vector2 { x: 0, y: 1 });
[INFO] [stdout]     | ------------------------------------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_operators` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/matrix.rs:890:62
[INFO] [stdout]     |
[INFO] [stdout] 890 |             fn sub_assign(&mut self, other: $MatrixN<S>) { $(self.$field -= other.$field);+ }
[INFO] [stdout]     |                                                              ^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 926 | impl_operators!(Matrix2, Vector2 { x: 0, y: 1 });
[INFO] [stdout]     | ------------------------------------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_operators` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/matrix.rs:871:50
[INFO] [stdout]     |
[INFO] [stdout] 871 |             fn mul_assign(&mut self, scalar) { $(self.$field *= scalar);+ }
[INFO] [stdout]     |                                                  ^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 927 | impl_operators!(Matrix3, Vector3 { x: 0, y: 1, z: 2 });
[INFO] [stdout]     | ------------------------------------------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_operators` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/matrix.rs:874:50
[INFO] [stdout]     |
[INFO] [stdout] 874 |             fn div_assign(&mut self, scalar) { $(self.$field /= scalar);+ }
[INFO] [stdout]     |                                                  ^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 927 | impl_operators!(Matrix3, Vector3 { x: 0, y: 1, z: 2 });
[INFO] [stdout]     | ------------------------------------------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_operators` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/matrix.rs:877:50
[INFO] [stdout]     |
[INFO] [stdout] 877 |             fn rem_assign(&mut self, scalar) { $(self.$field %= scalar);+ }
[INFO] [stdout]     |                                                  ^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 927 | impl_operators!(Matrix3, Vector3 { x: 0, y: 1, z: 2 });
[INFO] [stdout]     | ------------------------------------------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_operators` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/matrix.rs:887:62
[INFO] [stdout]     |
[INFO] [stdout] 887 |             fn add_assign(&mut self, other: $MatrixN<S>) { $(self.$field += other.$field);+ }
[INFO] [stdout]     |                                                              ^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 927 | impl_operators!(Matrix3, Vector3 { x: 0, y: 1, z: 2 });
[INFO] [stdout]     | ------------------------------------------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_operators` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/matrix.rs:890:62
[INFO] [stdout]     |
[INFO] [stdout] 890 |             fn sub_assign(&mut self, other: $MatrixN<S>) { $(self.$field -= other.$field);+ }
[INFO] [stdout]     |                                                              ^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 927 | impl_operators!(Matrix3, Vector3 { x: 0, y: 1, z: 2 });
[INFO] [stdout]     | ------------------------------------------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_operators` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/matrix.rs:871:50
[INFO] [stdout]     |
[INFO] [stdout] 871 |             fn mul_assign(&mut self, scalar) { $(self.$field *= scalar);+ }
[INFO] [stdout]     |                                                  ^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 928 | impl_operators!(Matrix4, Vector4 { x: 0, y: 1, z: 2, w: 3 });
[INFO] [stdout]     | ------------------------------------------------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_operators` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/matrix.rs:874:50
[INFO] [stdout]     |
[INFO] [stdout] 874 |             fn div_assign(&mut self, scalar) { $(self.$field /= scalar);+ }
[INFO] [stdout]     |                                                  ^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 928 | impl_operators!(Matrix4, Vector4 { x: 0, y: 1, z: 2, w: 3 });
[INFO] [stdout]     | ------------------------------------------------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_operators` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/matrix.rs:877:50
[INFO] [stdout]     |
[INFO] [stdout] 877 |             fn rem_assign(&mut self, scalar) { $(self.$field %= scalar);+ }
[INFO] [stdout]     |                                                  ^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 928 | impl_operators!(Matrix4, Vector4 { x: 0, y: 1, z: 2, w: 3 });
[INFO] [stdout]     | ------------------------------------------------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_operators` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/matrix.rs:887:62
[INFO] [stdout]     |
[INFO] [stdout] 887 |             fn add_assign(&mut self, other: $MatrixN<S>) { $(self.$field += other.$field);+ }
[INFO] [stdout]     |                                                              ^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 928 | impl_operators!(Matrix4, Vector4 { x: 0, y: 1, z: 2, w: 3 });
[INFO] [stdout]     | ------------------------------------------------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_operators` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/matrix.rs:890:62
[INFO] [stdout]     |
[INFO] [stdout] 890 |             fn sub_assign(&mut self, other: $MatrixN<S>) { $(self.$field -= other.$field);+ }
[INFO] [stdout]     |                                                              ^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 928 | impl_operators!(Matrix4, Vector4 { x: 0, y: 1, z: 2, w: 3 });
[INFO] [stdout]     | ------------------------------------------------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_operators` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/quaternion.rs:190:40
[INFO] [stdout]     |
[INFO] [stdout] 190 |     fn mul_assign(&mut self, scalar) { self.s *= scalar; self.v *= scalar; }
[INFO] [stdout]     |                                        ^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/quaternion.rs:190:58
[INFO] [stdout]     |
[INFO] [stdout] 190 |     fn mul_assign(&mut self, scalar) { self.s *= scalar; self.v *= scalar; }
[INFO] [stdout]     |                                                          ^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/quaternion.rs:199:40
[INFO] [stdout]     |
[INFO] [stdout] 199 |     fn div_assign(&mut self, scalar) { self.s /= scalar; self.v /= scalar; }
[INFO] [stdout]     |                                        ^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/quaternion.rs:199:58
[INFO] [stdout]     |
[INFO] [stdout] 199 |     fn div_assign(&mut self, scalar) { self.s /= scalar; self.v /= scalar; }
[INFO] [stdout]     |                                                          ^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/quaternion.rs:208:40
[INFO] [stdout]     |
[INFO] [stdout] 208 |     fn rem_assign(&mut self, scalar) { self.s %= scalar; self.v %= scalar; }
[INFO] [stdout]     |                                        ^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/quaternion.rs:208:58
[INFO] [stdout]     |
[INFO] [stdout] 208 |     fn rem_assign(&mut self, scalar) { self.s %= scalar; self.v %= scalar; }
[INFO] [stdout]     |                                                          ^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/quaternion.rs:226:39
[INFO] [stdout]     |
[INFO] [stdout] 226 |     fn add_assign(&mut self, other) { self.s += other.s; self.v += other.v; }
[INFO] [stdout]     |                                       ^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/quaternion.rs:226:58
[INFO] [stdout]     |
[INFO] [stdout] 226 |     fn add_assign(&mut self, other) { self.s += other.s; self.v += other.v; }
[INFO] [stdout]     |                                                          ^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/quaternion.rs:235:39
[INFO] [stdout]     |
[INFO] [stdout] 235 |     fn sub_assign(&mut self, other) { self.s -= other.s; self.v -= other.v; }
[INFO] [stdout]     |                                       ^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/quaternion.rs:235:58
[INFO] [stdout]     |
[INFO] [stdout] 235 |     fn sub_assign(&mut self, other) { self.s -= other.s; self.v -= other.v; }
[INFO] [stdout]     |                                                          ^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/quaternion.rs:277:9
[INFO] [stdout]     |
[INFO] [stdout] 277 |         self.s.approx_eq_eps(&other.s, epsilon) &&
[INFO] [stdout]     |         ^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/quaternion.rs:277:30
[INFO] [stdout]     |
[INFO] [stdout] 277 |         self.s.approx_eq_eps(&other.s, epsilon) &&
[INFO] [stdout]     |                              ^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/quaternion.rs:278:9
[INFO] [stdout]     |
[INFO] [stdout] 278 |         self.v.approx_eq_eps(&other.v, epsilon)
[INFO] [stdout]     |         ^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/quaternion.rs:278:30
[INFO] [stdout]     |
[INFO] [stdout] 278 |         self.v.approx_eq_eps(&other.v, epsilon)
[INFO] [stdout]     |                              ^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/vector.rs:179:19
[INFO] [stdout]     |
[INFO] [stdout] 179 |                 $(self.$field.approx_eq_eps(&other.$field, epsilon))&&+
[INFO] [stdout]     |                   ^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 288 | impl_vector!(Vector1 { x }, 1, vec1);
[INFO] [stdout]     | ------------------------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_vector` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/vector.rs:179:45
[INFO] [stdout]     |
[INFO] [stdout] 179 |                 $(self.$field.approx_eq_eps(&other.$field, epsilon))&&+
[INFO] [stdout]     |                                             ^^^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 288 | impl_vector!(Vector1 { x }, 1, vec1);
[INFO] [stdout]     | ------------------------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_vector` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/vector.rs:194:49
[INFO] [stdout]     |
[INFO] [stdout] 194 |             fn add_assign(&mut self, other) { $(self.$field += other.$field);+ }
[INFO] [stdout]     |                                                 ^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 288 | impl_vector!(Vector1 { x }, 1, vec1);
[INFO] [stdout]     | ------------------------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_vector` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/vector.rs:201:49
[INFO] [stdout]     |
[INFO] [stdout] 201 |             fn sub_assign(&mut self, other) { $(self.$field -= other.$field);+ }
[INFO] [stdout]     |                                                 ^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 288 | impl_vector!(Vector1 { x }, 1, vec1);
[INFO] [stdout]     | ------------------------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_vector` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/vector.rs:208:50
[INFO] [stdout]     |
[INFO] [stdout] 208 |             fn mul_assign(&mut self, scalar) { $(self.$field *= scalar);+ }
[INFO] [stdout]     |                                                  ^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 288 | impl_vector!(Vector1 { x }, 1, vec1);
[INFO] [stdout]     | ------------------------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_vector` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/vector.rs:215:50
[INFO] [stdout]     |
[INFO] [stdout] 215 |             fn div_assign(&mut self, scalar) { $(self.$field /= scalar);+ }
[INFO] [stdout]     |                                                  ^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 288 | impl_vector!(Vector1 { x }, 1, vec1);
[INFO] [stdout]     | ------------------------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_vector` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/vector.rs:222:50
[INFO] [stdout]     |
[INFO] [stdout] 222 |             fn rem_assign(&mut self, scalar) { $(self.$field %= scalar);+ }
[INFO] [stdout]     |                                                  ^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 288 | impl_vector!(Vector1 { x }, 1, vec1);
[INFO] [stdout]     | ------------------------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_vector` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/vector.rs:232:83
[INFO] [stdout]     |
[INFO] [stdout] 232 |             #[inline] fn add_assign_element_wise(&mut self, rhs: $VectorN<S>) { $(self.$field += rhs.$field);+ }
[INFO] [stdout]     |                                                                                   ^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 288 | impl_vector!(Vector1 { x }, 1, vec1);
[INFO] [stdout]     | ------------------------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_vector` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/vector.rs:233:83
[INFO] [stdout]     |
[INFO] [stdout] 233 |             #[inline] fn sub_assign_element_wise(&mut self, rhs: $VectorN<S>) { $(self.$field -= rhs.$field);+ }
[INFO] [stdout]     |                                                                                   ^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 288 | impl_vector!(Vector1 { x }, 1, vec1);
[INFO] [stdout]     | ------------------------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_vector` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/vector.rs:234:83
[INFO] [stdout]     |
[INFO] [stdout] 234 |             #[inline] fn mul_assign_element_wise(&mut self, rhs: $VectorN<S>) { $(self.$field *= rhs.$field);+ }
[INFO] [stdout]     |                                                                                   ^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 288 | impl_vector!(Vector1 { x }, 1, vec1);
[INFO] [stdout]     | ------------------------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_vector` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/vector.rs:235:83
[INFO] [stdout]     |
[INFO] [stdout] 235 |             #[inline] fn div_assign_element_wise(&mut self, rhs: $VectorN<S>) { $(self.$field /= rhs.$field);+ }
[INFO] [stdout]     |                                                                                   ^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 288 | impl_vector!(Vector1 { x }, 1, vec1);
[INFO] [stdout]     | ------------------------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_vector` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/vector.rs:236:83
[INFO] [stdout]     |
[INFO] [stdout] 236 |             #[inline] fn rem_assign_element_wise(&mut self, rhs: $VectorN<S>) { $(self.$field %= rhs.$field);+ }
[INFO] [stdout]     |                                                                                   ^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 288 | impl_vector!(Vector1 { x }, 1, vec1);
[INFO] [stdout]     | ------------------------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_vector` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/vector.rs:246:73
[INFO] [stdout]     |
[INFO] [stdout] 246 |             #[inline] fn add_assign_element_wise(&mut self, rhs: S) { $(self.$field += rhs);+ }
[INFO] [stdout]     |                                                                         ^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 288 | impl_vector!(Vector1 { x }, 1, vec1);
[INFO] [stdout]     | ------------------------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_vector` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/vector.rs:247:73
[INFO] [stdout]     |
[INFO] [stdout] 247 |             #[inline] fn sub_assign_element_wise(&mut self, rhs: S) { $(self.$field -= rhs);+ }
[INFO] [stdout]     |                                                                         ^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 288 | impl_vector!(Vector1 { x }, 1, vec1);
[INFO] [stdout]     | ------------------------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_vector` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/vector.rs:248:73
[INFO] [stdout]     |
[INFO] [stdout] 248 |             #[inline] fn mul_assign_element_wise(&mut self, rhs: S) { $(self.$field *= rhs);+ }
[INFO] [stdout]     |                                                                         ^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 288 | impl_vector!(Vector1 { x }, 1, vec1);
[INFO] [stdout]     | ------------------------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_vector` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/vector.rs:249:73
[INFO] [stdout]     |
[INFO] [stdout] 249 |             #[inline] fn div_assign_element_wise(&mut self, rhs: S) { $(self.$field /= rhs);+ }
[INFO] [stdout]     |                                                                         ^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 288 | impl_vector!(Vector1 { x }, 1, vec1);
[INFO] [stdout]     | ------------------------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_vector` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/vector.rs:250:73
[INFO] [stdout]     |
[INFO] [stdout] 250 |             #[inline] fn rem_assign_element_wise(&mut self, rhs: S) { $(self.$field %= rhs);+ }
[INFO] [stdout]     |                                                                         ^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 288 | impl_vector!(Vector1 { x }, 1, vec1);
[INFO] [stdout]     | ------------------------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_vector` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/vector.rs:179:19
[INFO] [stdout]     |
[INFO] [stdout] 179 |                 $(self.$field.approx_eq_eps(&other.$field, epsilon))&&+
[INFO] [stdout]     |                   ^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 289 | impl_vector!(Vector2 { x, y }, 2, vec2);
[INFO] [stdout]     | --------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_vector` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/vector.rs:179:45
[INFO] [stdout]     |
[INFO] [stdout] 179 |                 $(self.$field.approx_eq_eps(&other.$field, epsilon))&&+
[INFO] [stdout]     |                                             ^^^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 289 | impl_vector!(Vector2 { x, y }, 2, vec2);
[INFO] [stdout]     | --------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_vector` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/vector.rs:194:49
[INFO] [stdout]     |
[INFO] [stdout] 194 |             fn add_assign(&mut self, other) { $(self.$field += other.$field);+ }
[INFO] [stdout]     |                                                 ^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 289 | impl_vector!(Vector2 { x, y }, 2, vec2);
[INFO] [stdout]     | --------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_vector` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/vector.rs:201:49
[INFO] [stdout]     |
[INFO] [stdout] 201 |             fn sub_assign(&mut self, other) { $(self.$field -= other.$field);+ }
[INFO] [stdout]     |                                                 ^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 289 | impl_vector!(Vector2 { x, y }, 2, vec2);
[INFO] [stdout]     | --------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_vector` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/vector.rs:208:50
[INFO] [stdout]     |
[INFO] [stdout] 208 |             fn mul_assign(&mut self, scalar) { $(self.$field *= scalar);+ }
[INFO] [stdout]     |                                                  ^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 289 | impl_vector!(Vector2 { x, y }, 2, vec2);
[INFO] [stdout]     | --------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_vector` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/vector.rs:215:50
[INFO] [stdout]     |
[INFO] [stdout] 215 |             fn div_assign(&mut self, scalar) { $(self.$field /= scalar);+ }
[INFO] [stdout]     |                                                  ^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 289 | impl_vector!(Vector2 { x, y }, 2, vec2);
[INFO] [stdout]     | --------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_vector` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/vector.rs:222:50
[INFO] [stdout]     |
[INFO] [stdout] 222 |             fn rem_assign(&mut self, scalar) { $(self.$field %= scalar);+ }
[INFO] [stdout]     |                                                  ^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 289 | impl_vector!(Vector2 { x, y }, 2, vec2);
[INFO] [stdout]     | --------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_vector` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/vector.rs:232:83
[INFO] [stdout]     |
[INFO] [stdout] 232 |             #[inline] fn add_assign_element_wise(&mut self, rhs: $VectorN<S>) { $(self.$field += rhs.$field);+ }
[INFO] [stdout]     |                                                                                   ^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 289 | impl_vector!(Vector2 { x, y }, 2, vec2);
[INFO] [stdout]     | --------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_vector` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/vector.rs:233:83
[INFO] [stdout]     |
[INFO] [stdout] 233 |             #[inline] fn sub_assign_element_wise(&mut self, rhs: $VectorN<S>) { $(self.$field -= rhs.$field);+ }
[INFO] [stdout]     |                                                                                   ^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 289 | impl_vector!(Vector2 { x, y }, 2, vec2);
[INFO] [stdout]     | --------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_vector` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/vector.rs:234:83
[INFO] [stdout]     |
[INFO] [stdout] 234 |             #[inline] fn mul_assign_element_wise(&mut self, rhs: $VectorN<S>) { $(self.$field *= rhs.$field);+ }
[INFO] [stdout]     |                                                                                   ^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 289 | impl_vector!(Vector2 { x, y }, 2, vec2);
[INFO] [stdout]     | --------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_vector` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/vector.rs:235:83
[INFO] [stdout]     |
[INFO] [stdout] 235 |             #[inline] fn div_assign_element_wise(&mut self, rhs: $VectorN<S>) { $(self.$field /= rhs.$field);+ }
[INFO] [stdout]     |                                                                                   ^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 289 | impl_vector!(Vector2 { x, y }, 2, vec2);
[INFO] [stdout]     | --------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_vector` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/vector.rs:236:83
[INFO] [stdout]     |
[INFO] [stdout] 236 |             #[inline] fn rem_assign_element_wise(&mut self, rhs: $VectorN<S>) { $(self.$field %= rhs.$field);+ }
[INFO] [stdout]     |                                                                                   ^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 289 | impl_vector!(Vector2 { x, y }, 2, vec2);
[INFO] [stdout]     | --------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_vector` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/vector.rs:246:73
[INFO] [stdout]     |
[INFO] [stdout] 246 |             #[inline] fn add_assign_element_wise(&mut self, rhs: S) { $(self.$field += rhs);+ }
[INFO] [stdout]     |                                                                         ^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 289 | impl_vector!(Vector2 { x, y }, 2, vec2);
[INFO] [stdout]     | --------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_vector` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/vector.rs:247:73
[INFO] [stdout]     |
[INFO] [stdout] 247 |             #[inline] fn sub_assign_element_wise(&mut self, rhs: S) { $(self.$field -= rhs);+ }
[INFO] [stdout]     |                                                                         ^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 289 | impl_vector!(Vector2 { x, y }, 2, vec2);
[INFO] [stdout]     | --------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_vector` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/vector.rs:248:73
[INFO] [stdout]     |
[INFO] [stdout] 248 |             #[inline] fn mul_assign_element_wise(&mut self, rhs: S) { $(self.$field *= rhs);+ }
[INFO] [stdout]     |                                                                         ^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 289 | impl_vector!(Vector2 { x, y }, 2, vec2);
[INFO] [stdout]     | --------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_vector` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/vector.rs:249:73
[INFO] [stdout]     |
[INFO] [stdout] 249 |             #[inline] fn div_assign_element_wise(&mut self, rhs: S) { $(self.$field /= rhs);+ }
[INFO] [stdout]     |                                                                         ^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 289 | impl_vector!(Vector2 { x, y }, 2, vec2);
[INFO] [stdout]     | --------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_vector` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/vector.rs:250:73
[INFO] [stdout]     |
[INFO] [stdout] 250 |             #[inline] fn rem_assign_element_wise(&mut self, rhs: S) { $(self.$field %= rhs);+ }
[INFO] [stdout]     |                                                                         ^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 289 | impl_vector!(Vector2 { x, y }, 2, vec2);
[INFO] [stdout]     | --------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_vector` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/vector.rs:179:19
[INFO] [stdout]     |
[INFO] [stdout] 179 |                 $(self.$field.approx_eq_eps(&other.$field, epsilon))&&+
[INFO] [stdout]     |                   ^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 290 | impl_vector!(Vector3 { x, y, z }, 3, vec3);
[INFO] [stdout]     | ------------------------------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_vector` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/vector.rs:179:45
[INFO] [stdout]     |
[INFO] [stdout] 179 |                 $(self.$field.approx_eq_eps(&other.$field, epsilon))&&+
[INFO] [stdout]     |                                             ^^^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 290 | impl_vector!(Vector3 { x, y, z }, 3, vec3);
[INFO] [stdout]     | ------------------------------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_vector` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/vector.rs:194:49
[INFO] [stdout]     |
[INFO] [stdout] 194 |             fn add_assign(&mut self, other) { $(self.$field += other.$field);+ }
[INFO] [stdout]     |                                                 ^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 290 | impl_vector!(Vector3 { x, y, z }, 3, vec3);
[INFO] [stdout]     | ------------------------------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_vector` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/vector.rs:201:49
[INFO] [stdout]     |
[INFO] [stdout] 201 |             fn sub_assign(&mut self, other) { $(self.$field -= other.$field);+ }
[INFO] [stdout]     |                                                 ^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 290 | impl_vector!(Vector3 { x, y, z }, 3, vec3);
[INFO] [stdout]     | ------------------------------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_vector` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/vector.rs:208:50
[INFO] [stdout]     |
[INFO] [stdout] 208 |             fn mul_assign(&mut self, scalar) { $(self.$field *= scalar);+ }
[INFO] [stdout]     |                                                  ^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 290 | impl_vector!(Vector3 { x, y, z }, 3, vec3);
[INFO] [stdout]     | ------------------------------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_vector` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/vector.rs:215:50
[INFO] [stdout]     |
[INFO] [stdout] 215 |             fn div_assign(&mut self, scalar) { $(self.$field /= scalar);+ }
[INFO] [stdout]     |                                                  ^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 290 | impl_vector!(Vector3 { x, y, z }, 3, vec3);
[INFO] [stdout]     | ------------------------------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_vector` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/vector.rs:222:50
[INFO] [stdout]     |
[INFO] [stdout] 222 |             fn rem_assign(&mut self, scalar) { $(self.$field %= scalar);+ }
[INFO] [stdout]     |                                                  ^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 290 | impl_vector!(Vector3 { x, y, z }, 3, vec3);
[INFO] [stdout]     | ------------------------------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_vector` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/vector.rs:232:83
[INFO] [stdout]     |
[INFO] [stdout] 232 |             #[inline] fn add_assign_element_wise(&mut self, rhs: $VectorN<S>) { $(self.$field += rhs.$field);+ }
[INFO] [stdout]     |                                                                                   ^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 290 | impl_vector!(Vector3 { x, y, z }, 3, vec3);
[INFO] [stdout]     | ------------------------------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_vector` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/vector.rs:233:83
[INFO] [stdout]     |
[INFO] [stdout] 233 |             #[inline] fn sub_assign_element_wise(&mut self, rhs: $VectorN<S>) { $(self.$field -= rhs.$field);+ }
[INFO] [stdout]     |                                                                                   ^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 290 | impl_vector!(Vector3 { x, y, z }, 3, vec3);
[INFO] [stdout]     | ------------------------------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_vector` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/vector.rs:234:83
[INFO] [stdout]     |
[INFO] [stdout] 234 |             #[inline] fn mul_assign_element_wise(&mut self, rhs: $VectorN<S>) { $(self.$field *= rhs.$field);+ }
[INFO] [stdout]     |                                                                                   ^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 290 | impl_vector!(Vector3 { x, y, z }, 3, vec3);
[INFO] [stdout]     | ------------------------------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_vector` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/vector.rs:235:83
[INFO] [stdout]     |
[INFO] [stdout] 235 |             #[inline] fn div_assign_element_wise(&mut self, rhs: $VectorN<S>) { $(self.$field /= rhs.$field);+ }
[INFO] [stdout]     |                                                                                   ^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 290 | impl_vector!(Vector3 { x, y, z }, 3, vec3);
[INFO] [stdout]     | ------------------------------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_vector` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/vector.rs:236:83
[INFO] [stdout]     |
[INFO] [stdout] 236 |             #[inline] fn rem_assign_element_wise(&mut self, rhs: $VectorN<S>) { $(self.$field %= rhs.$field);+ }
[INFO] [stdout]     |                                                                                   ^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 290 | impl_vector!(Vector3 { x, y, z }, 3, vec3);
[INFO] [stdout]     | ------------------------------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_vector` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/vector.rs:246:73
[INFO] [stdout]     |
[INFO] [stdout] 246 |             #[inline] fn add_assign_element_wise(&mut self, rhs: S) { $(self.$field += rhs);+ }
[INFO] [stdout]     |                                                                         ^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 290 | impl_vector!(Vector3 { x, y, z }, 3, vec3);
[INFO] [stdout]     | ------------------------------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_vector` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/vector.rs:247:73
[INFO] [stdout]     |
[INFO] [stdout] 247 |             #[inline] fn sub_assign_element_wise(&mut self, rhs: S) { $(self.$field -= rhs);+ }
[INFO] [stdout]     |                                                                         ^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 290 | impl_vector!(Vector3 { x, y, z }, 3, vec3);
[INFO] [stdout]     | ------------------------------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_vector` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/vector.rs:248:73
[INFO] [stdout]     |
[INFO] [stdout] 248 |             #[inline] fn mul_assign_element_wise(&mut self, rhs: S) { $(self.$field *= rhs);+ }
[INFO] [stdout]     |                                                                         ^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 290 | impl_vector!(Vector3 { x, y, z }, 3, vec3);
[INFO] [stdout]     | ------------------------------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_vector` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/vector.rs:249:73
[INFO] [stdout]     |
[INFO] [stdout] 249 |             #[inline] fn div_assign_element_wise(&mut self, rhs: S) { $(self.$field /= rhs);+ }
[INFO] [stdout]     |                                                                         ^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 290 | impl_vector!(Vector3 { x, y, z }, 3, vec3);
[INFO] [stdout]     | ------------------------------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_vector` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/vector.rs:250:73
[INFO] [stdout]     |
[INFO] [stdout] 250 |             #[inline] fn rem_assign_element_wise(&mut self, rhs: S) { $(self.$field %= rhs);+ }
[INFO] [stdout]     |                                                                         ^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 290 | impl_vector!(Vector3 { x, y, z }, 3, vec3);
[INFO] [stdout]     | ------------------------------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_vector` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/vector.rs:179:19
[INFO] [stdout]     |
[INFO] [stdout] 179 |                 $(self.$field.approx_eq_eps(&other.$field, epsilon))&&+
[INFO] [stdout]     |                   ^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 291 | impl_vector!(Vector4 { x, y, z, w }, 4, vec4);
[INFO] [stdout]     | --------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_vector` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/vector.rs:179:45
[INFO] [stdout]     |
[INFO] [stdout] 179 |                 $(self.$field.approx_eq_eps(&other.$field, epsilon))&&+
[INFO] [stdout]     |                                             ^^^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 291 | impl_vector!(Vector4 { x, y, z, w }, 4, vec4);
[INFO] [stdout]     | --------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_vector` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/vector.rs:194:49
[INFO] [stdout]     |
[INFO] [stdout] 194 |             fn add_assign(&mut self, other) { $(self.$field += other.$field);+ }
[INFO] [stdout]     |                                                 ^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 291 | impl_vector!(Vector4 { x, y, z, w }, 4, vec4);
[INFO] [stdout]     | --------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_vector` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/vector.rs:201:49
[INFO] [stdout]     |
[INFO] [stdout] 201 |             fn sub_assign(&mut self, other) { $(self.$field -= other.$field);+ }
[INFO] [stdout]     |                                                 ^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 291 | impl_vector!(Vector4 { x, y, z, w }, 4, vec4);
[INFO] [stdout]     | --------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_vector` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/vector.rs:208:50
[INFO] [stdout]     |
[INFO] [stdout] 208 |             fn mul_assign(&mut self, scalar) { $(self.$field *= scalar);+ }
[INFO] [stdout]     |                                                  ^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 291 | impl_vector!(Vector4 { x, y, z, w }, 4, vec4);
[INFO] [stdout]     | --------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_vector` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/vector.rs:215:50
[INFO] [stdout]     |
[INFO] [stdout] 215 |             fn div_assign(&mut self, scalar) { $(self.$field /= scalar);+ }
[INFO] [stdout]     |                                                  ^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 291 | impl_vector!(Vector4 { x, y, z, w }, 4, vec4);
[INFO] [stdout]     | --------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_vector` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/vector.rs:222:50
[INFO] [stdout]     |
[INFO] [stdout] 222 |             fn rem_assign(&mut self, scalar) { $(self.$field %= scalar);+ }
[INFO] [stdout]     |                                                  ^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 291 | impl_vector!(Vector4 { x, y, z, w }, 4, vec4);
[INFO] [stdout]     | --------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_vector` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/vector.rs:232:83
[INFO] [stdout]     |
[INFO] [stdout] 232 |             #[inline] fn add_assign_element_wise(&mut self, rhs: $VectorN<S>) { $(self.$field += rhs.$field);+ }
[INFO] [stdout]     |                                                                                   ^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 291 | impl_vector!(Vector4 { x, y, z, w }, 4, vec4);
[INFO] [stdout]     | --------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_vector` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/vector.rs:233:83
[INFO] [stdout]     |
[INFO] [stdout] 233 |             #[inline] fn sub_assign_element_wise(&mut self, rhs: $VectorN<S>) { $(self.$field -= rhs.$field);+ }
[INFO] [stdout]     |                                                                                   ^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 291 | impl_vector!(Vector4 { x, y, z, w }, 4, vec4);
[INFO] [stdout]     | --------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_vector` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/vector.rs:234:83
[INFO] [stdout]     |
[INFO] [stdout] 234 |             #[inline] fn mul_assign_element_wise(&mut self, rhs: $VectorN<S>) { $(self.$field *= rhs.$field);+ }
[INFO] [stdout]     |                                                                                   ^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 291 | impl_vector!(Vector4 { x, y, z, w }, 4, vec4);
[INFO] [stdout]     | --------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_vector` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/vector.rs:235:83
[INFO] [stdout]     |
[INFO] [stdout] 235 |             #[inline] fn div_assign_element_wise(&mut self, rhs: $VectorN<S>) { $(self.$field /= rhs.$field);+ }
[INFO] [stdout]     |                                                                                   ^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 291 | impl_vector!(Vector4 { x, y, z, w }, 4, vec4);
[INFO] [stdout]     | --------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_vector` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/vector.rs:236:83
[INFO] [stdout]     |
[INFO] [stdout] 236 |             #[inline] fn rem_assign_element_wise(&mut self, rhs: $VectorN<S>) { $(self.$field %= rhs.$field);+ }
[INFO] [stdout]     |                                                                                   ^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 291 | impl_vector!(Vector4 { x, y, z, w }, 4, vec4);
[INFO] [stdout]     | --------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_vector` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/vector.rs:246:73
[INFO] [stdout]     |
[INFO] [stdout] 246 |             #[inline] fn add_assign_element_wise(&mut self, rhs: S) { $(self.$field += rhs);+ }
[INFO] [stdout]     |                                                                         ^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 291 | impl_vector!(Vector4 { x, y, z, w }, 4, vec4);
[INFO] [stdout]     | --------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_vector` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/vector.rs:247:73
[INFO] [stdout]     |
[INFO] [stdout] 247 |             #[inline] fn sub_assign_element_wise(&mut self, rhs: S) { $(self.$field -= rhs);+ }
[INFO] [stdout]     |                                                                         ^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 291 | impl_vector!(Vector4 { x, y, z, w }, 4, vec4);
[INFO] [stdout]     | --------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_vector` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/vector.rs:248:73
[INFO] [stdout]     |
[INFO] [stdout] 248 |             #[inline] fn mul_assign_element_wise(&mut self, rhs: S) { $(self.$field *= rhs);+ }
[INFO] [stdout]     |                                                                         ^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 291 | impl_vector!(Vector4 { x, y, z, w }, 4, vec4);
[INFO] [stdout]     | --------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_vector` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/vector.rs:249:73
[INFO] [stdout]     |
[INFO] [stdout] 249 |             #[inline] fn div_assign_element_wise(&mut self, rhs: S) { $(self.$field /= rhs);+ }
[INFO] [stdout]     |                                                                         ^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 291 | impl_vector!(Vector4 { x, y, z, w }, 4, vec4);
[INFO] [stdout]     | --------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_vector` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/vector.rs:250:73
[INFO] [stdout]     |
[INFO] [stdout] 250 |             #[inline] fn rem_assign_element_wise(&mut self, rhs: S) { $(self.$field %= rhs);+ }
[INFO] [stdout]     |                                                                         ^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 291 | impl_vector!(Vector4 { x, y, z, w }, 4, vec4);
[INFO] [stdout]     | --------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_vector` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/angle.rs:132:47
[INFO] [stdout]     |
[INFO] [stdout] 132 |             fn add_assign(&mut self, other) { self.s += other.s; }
[INFO] [stdout]     |                                               ^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 178 | impl_angle!(Rad, "{:?} rad", f64::consts::PI * 2.0, f64::consts::PI);
[INFO] [stdout]     | -------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_angle` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/angle.rs:135:47
[INFO] [stdout]     |
[INFO] [stdout] 135 |             fn sub_assign(&mut self, other) { self.s -= other.s; }
[INFO] [stdout]     |                                               ^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 178 | impl_angle!(Rad, "{:?} rad", f64::consts::PI * 2.0, f64::consts::PI);
[INFO] [stdout]     | -------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_angle` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/angle.rs:138:47
[INFO] [stdout]     |
[INFO] [stdout] 138 |             fn rem_assign(&mut self, other) { self.s %= other.s; }
[INFO] [stdout]     |                                               ^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 178 | impl_angle!(Rad, "{:?} rad", f64::consts::PI * 2.0, f64::consts::PI);
[INFO] [stdout]     | -------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_angle` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/angle.rs:148:48
[INFO] [stdout]     |
[INFO] [stdout] 148 |             fn mul_assign(&mut self, scalar) { self.s *= scalar; }
[INFO] [stdout]     |                                                ^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 178 | impl_angle!(Rad, "{:?} rad", f64::consts::PI * 2.0, f64::consts::PI);
[INFO] [stdout]     | -------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_angle` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/angle.rs:151:48
[INFO] [stdout]     |
[INFO] [stdout] 151 |             fn div_assign(&mut self, scalar) { self.s /= scalar; }
[INFO] [stdout]     |                                                ^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 178 | impl_angle!(Rad, "{:?} rad", f64::consts::PI * 2.0, f64::consts::PI);
[INFO] [stdout]     | -------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_angle` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/angle.rs:159:17
[INFO] [stdout]     |
[INFO] [stdout] 159 |                 self.s.approx_eq_eps(&other.s, epsilon)
[INFO] [stdout]     |                 ^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 178 | impl_angle!(Rad, "{:?} rad", f64::consts::PI * 2.0, f64::consts::PI);
[INFO] [stdout]     | -------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_angle` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/angle.rs:159:38
[INFO] [stdout]     |
[INFO] [stdout] 159 |                 self.s.approx_eq_eps(&other.s, epsilon)
[INFO] [stdout]     |                                      ^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 178 | impl_angle!(Rad, "{:?} rad", f64::consts::PI * 2.0, f64::consts::PI);
[INFO] [stdout]     | -------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_angle` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/angle.rs:172:33
[INFO] [stdout]     |
[INFO] [stdout] 172 |                 write!(f, $fmt, self.s)
[INFO] [stdout]     |                                 ^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 178 | impl_angle!(Rad, "{:?} rad", f64::consts::PI * 2.0, f64::consts::PI);
[INFO] [stdout]     | -------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `$crate::format_args` which comes from the expansion of the macro `impl_angle` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/angle.rs:132:47
[INFO] [stdout]     |
[INFO] [stdout] 132 |             fn add_assign(&mut self, other) { self.s += other.s; }
[INFO] [stdout]     |                                               ^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 179 | impl_angle!(Deg, "{:?}°", 360, 180);
[INFO] [stdout]     | ----------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_angle` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/angle.rs:135:47
[INFO] [stdout]     |
[INFO] [stdout] 135 |             fn sub_assign(&mut self, other) { self.s -= other.s; }
[INFO] [stdout]     |                                               ^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 179 | impl_angle!(Deg, "{:?}°", 360, 180);
[INFO] [stdout]     | ----------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_angle` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/angle.rs:138:47
[INFO] [stdout]     |
[INFO] [stdout] 138 |             fn rem_assign(&mut self, other) { self.s %= other.s; }
[INFO] [stdout]     |                                               ^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 179 | impl_angle!(Deg, "{:?}°", 360, 180);
[INFO] [stdout]     | ----------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_angle` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/angle.rs:148:48
[INFO] [stdout]     |
[INFO] [stdout] 148 |             fn mul_assign(&mut self, scalar) { self.s *= scalar; }
[INFO] [stdout]     |                                                ^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 179 | impl_angle!(Deg, "{:?}°", 360, 180);
[INFO] [stdout]     | ----------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_angle` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/angle.rs:151:48
[INFO] [stdout]     |
[INFO] [stdout] 151 |             fn div_assign(&mut self, scalar) { self.s /= scalar; }
[INFO] [stdout]     |                                                ^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 179 | impl_angle!(Deg, "{:?}°", 360, 180);
[INFO] [stdout]     | ----------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_angle` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/angle.rs:159:17
[INFO] [stdout]     |
[INFO] [stdout] 159 |                 self.s.approx_eq_eps(&other.s, epsilon)
[INFO] [stdout]     |                 ^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 179 | impl_angle!(Deg, "{:?}°", 360, 180);
[INFO] [stdout]     | ----------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_angle` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/angle.rs:159:38
[INFO] [stdout]     |
[INFO] [stdout] 159 |                 self.s.approx_eq_eps(&other.s, epsilon)
[INFO] [stdout]     |                                      ^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 179 | impl_angle!(Deg, "{:?}°", 360, 180);
[INFO] [stdout]     | ----------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_angle` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/angle.rs:172:33
[INFO] [stdout]     |
[INFO] [stdout] 172 |                 write!(f, $fmt, self.s)
[INFO] [stdout]     |                                 ^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 179 | impl_angle!(Deg, "{:?}°", 360, 180);
[INFO] [stdout]     | ----------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `$crate::format_args` which comes from the expansion of the macro `impl_angle` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/euler.rs:149:9
[INFO] [stdout]     |
[INFO] [stdout] 149 |         self.x.approx_eq_eps(&other.x, epsilon) &&
[INFO] [stdout]     |         ^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/euler.rs:149:30
[INFO] [stdout]     |
[INFO] [stdout] 149 |         self.x.approx_eq_eps(&other.x, epsilon) &&
[INFO] [stdout]     |                              ^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/euler.rs:150:9
[INFO] [stdout]     |
[INFO] [stdout] 150 |         self.y.approx_eq_eps(&other.y, epsilon) &&
[INFO] [stdout]     |         ^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/euler.rs:150:30
[INFO] [stdout]     |
[INFO] [stdout] 150 |         self.y.approx_eq_eps(&other.y, epsilon) &&
[INFO] [stdout]     |                              ^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/euler.rs:151:9
[INFO] [stdout]     |
[INFO] [stdout] 151 |         self.z.approx_eq_eps(&other.z, epsilon)
[INFO] [stdout]     |         ^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/euler.rs:151:30
[INFO] [stdout]     |
[INFO] [stdout] 151 |         self.z.approx_eq_eps(&other.z, epsilon)
[INFO] [stdout]     |                              ^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/point.rs:170:19
[INFO] [stdout]     |
[INFO] [stdout] 170 |                 $(self.$field.approx_eq_eps(&other.$field, epsilon))&&+
[INFO] [stdout]     |                   ^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 239 | impl_point!(Point1 { x }, Vector1, 1);
[INFO] [stdout]     | ------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_point` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/point.rs:170:45
[INFO] [stdout]     |
[INFO] [stdout] 170 |                 $(self.$field.approx_eq_eps(&other.$field, epsilon))&&+
[INFO] [stdout]     |                                             ^^^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 239 | impl_point!(Point1 { x }, Vector1, 1);
[INFO] [stdout]     | ------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_point` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/point.rs:178:50
[INFO] [stdout]     |
[INFO] [stdout] 178 |             fn add_assign(&mut self, vector) { $(self.$field += vector.$field);+ }
[INFO] [stdout]     |                                                  ^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 239 | impl_point!(Point1 { x }, Vector1, 1);
[INFO] [stdout]     | ------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_point` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/point.rs:195:50
[INFO] [stdout]     |
[INFO] [stdout] 195 |             fn mul_assign(&mut self, scalar) { $(self.$field *= scalar);+ }
[INFO] [stdout]     |                                                  ^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 239 | impl_point!(Point1 { x }, Vector1, 1);
[INFO] [stdout]     | ------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_point` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/point.rs:198:50
[INFO] [stdout]     |
[INFO] [stdout] 198 |             fn div_assign(&mut self, scalar) { $(self.$field /= scalar);+ }
[INFO] [stdout]     |                                                  ^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 239 | impl_point!(Point1 { x }, Vector1, 1);
[INFO] [stdout]     | ------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_point` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/point.rs:201:50
[INFO] [stdout]     |
[INFO] [stdout] 201 |             fn rem_assign(&mut self, scalar) { $(self.$field %= scalar);+ }
[INFO] [stdout]     |                                                  ^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 239 | impl_point!(Point1 { x }, Vector1, 1);
[INFO] [stdout]     | ------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_point` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/point.rs:170:19
[INFO] [stdout]     |
[INFO] [stdout] 170 |                 $(self.$field.approx_eq_eps(&other.$field, epsilon))&&+
[INFO] [stdout]     |                   ^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 240 | impl_point!(Point2 { x, y }, Vector2, 2);
[INFO] [stdout]     | ---------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_point` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/point.rs:170:45
[INFO] [stdout]     |
[INFO] [stdout] 170 |                 $(self.$field.approx_eq_eps(&other.$field, epsilon))&&+
[INFO] [stdout]     |                                             ^^^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 240 | impl_point!(Point2 { x, y }, Vector2, 2);
[INFO] [stdout]     | ---------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_point` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/point.rs:178:50
[INFO] [stdout]     |
[INFO] [stdout] 178 |             fn add_assign(&mut self, vector) { $(self.$field += vector.$field);+ }
[INFO] [stdout]     |                                                  ^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 240 | impl_point!(Point2 { x, y }, Vector2, 2);
[INFO] [stdout]     | ---------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_point` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/point.rs:195:50
[INFO] [stdout]     |
[INFO] [stdout] 195 |             fn mul_assign(&mut self, scalar) { $(self.$field *= scalar);+ }
[INFO] [stdout]     |                                                  ^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 240 | impl_point!(Point2 { x, y }, Vector2, 2);
[INFO] [stdout]     | ---------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_point` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/point.rs:198:50
[INFO] [stdout]     |
[INFO] [stdout] 198 |             fn div_assign(&mut self, scalar) { $(self.$field /= scalar);+ }
[INFO] [stdout]     |                                                  ^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 240 | impl_point!(Point2 { x, y }, Vector2, 2);
[INFO] [stdout]     | ---------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_point` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/point.rs:201:50
[INFO] [stdout]     |
[INFO] [stdout] 201 |             fn rem_assign(&mut self, scalar) { $(self.$field %= scalar);+ }
[INFO] [stdout]     |                                                  ^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 240 | impl_point!(Point2 { x, y }, Vector2, 2);
[INFO] [stdout]     | ---------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_point` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/point.rs:170:19
[INFO] [stdout]     |
[INFO] [stdout] 170 |                 $(self.$field.approx_eq_eps(&other.$field, epsilon))&&+
[INFO] [stdout]     |                   ^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 241 | impl_point!(Point3 { x, y, z }, Vector3, 3);
[INFO] [stdout]     | ------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_point` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/point.rs:170:45
[INFO] [stdout]     |
[INFO] [stdout] 170 |                 $(self.$field.approx_eq_eps(&other.$field, epsilon))&&+
[INFO] [stdout]     |                                             ^^^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 241 | impl_point!(Point3 { x, y, z }, Vector3, 3);
[INFO] [stdout]     | ------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_point` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/point.rs:178:50
[INFO] [stdout]     |
[INFO] [stdout] 178 |             fn add_assign(&mut self, vector) { $(self.$field += vector.$field);+ }
[INFO] [stdout]     |                                                  ^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 241 | impl_point!(Point3 { x, y, z }, Vector3, 3);
[INFO] [stdout]     | ------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_point` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/point.rs:195:50
[INFO] [stdout]     |
[INFO] [stdout] 195 |             fn mul_assign(&mut self, scalar) { $(self.$field *= scalar);+ }
[INFO] [stdout]     |                                                  ^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 241 | impl_point!(Point3 { x, y, z }, Vector3, 3);
[INFO] [stdout]     | ------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_point` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/point.rs:198:50
[INFO] [stdout]     |
[INFO] [stdout] 198 |             fn div_assign(&mut self, scalar) { $(self.$field /= scalar);+ }
[INFO] [stdout]     |                                                  ^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 241 | impl_point!(Point3 { x, y, z }, Vector3, 3);
[INFO] [stdout]     | ------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_point` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error[E0793]: reference to packed field is unaligned
[INFO] [stdout]    --> /opt/rustwide/cargo-home/registry/src/index.crates.io-6f17d22bba15001f/cgmath-0.10.0/src/point.rs:201:50
[INFO] [stdout]     |
[INFO] [stdout] 201 |             fn rem_assign(&mut self, scalar) { $(self.$field %= scalar);+ }
[INFO] [stdout]     |                                                  ^^^^^^^^^^^
[INFO] [stdout] ...
[INFO] [stdout] 241 | impl_point!(Point3 { x, y, z }, Vector3, 3);
[INFO] [stdout]     | ------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses
[INFO] [stdout]     = note: creating a misaligned reference is undefined behavior (even if that reference is never dereferenced)
[INFO] [stdout]     = help: copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers)
[INFO] [stdout]     = note: this error originates in the macro `impl_point` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: aborting due to 173 previous errors
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] Some errors have detailed explanations: E0277, E0369, E0793.
[INFO] [stdout] 
[INFO] [stdout] For more information about an error, try `rustc --explain E0277`.
[INFO] [stdout] 
[INFO] [stderr] error: could not compile `cgmath` (lib) due to 174 previous errors; 40 warnings emitted
[INFO] running `Command { std: "docker" "inspect" "5a2e7092c08e5cd1fdd02b06f517fb99883977f9a50644f82357cda0af283e2f", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "rm" "-f" "5a2e7092c08e5cd1fdd02b06f517fb99883977f9a50644f82357cda0af283e2f", kill_on_drop: false }`
[INFO] [stdout] 5a2e7092c08e5cd1fdd02b06f517fb99883977f9a50644f82357cda0af283e2f
