[INFO] cloning repository https://github.com/GeoSpark/autel-odl
[INFO] running `Command { std: "git" "-c" "credential.helper=" "-c" "credential.helper=/workspace/cargo-home/bin/git-credential-null" "clone" "--bare" "https://github.com/GeoSpark/autel-odl" "/workspace/cache/git-repos/https%3A%2F%2Fgithub.com%2FGeoSpark%2Fautel-odl", kill_on_drop: false }`
[INFO] [stderr] Cloning into bare repository '/workspace/cache/git-repos/https%3A%2F%2Fgithub.com%2FGeoSpark%2Fautel-odl'...
[INFO] running `Command { std: "git" "rev-parse" "HEAD", kill_on_drop: false }`
[INFO] [stdout] bd0458136b6c3dbf4478a25a39612428628fc0e3
[INFO] checking GeoSpark/autel-odl against a5689b034ad287112f709693384a37f1377eb9cc for pr-129249-3
[INFO] running `Command { std: "git" "clone" "/workspace/cache/git-repos/https%3A%2F%2Fgithub.com%2FGeoSpark%2Fautel-odl" "/workspace/builds/worker-6-tc2/source", kill_on_drop: false }`
[INFO] [stderr] Cloning into '/workspace/builds/worker-6-tc2/source'...
[INFO] [stderr] done.
[INFO] started tweaking git repo https://github.com/GeoSpark/autel-odl
[INFO] finished tweaking git repo https://github.com/GeoSpark/autel-odl
[INFO] tweaked toml for git repo https://github.com/GeoSpark/autel-odl written to /workspace/builds/worker-6-tc2/source/Cargo.toml
[INFO] validating manifest of git repo https://github.com/GeoSpark/autel-odl on toolchain a5689b034ad287112f709693384a37f1377eb9cc
[INFO] running `Command { std: CARGO_HOME="/workspace/cargo-home" RUSTUP_HOME="/workspace/rustup-home" "/workspace/cargo-home/bin/cargo" "+a5689b034ad287112f709693384a37f1377eb9cc" "metadata" "--manifest-path" "Cargo.toml" "--no-deps", kill_on_drop: false }`
[INFO] crate git repo https://github.com/GeoSpark/autel-odl already has a lockfile, it will not be regenerated
[INFO] running `Command { std: CARGO_HOME="/workspace/cargo-home" RUSTUP_HOME="/workspace/rustup-home" "/workspace/cargo-home/bin/cargo" "+a5689b034ad287112f709693384a37f1377eb9cc" "fetch" "--manifest-path" "Cargo.toml", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "create" "-v" "/var/lib/crater-agent-workspace/builds/worker-6-tc2/source:/opt/rustwide/workdir:ro,Z" "-v" "/var/lib/crater-agent-workspace/builds/worker-6-tc2/target:/opt/rustwide/target:rw,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" "-m" "1610612736" "--network" "none" "ghcr.io/rust-lang/crates-build-env/linux@sha256:77db811e55d90add9212f6832c23229e3de5f1c1f9905e8cb07319ea15df73ac" "sleep" "infinity", kill_on_drop: false }`
[INFO] [stdout] 0c36cca878d669f3365b0bc692b1358861e57305350dd7b4eb314f496f42f4f2
[INFO] running `Command { std: "docker" "start" "0c36cca878d669f3365b0bc692b1358861e57305350dd7b4eb314f496f42f4f2", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "inspect" "0c36cca878d669f3365b0bc692b1358861e57305350dd7b4eb314f496f42f4f2", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "exec" "-e" "SOURCE_DIR=/opt/rustwide/workdir" "-e" "CARGO_HOME=/opt/rustwide/cargo-home" "-e" "RUSTUP_HOME=/opt/rustwide/rustup-home" "-e" "CARGO_TARGET_DIR=/opt/rustwide/target" "-w" "/opt/rustwide/workdir" "--user" "0:0" "0c36cca878d669f3365b0bc692b1358861e57305350dd7b4eb314f496f42f4f2" "/opt/rustwide/cargo-home/bin/cargo" "+a5689b034ad287112f709693384a37f1377eb9cc" "metadata" "--no-deps" "--format-version=1", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "inspect" "0c36cca878d669f3365b0bc692b1358861e57305350dd7b4eb314f496f42f4f2", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "exec" "-e" "SOURCE_DIR=/opt/rustwide/workdir" "-e" "CARGO_HOME=/opt/rustwide/cargo-home" "-e" "RUSTUP_HOME=/opt/rustwide/rustup-home" "-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" "-w" "/opt/rustwide/workdir" "--user" "0:0" "0c36cca878d669f3365b0bc692b1358861e57305350dd7b4eb314f496f42f4f2" "/opt/rustwide/cargo-home/bin/cargo" "+a5689b034ad287112f709693384a37f1377eb9cc" "check" "--frozen" "--all" "--all-targets" "--message-format=json", kill_on_drop: false }`
[INFO] [stderr]    Compiling proc-macro2 v1.0.106
[INFO] [stderr]    Compiling quote v1.0.45
[INFO] [stderr]    Compiling serde_core v1.0.228
[INFO] [stderr]    Compiling unicode-ident v1.0.24
[INFO] [stderr]    Compiling crc32fast v1.5.0
[INFO] [stderr]    Compiling autocfg v1.5.0
[INFO] [stderr]     Checking adler2 v2.0.1
[INFO] [stderr]    Compiling zmij v1.0.21
[INFO] [stderr]     Checking memchr v2.8.0
[INFO] [stderr]     Checking cfg-if v1.0.4
[INFO] [stderr]     Checking simd-adler32 v0.3.9
[INFO] [stderr]     Checking encoding-next-index-tradchinese v1.20180106.1
[INFO] [stderr]     Checking encoding-next-types v0.2.0
[INFO] [stderr]    Compiling serde v1.0.228
[INFO] [stderr]    Compiling serde_json v1.0.149
[INFO] [stderr]     Checking unicode-segmentation v1.13.2
[INFO] [stderr]     Checking itoa v1.0.18
[INFO] [stderr]     Checking encoding-next-index-japanese v1.20180106.0
[INFO] [stderr]     Checking encoding-next-index-korean v1.20180106.0
[INFO] [stderr]     Checking encoding-next-index-simpchinese v1.20180106.0
[INFO] [stderr]     Checking encoding-next-index-singlebyte v1.20180106.0
[INFO] [stderr]     Checking miniz_oxide v0.8.9
[INFO] [stderr]     Checking iana-time-zone v0.1.65
[INFO] [stderr]     Checking cp437 v0.1.1
[INFO] [stderr]     Checking ryu v1.0.23
[INFO] [stderr]     Checking convert_case v0.11.0
[INFO] [stderr]    Compiling num-traits v0.2.19
[INFO] [stderr]     Checking encoding-next v0.3.0
[INFO] [stderr]     Checking flate2 v1.1.9
[INFO] [stderr]     Checking csv-core v0.1.13
[INFO] [stderr]     Checking kaitai v0.11.0 (https://github.com/kaitai-io/kaitai_struct_rust_runtime.git?tag=v0.11.0#770aff09)
[INFO] [stderr]    Compiling syn v2.0.117
[INFO] [stderr]     Checking chrono v0.4.44
[INFO] [stderr]    Compiling serde_derive v1.0.228
[INFO] [stderr]     Checking csv v1.4.0
[INFO] [stderr]     Checking autel-odl v0.1.4 (/opt/rustwide/workdir)
[INFO] [stdout] error: useless conversion to the same type: `Vec<u8>`
[INFO] [stdout]   --> src/autel_drone_log.rs:55:39
[INFO] [stdout]    |
[INFO] [stdout] 55 |         *self_rc.magic.borrow_mut() = _io.read_bytes(8 as usize)?.into();
[INFO] [stdout]    |                                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]    = note: `#[deny(self_type_conversion)]` on by default
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 55 -         *self_rc.magic.borrow_mut() = _io.read_bytes(8 as usize)?.into();
[INFO] [stdout] 55 +         *self_rc.magic.borrow_mut() = _io.read_bytes(8 as usize)?;
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 55 -         *self_rc.magic.borrow_mut() = _io.read_bytes(8 as usize)?.into();
[INFO] [stdout] 55 +         *self_rc.magic.borrow_mut() = <Vec<u8> as Into<_>>::into(_io.read_bytes(8 as usize)?);
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]   --> src/autel_drone_log.rs:59:45
[INFO] [stdout]    |
[INFO] [stdout] 59 |         *self_rc.log_version.borrow_mut() = _io.read_u4le()?.into();
[INFO] [stdout]    |                                             ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 59 -         *self_rc.log_version.borrow_mut() = _io.read_u4le()?.into();
[INFO] [stdout] 59 +         *self_rc.log_version.borrow_mut() = _io.read_u4le()?;
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 59 -         *self_rc.log_version.borrow_mut() = _io.read_u4le()?.into();
[INFO] [stdout] 59 +         *self_rc.log_version.borrow_mut() = <u32 as Into<_>>::into(_io.read_u4le()?);
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `kaitai::OptRc<AutelDroneLog_HeaderT>`
[INFO] [stdout]   --> src/autel_drone_log.rs:63:17
[INFO] [stdout]    |
[INFO] [stdout] 63 |         let t = Self::read_into::<_, AutelDroneLog_HeaderT>(&*_io, Some(self_rc._root.clone()), Some(self_rc._self.clone()))?.into();
[INFO] [stdout]    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 63 -         let t = Self::read_into::<_, AutelDroneLog_HeaderT>(&*_io, Some(self_rc._root.clone()), Some(self_rc._self.clone()))?.into();
[INFO] [stdout] 63 +         let t = Self::read_into::<_, AutelDroneLog_HeaderT>(&*_io, Some(self_rc._root.clone()), Some(self_rc._self.clone()))?;
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 63 -         let t = Self::read_into::<_, AutelDroneLog_HeaderT>(&*_io, Some(self_rc._root.clone()), Some(self_rc._self.clone()))?.into();
[INFO] [stdout] 63 +         let t = <kaitai::OptRc<AutelDroneLog_HeaderT> as Into<_>>::into(Self::read_into::<_, AutelDroneLog_HeaderT>(&*_io, Some(self_rc._root.clone()), Some(self_rc._self.clone()))?);
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `kaitai::OptRc<AutelDroneLog_RecordT>`
[INFO] [stdout]   --> src/autel_drone_log.rs:69:25
[INFO] [stdout]    |
[INFO] [stdout] 69 | ...t t = Self::read_into::<_, AutelDroneLog_RecordT>(&*_io, Some(self_rc._root.clone()), Some(self_rc._self.clone()))?.into();
[INFO] [stdout]    |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 69 -                 let t = Self::read_into::<_, AutelDroneLog_RecordT>(&*_io, Some(self_rc._root.clone()), Some(self_rc._self.clone()))?.into();
[INFO] [stdout] 69 +                 let t = Self::read_into::<_, AutelDroneLog_RecordT>(&*_io, Some(self_rc._root.clone()), Some(self_rc._self.clone()))?;
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 69 -                 let t = Self::read_into::<_, AutelDroneLog_RecordT>(&*_io, Some(self_rc._root.clone()), Some(self_rc._self.clone()))?.into();
[INFO] [stdout] 69 +                 let t = <kaitai::OptRc<AutelDroneLog_RecordT> as Into<_>>::into(Self::read_into::<_, AutelDroneLog_RecordT>(&*_io, Some(self_rc._root.clone()), Some(self_rc._self.clone()))?);
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]    --> src/autel_drone_log.rs:342:49
[INFO] [stdout]     |
[INFO] [stdout] 342 |         *self_rc.mission_time_ms.borrow_mut() = _io.read_u4le()?.into();
[INFO] [stdout]     |                                                 ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 342 -         *self_rc.mission_time_ms.borrow_mut() = _io.read_u4le()?.into();
[INFO] [stdout] 342 +         *self_rc.mission_time_ms.borrow_mut() = _io.read_u4le()?;
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 342 -         *self_rc.mission_time_ms.borrow_mut() = _io.read_u4le()?.into();
[INFO] [stdout] 342 +         *self_rc.mission_time_ms.borrow_mut() = <u32 as Into<_>>::into(_io.read_u4le()?);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `kaitai::OptRc<AutelDroneLog_DroneAttitudeT>`
[INFO] [stdout]    --> src/autel_drone_log.rs:343:17
[INFO] [stdout]     |
[INFO] [stdout] 343 |         let t = Self::read_into::<_, AutelDroneLog_DroneAttitudeT>(&*_io, Some(self_rc._root.clone()), None)?.into();
[INFO] [stdout]     |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 343 -         let t = Self::read_into::<_, AutelDroneLog_DroneAttitudeT>(&*_io, Some(self_rc._root.clone()), None)?.into();
[INFO] [stdout] 343 +         let t = Self::read_into::<_, AutelDroneLog_DroneAttitudeT>(&*_io, Some(self_rc._root.clone()), None)?;
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 343 -         let t = Self::read_into::<_, AutelDroneLog_DroneAttitudeT>(&*_io, Some(self_rc._root.clone()), None)?.into();
[INFO] [stdout] 343 +         let t = <kaitai::OptRc<AutelDroneLog_DroneAttitudeT> as Into<_>>::into(Self::read_into::<_, AutelDroneLog_DroneAttitudeT>(&*_io, Some(self_rc._root.clone()), None)?);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `kaitai::OptRc<AutelDroneLog_ControllerT>`
[INFO] [stdout]    --> src/autel_drone_log.rs:345:17
[INFO] [stdout]     |
[INFO] [stdout] 345 |         let t = Self::read_into::<_, AutelDroneLog_ControllerT>(&*_io, Some(self_rc._root.clone()), None)?.into();
[INFO] [stdout]     |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 345 -         let t = Self::read_into::<_, AutelDroneLog_ControllerT>(&*_io, Some(self_rc._root.clone()), None)?.into();
[INFO] [stdout] 345 +         let t = Self::read_into::<_, AutelDroneLog_ControllerT>(&*_io, Some(self_rc._root.clone()), None)?;
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 345 -         let t = Self::read_into::<_, AutelDroneLog_ControllerT>(&*_io, Some(self_rc._root.clone()), None)?.into();
[INFO] [stdout] 345 +         let t = <kaitai::OptRc<AutelDroneLog_ControllerT> as Into<_>>::into(Self::read_into::<_, AutelDroneLog_ControllerT>(&*_io, Some(self_rc._root.clone()), None)?);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/autel_drone_log.rs:347:41
[INFO] [stdout]     |
[INFO] [stdout] 347 |         *self_rc.rc_mode.borrow_mut() = _io.read_u1()?.into();
[INFO] [stdout]     |                                         ^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 347 -         *self_rc.rc_mode.borrow_mut() = _io.read_u1()?.into();
[INFO] [stdout] 347 +         *self_rc.rc_mode.borrow_mut() = _io.read_u1()?;
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 347 -         *self_rc.rc_mode.borrow_mut() = _io.read_u1()?.into();
[INFO] [stdout] 347 +         *self_rc.rc_mode.borrow_mut() = <u8 as Into<_>>::into(_io.read_u1()?);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]    --> src/autel_drone_log.rs:348:50
[INFO] [stdout]     |
[INFO] [stdout] 348 |         *self_rc.offline_duration.borrow_mut() = _io.read_u4le()?.into();
[INFO] [stdout]     |                                                  ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 348 -         *self_rc.offline_duration.borrow_mut() = _io.read_u4le()?.into();
[INFO] [stdout] 348 +         *self_rc.offline_duration.borrow_mut() = _io.read_u4le()?;
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 348 -         *self_rc.offline_duration.borrow_mut() = _io.read_u4le()?.into();
[INFO] [stdout] 348 +         *self_rc.offline_duration.borrow_mut() = <u32 as Into<_>>::into(_io.read_u4le()?);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/autel_drone_log.rs:349:44
[INFO] [stdout]     |
[INFO] [stdout] 349 |         *self_rc.rc_buttons.borrow_mut() = _io.read_u1()?.into();
[INFO] [stdout]     |                                            ^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 349 -         *self_rc.rc_buttons.borrow_mut() = _io.read_u1()?.into();
[INFO] [stdout] 349 +         *self_rc.rc_buttons.borrow_mut() = _io.read_u1()?;
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 349 -         *self_rc.rc_buttons.borrow_mut() = _io.read_u1()?.into();
[INFO] [stdout] 349 +         *self_rc.rc_buttons.borrow_mut() = <u8 as Into<_>>::into(_io.read_u1()?);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `f64`
[INFO] [stdout]    --> src/autel_drone_log.rs:350:52
[INFO] [stdout]     |
[INFO] [stdout] 350 |         *self_rc.controller_heading.borrow_mut() = _io.read_f8le()?.into();
[INFO] [stdout]     |                                                    ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 350 -         *self_rc.controller_heading.borrow_mut() = _io.read_f8le()?.into();
[INFO] [stdout] 350 +         *self_rc.controller_heading.borrow_mut() = _io.read_f8le()?;
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 350 -         *self_rc.controller_heading.borrow_mut() = _io.read_f8le()?.into();
[INFO] [stdout] 350 +         *self_rc.controller_heading.borrow_mut() = <f64 as Into<_>>::into(_io.read_f8le()?);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `kaitai::OptRc<AutelDroneLog_OaSensorT>`
[INFO] [stdout]    --> src/autel_drone_log.rs:351:17
[INFO] [stdout]     |
[INFO] [stdout] 351 |         let t = Self::read_into::<_, AutelDroneLog_OaSensorT>(&*_io, Some(self_rc._root.clone()), None)?.into();
[INFO] [stdout]     |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 351 -         let t = Self::read_into::<_, AutelDroneLog_OaSensorT>(&*_io, Some(self_rc._root.clone()), None)?.into();
[INFO] [stdout] 351 +         let t = Self::read_into::<_, AutelDroneLog_OaSensorT>(&*_io, Some(self_rc._root.clone()), None)?;
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 351 -         let t = Self::read_into::<_, AutelDroneLog_OaSensorT>(&*_io, Some(self_rc._root.clone()), None)?.into();
[INFO] [stdout] 351 +         let t = <kaitai::OptRc<AutelDroneLog_OaSensorT> as Into<_>>::into(Self::read_into::<_, AutelDroneLog_OaSensorT>(&*_io, Some(self_rc._root.clone()), None)?);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]    --> src/autel_drone_log.rs:353:40
[INFO] [stdout]     |
[INFO] [stdout] 353 |         *self_rc.param1.borrow_mut() = _io.read_u4le()?.into();
[INFO] [stdout]     |                                        ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 353 -         *self_rc.param1.borrow_mut() = _io.read_u4le()?.into();
[INFO] [stdout] 353 +         *self_rc.param1.borrow_mut() = _io.read_u4le()?;
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 353 -         *self_rc.param1.borrow_mut() = _io.read_u4le()?.into();
[INFO] [stdout] 353 +         *self_rc.param1.borrow_mut() = <u32 as Into<_>>::into(_io.read_u4le()?);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]    --> src/autel_drone_log.rs:354:40
[INFO] [stdout]     |
[INFO] [stdout] 354 |         *self_rc.param2.borrow_mut() = _io.read_u4le()?.into();
[INFO] [stdout]     |                                        ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 354 -         *self_rc.param2.borrow_mut() = _io.read_u4le()?.into();
[INFO] [stdout] 354 +         *self_rc.param2.borrow_mut() = _io.read_u4le()?;
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 354 -         *self_rc.param2.borrow_mut() = _io.read_u4le()?.into();
[INFO] [stdout] 354 +         *self_rc.param2.borrow_mut() = <u32 as Into<_>>::into(_io.read_u4le()?);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/autel_drone_log.rs:480:45
[INFO] [stdout]     |
[INFO] [stdout] 480 |         *self_rc.camera_mode.borrow_mut() = _io.read_u1()?.into();
[INFO] [stdout]     |                                             ^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 480 -         *self_rc.camera_mode.borrow_mut() = _io.read_u1()?.into();
[INFO] [stdout] 480 +         *self_rc.camera_mode.borrow_mut() = _io.read_u1()?;
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 480 -         *self_rc.camera_mode.borrow_mut() = _io.read_u1()?.into();
[INFO] [stdout] 480 +         *self_rc.camera_mode.borrow_mut() = <u8 as Into<_>>::into(_io.read_u1()?);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/autel_drone_log.rs:481:43
[INFO] [stdout]     |
[INFO] [stdout] 481 |         *self_rc.gnss_rssi.borrow_mut() = _io.read_u1()?.into();
[INFO] [stdout]     |                                           ^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 481 -         *self_rc.gnss_rssi.borrow_mut() = _io.read_u1()?.into();
[INFO] [stdout] 481 +         *self_rc.gnss_rssi.borrow_mut() = _io.read_u1()?;
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 481 -         *self_rc.gnss_rssi.borrow_mut() = _io.read_u1()?.into();
[INFO] [stdout] 481 +         *self_rc.gnss_rssi.borrow_mut() = <u8 as Into<_>>::into(_io.read_u1()?);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/autel_drone_log.rs:482:49
[INFO] [stdout]     |
[INFO] [stdout] 482 |         *self_rc.controller_rssi.borrow_mut() = _io.read_u1()?.into();
[INFO] [stdout]     |                                                 ^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 482 -         *self_rc.controller_rssi.borrow_mut() = _io.read_u1()?.into();
[INFO] [stdout] 482 +         *self_rc.controller_rssi.borrow_mut() = _io.read_u1()?;
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 482 -         *self_rc.controller_rssi.borrow_mut() = _io.read_u1()?.into();
[INFO] [stdout] 482 +         *self_rc.controller_rssi.borrow_mut() = <u8 as Into<_>>::into(_io.read_u1()?);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/autel_drone_log.rs:483:44
[INFO] [stdout]     |
[INFO] [stdout] 483 |         *self_rc.stick_mode.borrow_mut() = _io.read_u1()?.into();
[INFO] [stdout]     |                                            ^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 483 -         *self_rc.stick_mode.borrow_mut() = _io.read_u1()?.into();
[INFO] [stdout] 483 +         *self_rc.stick_mode.borrow_mut() = _io.read_u1()?;
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 483 -         *self_rc.stick_mode.borrow_mut() = _io.read_u1()?.into();
[INFO] [stdout] 483 +         *self_rc.stick_mode.borrow_mut() = <u8 as Into<_>>::into(_io.read_u1()?);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `kaitai::OptRc<AutelDroneLog_HomeInfoT>`
[INFO] [stdout]    --> src/autel_drone_log.rs:484:17
[INFO] [stdout]     |
[INFO] [stdout] 484 | ... t = Self::read_into::<_, AutelDroneLog_HomeInfoT>(&*_io, Some(self_rc._root.clone()), Some(self_rc._self.clone()))?.into();
[INFO] [stdout]     |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 484 -         let t = Self::read_into::<_, AutelDroneLog_HomeInfoT>(&*_io, Some(self_rc._root.clone()), Some(self_rc._self.clone()))?.into();
[INFO] [stdout] 484 +         let t = Self::read_into::<_, AutelDroneLog_HomeInfoT>(&*_io, Some(self_rc._root.clone()), Some(self_rc._self.clone()))?;
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 484 -         let t = Self::read_into::<_, AutelDroneLog_HomeInfoT>(&*_io, Some(self_rc._root.clone()), Some(self_rc._self.clone()))?.into();
[INFO] [stdout] 484 +         let t = <kaitai::OptRc<AutelDroneLog_HomeInfoT> as Into<_>>::into(Self::read_into::<_, AutelDroneLog_HomeInfoT>(&*_io, Some(self_rc._root.clone()), Some(self_rc._self.clone()))?);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `f32`
[INFO] [stdout]    --> src/autel_drone_log.rs:486:48
[INFO] [stdout]     |
[INFO] [stdout] 486 |         *self_rc.distance_flown.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout]     |                                                ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 486 -         *self_rc.distance_flown.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout] 486 +         *self_rc.distance_flown.borrow_mut() = _io.read_f4le()?;
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 486 -         *self_rc.distance_flown.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout] 486 +         *self_rc.distance_flown.borrow_mut() = <f32 as Into<_>>::into(_io.read_f4le()?);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]    --> src/autel_drone_log.rs:487:53
[INFO] [stdout]     |
[INFO] [stdout] 487 |         *self_rc.drone_warning_flags.borrow_mut() = _io.read_u4le()?.into();
[INFO] [stdout]     |                                                     ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 487 -         *self_rc.drone_warning_flags.borrow_mut() = _io.read_u4le()?.into();
[INFO] [stdout] 487 +         *self_rc.drone_warning_flags.borrow_mut() = _io.read_u4le()?;
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 487 -         *self_rc.drone_warning_flags.borrow_mut() = _io.read_u4le()?.into();
[INFO] [stdout] 487 +         *self_rc.drone_warning_flags.borrow_mut() = <u32 as Into<_>>::into(_io.read_u4le()?);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]    --> src/autel_drone_log.rs:488:57
[INFO] [stdout]     |
[INFO] [stdout] 488 |         *self_rc.drone_ext_warning_flags.borrow_mut() = _io.read_u4le()?.into();
[INFO] [stdout]     |                                                         ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 488 -         *self_rc.drone_ext_warning_flags.borrow_mut() = _io.read_u4le()?.into();
[INFO] [stdout] 488 +         *self_rc.drone_ext_warning_flags.borrow_mut() = _io.read_u4le()?;
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 488 -         *self_rc.drone_ext_warning_flags.borrow_mut() = _io.read_u4le()?.into();
[INFO] [stdout] 488 +         *self_rc.drone_ext_warning_flags.borrow_mut() = <u32 as Into<_>>::into(_io.read_u4le()?);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]    --> src/autel_drone_log.rs:489:54
[INFO] [stdout]     |
[INFO] [stdout] 489 |         *self_rc.gimbal_warning_flags.borrow_mut() = _io.read_u4le()?.into();
[INFO] [stdout]     |                                                      ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 489 -         *self_rc.gimbal_warning_flags.borrow_mut() = _io.read_u4le()?.into();
[INFO] [stdout] 489 +         *self_rc.gimbal_warning_flags.borrow_mut() = _io.read_u4le()?;
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 489 -         *self_rc.gimbal_warning_flags.borrow_mut() = _io.read_u4le()?.into();
[INFO] [stdout] 489 +         *self_rc.gimbal_warning_flags.borrow_mut() = <u32 as Into<_>>::into(_io.read_u4le()?);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]    --> src/autel_drone_log.rs:490:48
[INFO] [stdout]     |
[INFO] [stdout] 490 |         *self_rc.time_remaining.borrow_mut() = _io.read_u4le()?.into();
[INFO] [stdout]     |                                                ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 490 -         *self_rc.time_remaining.borrow_mut() = _io.read_u4le()?.into();
[INFO] [stdout] 490 +         *self_rc.time_remaining.borrow_mut() = _io.read_u4le()?;
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 490 -         *self_rc.time_remaining.borrow_mut() = _io.read_u4le()?.into();
[INFO] [stdout] 490 +         *self_rc.time_remaining.borrow_mut() = <u32 as Into<_>>::into(_io.read_u4le()?);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]    --> src/autel_drone_log.rs:491:43
[INFO] [stdout]     |
[INFO] [stdout] 491 |         *self_rc.back_time.borrow_mut() = _io.read_u4le()?.into();
[INFO] [stdout]     |                                           ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 491 -         *self_rc.back_time.borrow_mut() = _io.read_u4le()?.into();
[INFO] [stdout] 491 +         *self_rc.back_time.borrow_mut() = _io.read_u4le()?;
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 491 -         *self_rc.back_time.borrow_mut() = _io.read_u4le()?.into();
[INFO] [stdout] 491 +         *self_rc.back_time.borrow_mut() = <u32 as Into<_>>::into(_io.read_u4le()?);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/autel_drone_log.rs:492:49
[INFO] [stdout]     |
[INFO] [stdout] 492 |         *self_rc.satellite_count.borrow_mut() = _io.read_u1()?.into();
[INFO] [stdout]     |                                                 ^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 492 -         *self_rc.satellite_count.borrow_mut() = _io.read_u1()?.into();
[INFO] [stdout] 492 +         *self_rc.satellite_count.borrow_mut() = _io.read_u1()?;
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 492 -         *self_rc.satellite_count.borrow_mut() = _io.read_u1()?.into();
[INFO] [stdout] 492 +         *self_rc.satellite_count.borrow_mut() = <u8 as Into<_>>::into(_io.read_u1()?);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `kaitai::OptRc<AutelDroneLog_PowerInfoT>`
[INFO] [stdout]    --> src/autel_drone_log.rs:493:17
[INFO] [stdout]     |
[INFO] [stdout] 493 | ...t = Self::read_into::<_, AutelDroneLog_PowerInfoT>(&*_io, Some(self_rc._root.clone()), Some(self_rc._self.clone()))?.into();
[INFO] [stdout]     |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 493 -         let t = Self::read_into::<_, AutelDroneLog_PowerInfoT>(&*_io, Some(self_rc._root.clone()), Some(self_rc._self.clone()))?.into();
[INFO] [stdout] 493 +         let t = Self::read_into::<_, AutelDroneLog_PowerInfoT>(&*_io, Some(self_rc._root.clone()), Some(self_rc._self.clone()))?;
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 493 -         let t = Self::read_into::<_, AutelDroneLog_PowerInfoT>(&*_io, Some(self_rc._root.clone()), Some(self_rc._self.clone()))?.into();
[INFO] [stdout] 493 +         let t = <kaitai::OptRc<AutelDroneLog_PowerInfoT> as Into<_>>::into(Self::read_into::<_, AutelDroneLog_PowerInfoT>(&*_io, Some(self_rc._root.clone()), Some(self_rc._self.clone()))?);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `kaitai::OptRc<AutelDroneLog_SettingsT>`
[INFO] [stdout]    --> src/autel_drone_log.rs:495:17
[INFO] [stdout]     |
[INFO] [stdout] 495 | ... t = Self::read_into::<_, AutelDroneLog_SettingsT>(&*_io, Some(self_rc._root.clone()), Some(self_rc._self.clone()))?.into();
[INFO] [stdout]     |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 495 -         let t = Self::read_into::<_, AutelDroneLog_SettingsT>(&*_io, Some(self_rc._root.clone()), Some(self_rc._self.clone()))?.into();
[INFO] [stdout] 495 +         let t = Self::read_into::<_, AutelDroneLog_SettingsT>(&*_io, Some(self_rc._root.clone()), Some(self_rc._self.clone()))?;
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 495 -         let t = Self::read_into::<_, AutelDroneLog_SettingsT>(&*_io, Some(self_rc._root.clone()), Some(self_rc._self.clone()))?.into();
[INFO] [stdout] 495 +         let t = <kaitai::OptRc<AutelDroneLog_SettingsT> as Into<_>>::into(Self::read_into::<_, AutelDroneLog_SettingsT>(&*_io, Some(self_rc._root.clone()), Some(self_rc._self.clone()))?);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u16`
[INFO] [stdout]    --> src/autel_drone_log.rs:642:46
[INFO] [stdout]     |
[INFO] [stdout] 642 |         *self_rc.left_stick_x.borrow_mut() = _io.read_u2le()?.into();
[INFO] [stdout]     |                                              ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 642 -         *self_rc.left_stick_x.borrow_mut() = _io.read_u2le()?.into();
[INFO] [stdout] 642 +         *self_rc.left_stick_x.borrow_mut() = _io.read_u2le()?;
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 642 -         *self_rc.left_stick_x.borrow_mut() = _io.read_u2le()?.into();
[INFO] [stdout] 642 +         *self_rc.left_stick_x.borrow_mut() = <u16 as Into<_>>::into(_io.read_u2le()?);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u16`
[INFO] [stdout]    --> src/autel_drone_log.rs:643:46
[INFO] [stdout]     |
[INFO] [stdout] 643 |         *self_rc.left_stick_y.borrow_mut() = _io.read_u2le()?.into();
[INFO] [stdout]     |                                              ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 643 -         *self_rc.left_stick_y.borrow_mut() = _io.read_u2le()?.into();
[INFO] [stdout] 643 +         *self_rc.left_stick_y.borrow_mut() = _io.read_u2le()?;
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 643 -         *self_rc.left_stick_y.borrow_mut() = _io.read_u2le()?.into();
[INFO] [stdout] 643 +         *self_rc.left_stick_y.borrow_mut() = <u16 as Into<_>>::into(_io.read_u2le()?);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u16`
[INFO] [stdout]    --> src/autel_drone_log.rs:644:47
[INFO] [stdout]     |
[INFO] [stdout] 644 |         *self_rc.right_stick_x.borrow_mut() = _io.read_u2le()?.into();
[INFO] [stdout]     |                                               ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 644 -         *self_rc.right_stick_x.borrow_mut() = _io.read_u2le()?.into();
[INFO] [stdout] 644 +         *self_rc.right_stick_x.borrow_mut() = _io.read_u2le()?;
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 644 -         *self_rc.right_stick_x.borrow_mut() = _io.read_u2le()?.into();
[INFO] [stdout] 644 +         *self_rc.right_stick_x.borrow_mut() = <u16 as Into<_>>::into(_io.read_u2le()?);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u16`
[INFO] [stdout]    --> src/autel_drone_log.rs:645:47
[INFO] [stdout]     |
[INFO] [stdout] 645 |         *self_rc.right_stick_y.borrow_mut() = _io.read_u2le()?.into();
[INFO] [stdout]     |                                               ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 645 -         *self_rc.right_stick_y.borrow_mut() = _io.read_u2le()?.into();
[INFO] [stdout] 645 +         *self_rc.right_stick_y.borrow_mut() = _io.read_u2le()?;
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 645 -         *self_rc.right_stick_y.borrow_mut() = _io.read_u2le()?.into();
[INFO] [stdout] 645 +         *self_rc.right_stick_y.borrow_mut() = <u16 as Into<_>>::into(_io.read_u2le()?);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `f32`
[INFO] [stdout]    --> src/autel_drone_log.rs:718:48
[INFO] [stdout]     |
[INFO] [stdout] 718 |         *self_rc.drone_latitude.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout]     |                                                ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 718 -         *self_rc.drone_latitude.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout] 718 +         *self_rc.drone_latitude.borrow_mut() = _io.read_f4le()?;
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 718 -         *self_rc.drone_latitude.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout] 718 +         *self_rc.drone_latitude.borrow_mut() = <f32 as Into<_>>::into(_io.read_f4le()?);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `f32`
[INFO] [stdout]    --> src/autel_drone_log.rs:719:49
[INFO] [stdout]     |
[INFO] [stdout] 719 |         *self_rc.drone_longitude.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout]     |                                                 ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 719 -         *self_rc.drone_longitude.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout] 719 +         *self_rc.drone_longitude.borrow_mut() = _io.read_f4le()?;
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 719 -         *self_rc.drone_longitude.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout] 719 +         *self_rc.drone_longitude.borrow_mut() = <f32 as Into<_>>::into(_io.read_f4le()?);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `f32`
[INFO] [stdout]    --> src/autel_drone_log.rs:720:48
[INFO] [stdout]     |
[INFO] [stdout] 720 |         *self_rc.drone_altitude.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout]     |                                                ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 720 -         *self_rc.drone_altitude.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout] 720 +         *self_rc.drone_altitude.borrow_mut() = _io.read_f4le()?;
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 720 -         *self_rc.drone_altitude.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout] 720 +         *self_rc.drone_altitude.borrow_mut() = <f32 as Into<_>>::into(_io.read_f4le()?);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `f32`
[INFO] [stdout]    --> src/autel_drone_log.rs:721:47
[INFO] [stdout]     |
[INFO] [stdout] 721 |         *self_rc.drone_x_speed.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout]     |                                               ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 721 -         *self_rc.drone_x_speed.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout] 721 +         *self_rc.drone_x_speed.borrow_mut() = _io.read_f4le()?;
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 721 -         *self_rc.drone_x_speed.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout] 721 +         *self_rc.drone_x_speed.borrow_mut() = <f32 as Into<_>>::into(_io.read_f4le()?);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `f32`
[INFO] [stdout]    --> src/autel_drone_log.rs:722:47
[INFO] [stdout]     |
[INFO] [stdout] 722 |         *self_rc.drone_y_speed.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout]     |                                               ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 722 -         *self_rc.drone_y_speed.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout] 722 +         *self_rc.drone_y_speed.borrow_mut() = _io.read_f4le()?;
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 722 -         *self_rc.drone_y_speed.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout] 722 +         *self_rc.drone_y_speed.borrow_mut() = <f32 as Into<_>>::into(_io.read_f4le()?);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Vec<u8>`
[INFO] [stdout]   --> src/autel_drone_log.rs:55:39
[INFO] [stdout]    |
[INFO] [stdout] 55 |         *self_rc.magic.borrow_mut() = _io.read_bytes(8 as usize)?.into();
[INFO] [stdout]    |                                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]    = note: `#[deny(self_type_conversion)]` on by default
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 55 -         *self_rc.magic.borrow_mut() = _io.read_bytes(8 as usize)?.into();
[INFO] [stdout] 55 +         *self_rc.magic.borrow_mut() = _io.read_bytes(8 as usize)?;
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 55 -         *self_rc.magic.borrow_mut() = _io.read_bytes(8 as usize)?.into();
[INFO] [stdout] 55 +         *self_rc.magic.borrow_mut() = <Vec<u8> as Into<_>>::into(_io.read_bytes(8 as usize)?);
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `f32`
[INFO] [stdout]    --> src/autel_drone_log.rs:723:47
[INFO] [stdout]     |
[INFO] [stdout] 723 |         *self_rc.drone_z_speed.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout]     |                                               ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 723 -         *self_rc.drone_z_speed.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout] 723 +         *self_rc.drone_z_speed.borrow_mut() = _io.read_f4le()?;
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 723 -         *self_rc.drone_z_speed.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout] 723 +         *self_rc.drone_z_speed.borrow_mut() = <f32 as Into<_>>::into(_io.read_f4le()?);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]   --> src/autel_drone_log.rs:59:45
[INFO] [stdout]    |
[INFO] [stdout] 59 |         *self_rc.log_version.borrow_mut() = _io.read_u4le()?.into();
[INFO] [stdout]    |                                             ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 59 -         *self_rc.log_version.borrow_mut() = _io.read_u4le()?.into();
[INFO] [stdout] 59 +         *self_rc.log_version.borrow_mut() = _io.read_u4le()?;
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 59 -         *self_rc.log_version.borrow_mut() = _io.read_u4le()?.into();
[INFO] [stdout] 59 +         *self_rc.log_version.borrow_mut() = <u32 as Into<_>>::into(_io.read_u4le()?);
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `f32`
[INFO] [stdout]    --> src/autel_drone_log.rs:724:46
[INFO] [stdout]     |
[INFO] [stdout] 724 |         *self_rc.gimbal_pitch.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout]     |                                              ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 724 -         *self_rc.gimbal_pitch.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout] 724 +         *self_rc.gimbal_pitch.borrow_mut() = _io.read_f4le()?;
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 724 -         *self_rc.gimbal_pitch.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout] 724 +         *self_rc.gimbal_pitch.borrow_mut() = <f32 as Into<_>>::into(_io.read_f4le()?);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `f32`
[INFO] [stdout]    --> src/autel_drone_log.rs:725:45
[INFO] [stdout]     |
[INFO] [stdout] 725 |         *self_rc.gimbal_roll.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout]     |                                             ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 725 -         *self_rc.gimbal_roll.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout] 725 +         *self_rc.gimbal_roll.borrow_mut() = _io.read_f4le()?;
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 725 -         *self_rc.gimbal_roll.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout] 725 +         *self_rc.gimbal_roll.borrow_mut() = <f32 as Into<_>>::into(_io.read_f4le()?);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `f32`
[INFO] [stdout]    --> src/autel_drone_log.rs:726:44
[INFO] [stdout]     |
[INFO] [stdout] 726 |         *self_rc.gimbal_yaw.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout]     |                                            ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 726 -         *self_rc.gimbal_yaw.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout] 726 +         *self_rc.gimbal_yaw.borrow_mut() = _io.read_f4le()?;
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 726 -         *self_rc.gimbal_yaw.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout] 726 +         *self_rc.gimbal_yaw.borrow_mut() = <f32 as Into<_>>::into(_io.read_f4le()?);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `f32`
[INFO] [stdout]    --> src/autel_drone_log.rs:727:45
[INFO] [stdout]     |
[INFO] [stdout] 727 |         *self_rc.drone_pitch.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout]     |                                             ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 727 -         *self_rc.drone_pitch.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout] 727 +         *self_rc.drone_pitch.borrow_mut() = _io.read_f4le()?;
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 727 -         *self_rc.drone_pitch.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout] 727 +         *self_rc.drone_pitch.borrow_mut() = <f32 as Into<_>>::into(_io.read_f4le()?);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `f32`
[INFO] [stdout]    --> src/autel_drone_log.rs:728:44
[INFO] [stdout]     |
[INFO] [stdout] 728 |         *self_rc.drone_roll.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout]     |                                            ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 728 -         *self_rc.drone_roll.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout] 728 +         *self_rc.drone_roll.borrow_mut() = _io.read_f4le()?;
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 728 -         *self_rc.drone_roll.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout] 728 +         *self_rc.drone_roll.borrow_mut() = <f32 as Into<_>>::into(_io.read_f4le()?);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `f32`
[INFO] [stdout]    --> src/autel_drone_log.rs:729:43
[INFO] [stdout]     |
[INFO] [stdout] 729 |         *self_rc.drone_yaw.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout]     |                                           ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 729 -         *self_rc.drone_yaw.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout] 729 +         *self_rc.drone_yaw.borrow_mut() = _io.read_f4le()?;
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 729 -         *self_rc.drone_yaw.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout] 729 +         *self_rc.drone_yaw.borrow_mut() = <f32 as Into<_>>::into(_io.read_f4le()?);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]    --> src/autel_drone_log.rs:879:49
[INFO] [stdout]     |
[INFO] [stdout] 879 |         *self_rc.mission_time_ms.borrow_mut() = _io.read_u4le()?.into();
[INFO] [stdout]     |                                                 ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 879 -         *self_rc.mission_time_ms.borrow_mut() = _io.read_u4le()?.into();
[INFO] [stdout] 879 +         *self_rc.mission_time_ms.borrow_mut() = _io.read_u4le()?;
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 879 -         *self_rc.mission_time_ms.borrow_mut() = _io.read_u4le()?.into();
[INFO] [stdout] 879 +         *self_rc.mission_time_ms.borrow_mut() = <u32 as Into<_>>::into(_io.read_u4le()?);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `kaitai::OptRc<AutelDroneLog_HeaderT>`
[INFO] [stdout]   --> src/autel_drone_log.rs:63:17
[INFO] [stdout]    |
[INFO] [stdout] 63 |         let t = Self::read_into::<_, AutelDroneLog_HeaderT>(&*_io, Some(self_rc._root.clone()), Some(self_rc._self.clone()))?.into();
[INFO] [stdout]    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 63 -         let t = Self::read_into::<_, AutelDroneLog_HeaderT>(&*_io, Some(self_rc._root.clone()), Some(self_rc._self.clone()))?.into();
[INFO] [stdout] 63 +         let t = Self::read_into::<_, AutelDroneLog_HeaderT>(&*_io, Some(self_rc._root.clone()), Some(self_rc._self.clone()))?;
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 63 -         let t = Self::read_into::<_, AutelDroneLog_HeaderT>(&*_io, Some(self_rc._root.clone()), Some(self_rc._self.clone()))?.into();
[INFO] [stdout] 63 +         let t = <kaitai::OptRc<AutelDroneLog_HeaderT> as Into<_>>::into(Self::read_into::<_, AutelDroneLog_HeaderT>(&*_io, Some(self_rc._root.clone()), Some(self_rc._self.clone()))?);
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `kaitai::OptRc<AutelDroneLog_DroneAttitudeT>`
[INFO] [stdout]    --> src/autel_drone_log.rs:880:17
[INFO] [stdout]     |
[INFO] [stdout] 880 |         let t = Self::read_into::<_, AutelDroneLog_DroneAttitudeT>(&*_io, Some(self_rc._root.clone()), None)?.into();
[INFO] [stdout]     |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 880 -         let t = Self::read_into::<_, AutelDroneLog_DroneAttitudeT>(&*_io, Some(self_rc._root.clone()), None)?.into();
[INFO] [stdout] 880 +         let t = Self::read_into::<_, AutelDroneLog_DroneAttitudeT>(&*_io, Some(self_rc._root.clone()), None)?;
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 880 -         let t = Self::read_into::<_, AutelDroneLog_DroneAttitudeT>(&*_io, Some(self_rc._root.clone()), None)?.into();
[INFO] [stdout] 880 +         let t = <kaitai::OptRc<AutelDroneLog_DroneAttitudeT> as Into<_>>::into(Self::read_into::<_, AutelDroneLog_DroneAttitudeT>(&*_io, Some(self_rc._root.clone()), None)?);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `kaitai::OptRc<AutelDroneLog_ControllerT>`
[INFO] [stdout]    --> src/autel_drone_log.rs:882:17
[INFO] [stdout]     |
[INFO] [stdout] 882 |         let t = Self::read_into::<_, AutelDroneLog_ControllerT>(&*_io, Some(self_rc._root.clone()), None)?.into();
[INFO] [stdout]     |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 882 -         let t = Self::read_into::<_, AutelDroneLog_ControllerT>(&*_io, Some(self_rc._root.clone()), None)?.into();
[INFO] [stdout] 882 +         let t = Self::read_into::<_, AutelDroneLog_ControllerT>(&*_io, Some(self_rc._root.clone()), None)?;
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 882 -         let t = Self::read_into::<_, AutelDroneLog_ControllerT>(&*_io, Some(self_rc._root.clone()), None)?.into();
[INFO] [stdout] 882 +         let t = <kaitai::OptRc<AutelDroneLog_ControllerT> as Into<_>>::into(Self::read_into::<_, AutelDroneLog_ControllerT>(&*_io, Some(self_rc._root.clone()), None)?);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `kaitai::OptRc<AutelDroneLog_RecordT>`
[INFO] [stdout]   --> src/autel_drone_log.rs:69:25
[INFO] [stdout]    |
[INFO] [stdout] 69 | ...t t = Self::read_into::<_, AutelDroneLog_RecordT>(&*_io, Some(self_rc._root.clone()), Some(self_rc._self.clone()))?.into();
[INFO] [stdout]    |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 69 -                 let t = Self::read_into::<_, AutelDroneLog_RecordT>(&*_io, Some(self_rc._root.clone()), Some(self_rc._self.clone()))?.into();
[INFO] [stdout] 69 +                 let t = Self::read_into::<_, AutelDroneLog_RecordT>(&*_io, Some(self_rc._root.clone()), Some(self_rc._self.clone()))?;
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 69 -                 let t = Self::read_into::<_, AutelDroneLog_RecordT>(&*_io, Some(self_rc._root.clone()), Some(self_rc._self.clone()))?.into();
[INFO] [stdout] 69 +                 let t = <kaitai::OptRc<AutelDroneLog_RecordT> as Into<_>>::into(Self::read_into::<_, AutelDroneLog_RecordT>(&*_io, Some(self_rc._root.clone()), Some(self_rc._self.clone()))?);
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/autel_drone_log.rs:884:41
[INFO] [stdout]     |
[INFO] [stdout] 884 |         *self_rc.rc_mode.borrow_mut() = _io.read_u1()?.into();
[INFO] [stdout]     |                                         ^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 884 -         *self_rc.rc_mode.borrow_mut() = _io.read_u1()?.into();
[INFO] [stdout] 884 +         *self_rc.rc_mode.borrow_mut() = _io.read_u1()?;
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 884 -         *self_rc.rc_mode.borrow_mut() = _io.read_u1()?.into();
[INFO] [stdout] 884 +         *self_rc.rc_mode.borrow_mut() = <u8 as Into<_>>::into(_io.read_u1()?);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]    --> src/autel_drone_log.rs:885:50
[INFO] [stdout]     |
[INFO] [stdout] 885 |         *self_rc.offline_duration.borrow_mut() = _io.read_u4le()?.into();
[INFO] [stdout]     |                                                  ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 885 -         *self_rc.offline_duration.borrow_mut() = _io.read_u4le()?.into();
[INFO] [stdout] 885 +         *self_rc.offline_duration.borrow_mut() = _io.read_u4le()?;
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 885 -         *self_rc.offline_duration.borrow_mut() = _io.read_u4le()?.into();
[INFO] [stdout] 885 +         *self_rc.offline_duration.borrow_mut() = <u32 as Into<_>>::into(_io.read_u4le()?);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/autel_drone_log.rs:886:44
[INFO] [stdout]     |
[INFO] [stdout] 886 |         *self_rc.rc_buttons.borrow_mut() = _io.read_u1()?.into();
[INFO] [stdout]     |                                            ^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 886 -         *self_rc.rc_buttons.borrow_mut() = _io.read_u1()?.into();
[INFO] [stdout] 886 +         *self_rc.rc_buttons.borrow_mut() = _io.read_u1()?;
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 886 -         *self_rc.rc_buttons.borrow_mut() = _io.read_u1()?.into();
[INFO] [stdout] 886 +         *self_rc.rc_buttons.borrow_mut() = <u8 as Into<_>>::into(_io.read_u1()?);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]    --> src/autel_drone_log.rs:342:49
[INFO] [stdout]     |
[INFO] [stdout] 342 |         *self_rc.mission_time_ms.borrow_mut() = _io.read_u4le()?.into();
[INFO] [stdout]     |                                                 ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 342 -         *self_rc.mission_time_ms.borrow_mut() = _io.read_u4le()?.into();
[INFO] [stdout] 342 +         *self_rc.mission_time_ms.borrow_mut() = _io.read_u4le()?;
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 342 -         *self_rc.mission_time_ms.borrow_mut() = _io.read_u4le()?.into();
[INFO] [stdout] 342 +         *self_rc.mission_time_ms.borrow_mut() = <u32 as Into<_>>::into(_io.read_u4le()?);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `f64`
[INFO] [stdout]    --> src/autel_drone_log.rs:887:52
[INFO] [stdout]     |
[INFO] [stdout] 887 |         *self_rc.controller_heading.borrow_mut() = _io.read_f8le()?.into();
[INFO] [stdout]     |                                                    ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 887 -         *self_rc.controller_heading.borrow_mut() = _io.read_f8le()?.into();
[INFO] [stdout] 887 +         *self_rc.controller_heading.borrow_mut() = _io.read_f8le()?;
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 887 -         *self_rc.controller_heading.borrow_mut() = _io.read_f8le()?.into();
[INFO] [stdout] 887 +         *self_rc.controller_heading.borrow_mut() = <f64 as Into<_>>::into(_io.read_f8le()?);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `kaitai::OptRc<AutelDroneLog_DroneAttitudeT>`
[INFO] [stdout]    --> src/autel_drone_log.rs:343:17
[INFO] [stdout]     |
[INFO] [stdout] 343 |         let t = Self::read_into::<_, AutelDroneLog_DroneAttitudeT>(&*_io, Some(self_rc._root.clone()), None)?.into();
[INFO] [stdout]     |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 343 -         let t = Self::read_into::<_, AutelDroneLog_DroneAttitudeT>(&*_io, Some(self_rc._root.clone()), None)?.into();
[INFO] [stdout] 343 +         let t = Self::read_into::<_, AutelDroneLog_DroneAttitudeT>(&*_io, Some(self_rc._root.clone()), None)?;
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 343 -         let t = Self::read_into::<_, AutelDroneLog_DroneAttitudeT>(&*_io, Some(self_rc._root.clone()), None)?.into();
[INFO] [stdout] 343 +         let t = <kaitai::OptRc<AutelDroneLog_DroneAttitudeT> as Into<_>>::into(Self::read_into::<_, AutelDroneLog_DroneAttitudeT>(&*_io, Some(self_rc._root.clone()), None)?);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `kaitai::OptRc<AutelDroneLog_OaSensorT>`
[INFO] [stdout]    --> src/autel_drone_log.rs:888:17
[INFO] [stdout]     |
[INFO] [stdout] 888 |         let t = Self::read_into::<_, AutelDroneLog_OaSensorT>(&*_io, Some(self_rc._root.clone()), None)?.into();
[INFO] [stdout]     |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 888 -         let t = Self::read_into::<_, AutelDroneLog_OaSensorT>(&*_io, Some(self_rc._root.clone()), None)?.into();
[INFO] [stdout] 888 +         let t = Self::read_into::<_, AutelDroneLog_OaSensorT>(&*_io, Some(self_rc._root.clone()), None)?;
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 888 -         let t = Self::read_into::<_, AutelDroneLog_OaSensorT>(&*_io, Some(self_rc._root.clone()), None)?.into();
[INFO] [stdout] 888 +         let t = <kaitai::OptRc<AutelDroneLog_OaSensorT> as Into<_>>::into(Self::read_into::<_, AutelDroneLog_OaSensorT>(&*_io, Some(self_rc._root.clone()), None)?);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `kaitai::OptRc<AutelDroneLog_ControllerT>`
[INFO] [stdout]    --> src/autel_drone_log.rs:345:17
[INFO] [stdout]     |
[INFO] [stdout] 345 |         let t = Self::read_into::<_, AutelDroneLog_ControllerT>(&*_io, Some(self_rc._root.clone()), None)?.into();
[INFO] [stdout]     |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 345 -         let t = Self::read_into::<_, AutelDroneLog_ControllerT>(&*_io, Some(self_rc._root.clone()), None)?.into();
[INFO] [stdout] 345 +         let t = Self::read_into::<_, AutelDroneLog_ControllerT>(&*_io, Some(self_rc._root.clone()), None)?;
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 345 -         let t = Self::read_into::<_, AutelDroneLog_ControllerT>(&*_io, Some(self_rc._root.clone()), None)?.into();
[INFO] [stdout] 345 +         let t = <kaitai::OptRc<AutelDroneLog_ControllerT> as Into<_>>::into(Self::read_into::<_, AutelDroneLog_ControllerT>(&*_io, Some(self_rc._root.clone()), None)?);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `kaitai::OptRc<AutelDroneLog_ConfigurationT>`
[INFO] [stdout]    --> src/autel_drone_log.rs:890:17
[INFO] [stdout]     |
[INFO] [stdout] 890 | ... = Self::read_into::<_, AutelDroneLog_ConfigurationT>(&*_io, Some(self_rc._root.clone()), Some(self_rc._self.clone()))?.into();
[INFO] [stdout]     |       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 890 -         let t = Self::read_into::<_, AutelDroneLog_ConfigurationT>(&*_io, Some(self_rc._root.clone()), Some(self_rc._self.clone()))?.into();
[INFO] [stdout] 890 +         let t = Self::read_into::<_, AutelDroneLog_ConfigurationT>(&*_io, Some(self_rc._root.clone()), Some(self_rc._self.clone()))?;
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 890 -         let t = Self::read_into::<_, AutelDroneLog_ConfigurationT>(&*_io, Some(self_rc._root.clone()), Some(self_rc._self.clone()))?.into();
[INFO] [stdout] 890 +         let t = <kaitai::OptRc<AutelDroneLog_ConfigurationT> as Into<_>>::into(Self::read_into::<_, AutelDroneLog_ConfigurationT>(&*_io, Some(self_rc._root.clone()), Some(self_rc._self.clone()))?);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]    --> src/autel_drone_log.rs:892:40
[INFO] [stdout]     |
[INFO] [stdout] 892 |         *self_rc.param1.borrow_mut() = _io.read_u4le()?.into();
[INFO] [stdout]     |                                        ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 892 -         *self_rc.param1.borrow_mut() = _io.read_u4le()?.into();
[INFO] [stdout] 892 +         *self_rc.param1.borrow_mut() = _io.read_u4le()?;
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 892 -         *self_rc.param1.borrow_mut() = _io.read_u4le()?.into();
[INFO] [stdout] 892 +         *self_rc.param1.borrow_mut() = <u32 as Into<_>>::into(_io.read_u4le()?);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/autel_drone_log.rs:347:41
[INFO] [stdout]     |
[INFO] [stdout] 347 |         *self_rc.rc_mode.borrow_mut() = _io.read_u1()?.into();
[INFO] [stdout]     |                                         ^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 347 -         *self_rc.rc_mode.borrow_mut() = _io.read_u1()?.into();
[INFO] [stdout] 347 +         *self_rc.rc_mode.borrow_mut() = _io.read_u1()?;
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 347 -         *self_rc.rc_mode.borrow_mut() = _io.read_u1()?.into();
[INFO] [stdout] 347 +         *self_rc.rc_mode.borrow_mut() = <u8 as Into<_>>::into(_io.read_u1()?);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]    --> src/autel_drone_log.rs:893:40
[INFO] [stdout]     |
[INFO] [stdout] 893 |         *self_rc.param2.borrow_mut() = _io.read_u4le()?.into();
[INFO] [stdout]     |                                        ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 893 -         *self_rc.param2.borrow_mut() = _io.read_u4le()?.into();
[INFO] [stdout] 893 +         *self_rc.param2.borrow_mut() = _io.read_u4le()?;
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 893 -         *self_rc.param2.borrow_mut() = _io.read_u4le()?.into();
[INFO] [stdout] 893 +         *self_rc.param2.borrow_mut() = <u32 as Into<_>>::into(_io.read_u4le()?);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]    --> src/autel_drone_log.rs:348:50
[INFO] [stdout]     |
[INFO] [stdout] 348 |         *self_rc.offline_duration.borrow_mut() = _io.read_u4le()?.into();
[INFO] [stdout]     |                                                  ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 348 -         *self_rc.offline_duration.borrow_mut() = _io.read_u4le()?.into();
[INFO] [stdout] 348 +         *self_rc.offline_duration.borrow_mut() = _io.read_u4le()?;
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 348 -         *self_rc.offline_duration.borrow_mut() = _io.read_u4le()?.into();
[INFO] [stdout] 348 +         *self_rc.offline_duration.borrow_mut() = <u32 as Into<_>>::into(_io.read_u4le()?);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]    --> src/autel_drone_log.rs:894:40
[INFO] [stdout]     |
[INFO] [stdout] 894 |         *self_rc.param3.borrow_mut() = _io.read_u4le()?.into();
[INFO] [stdout]     |                                        ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 894 -         *self_rc.param3.borrow_mut() = _io.read_u4le()?.into();
[INFO] [stdout] 894 +         *self_rc.param3.borrow_mut() = _io.read_u4le()?;
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 894 -         *self_rc.param3.borrow_mut() = _io.read_u4le()?.into();
[INFO] [stdout] 894 +         *self_rc.param3.borrow_mut() = <u32 as Into<_>>::into(_io.read_u4le()?);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]    --> src/autel_drone_log.rs:895:40
[INFO] [stdout]     |
[INFO] [stdout] 895 |         *self_rc.param4.borrow_mut() = _io.read_u4le()?.into();
[INFO] [stdout]     |                                        ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 895 -         *self_rc.param4.borrow_mut() = _io.read_u4le()?.into();
[INFO] [stdout] 895 +         *self_rc.param4.borrow_mut() = _io.read_u4le()?;
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 895 -         *self_rc.param4.borrow_mut() = _io.read_u4le()?.into();
[INFO] [stdout] 895 +         *self_rc.param4.borrow_mut() = <u32 as Into<_>>::into(_io.read_u4le()?);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/autel_drone_log.rs:349:44
[INFO] [stdout]     |
[INFO] [stdout] 349 |         *self_rc.rc_buttons.borrow_mut() = _io.read_u1()?.into();
[INFO] [stdout]     |                                            ^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 349 -         *self_rc.rc_buttons.borrow_mut() = _io.read_u1()?.into();
[INFO] [stdout] 349 +         *self_rc.rc_buttons.borrow_mut() = _io.read_u1()?;
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 349 -         *self_rc.rc_buttons.borrow_mut() = _io.read_u1()?.into();
[INFO] [stdout] 349 +         *self_rc.rc_buttons.borrow_mut() = <u8 as Into<_>>::into(_io.read_u1()?);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]    --> src/autel_drone_log.rs:896:40
[INFO] [stdout]     |
[INFO] [stdout] 896 |         *self_rc.param5.borrow_mut() = _io.read_u4le()?.into();
[INFO] [stdout]     |                                        ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 896 -         *self_rc.param5.borrow_mut() = _io.read_u4le()?.into();
[INFO] [stdout] 896 +         *self_rc.param5.borrow_mut() = _io.read_u4le()?;
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 896 -         *self_rc.param5.borrow_mut() = _io.read_u4le()?.into();
[INFO] [stdout] 896 +         *self_rc.param5.borrow_mut() = <u32 as Into<_>>::into(_io.read_u4le()?);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `f64`
[INFO] [stdout]    --> src/autel_drone_log.rs:350:52
[INFO] [stdout]     |
[INFO] [stdout] 350 |         *self_rc.controller_heading.borrow_mut() = _io.read_f8le()?.into();
[INFO] [stdout]     |                                                    ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 350 -         *self_rc.controller_heading.borrow_mut() = _io.read_f8le()?.into();
[INFO] [stdout] 350 +         *self_rc.controller_heading.borrow_mut() = _io.read_f8le()?;
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 350 -         *self_rc.controller_heading.borrow_mut() = _io.read_f8le()?.into();
[INFO] [stdout] 350 +         *self_rc.controller_heading.borrow_mut() = <f64 as Into<_>>::into(_io.read_f8le()?);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u16`
[INFO] [stdout]     --> src/autel_drone_log.rs:1055:45
[INFO] [stdout]      |
[INFO] [stdout] 1055 |         *self_rc.header_size.borrow_mut() = _io.read_u2le()?.into();
[INFO] [stdout]      |                                             ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1055 -         *self_rc.header_size.borrow_mut() = _io.read_u2le()?.into();
[INFO] [stdout] 1055 +         *self_rc.header_size.borrow_mut() = _io.read_u2le()?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1055 -         *self_rc.header_size.borrow_mut() = _io.read_u2le()?.into();
[INFO] [stdout] 1055 +         *self_rc.header_size.borrow_mut() = <u16 as Into<_>>::into(_io.read_u2le()?);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Vec<u8>`
[INFO] [stdout]     --> src/autel_drone_log.rs:1056:60
[INFO] [stdout]      |
[INFO] [stdout] 1056 |         *self_rc.drone_serial.borrow_mut() = bytes_to_str(&_io.read_bytes(18 as usize)?.into(), "UTF-8")?;
[INFO] [stdout]      |                                                            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1056 -         *self_rc.drone_serial.borrow_mut() = bytes_to_str(&_io.read_bytes(18 as usize)?.into(), "UTF-8")?;
[INFO] [stdout] 1056 +         *self_rc.drone_serial.borrow_mut() = bytes_to_str(&_io.read_bytes(18 as usize)?, "UTF-8")?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1056 -         *self_rc.drone_serial.borrow_mut() = bytes_to_str(&_io.read_bytes(18 as usize)?.into(), "UTF-8")?;
[INFO] [stdout] 1056 +         *self_rc.drone_serial.borrow_mut() = bytes_to_str(&<Vec<u8> as Into<_>>::into(_io.read_bytes(18 as usize)?), "UTF-8")?;
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Vec<u8>`
[INFO] [stdout]     --> src/autel_drone_log.rs:1057:62
[INFO] [stdout]      |
[INFO] [stdout] 1057 |         *self_rc.battery_serial.borrow_mut() = bytes_to_str(&_io.read_bytes(32 as usize)?.into(), "UTF-8")?;
[INFO] [stdout]      |                                                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1057 -         *self_rc.battery_serial.borrow_mut() = bytes_to_str(&_io.read_bytes(32 as usize)?.into(), "UTF-8")?;
[INFO] [stdout] 1057 +         *self_rc.battery_serial.borrow_mut() = bytes_to_str(&_io.read_bytes(32 as usize)?, "UTF-8")?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1057 -         *self_rc.battery_serial.borrow_mut() = bytes_to_str(&_io.read_bytes(32 as usize)?.into(), "UTF-8")?;
[INFO] [stdout] 1057 +         *self_rc.battery_serial.borrow_mut() = bytes_to_str(&<Vec<u8> as Into<_>>::into(_io.read_bytes(32 as usize)?), "UTF-8")?;
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Vec<u8>`
[INFO] [stdout]     --> src/autel_drone_log.rs:1058:56
[INFO] [stdout]      |
[INFO] [stdout] 1058 |         *self_rc.location.borrow_mut() = bytes_to_str(&_io.read_bytes(64 as usize)?.into(), "UTF-8")?;
[INFO] [stdout]      |                                                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1058 -         *self_rc.location.borrow_mut() = bytes_to_str(&_io.read_bytes(64 as usize)?.into(), "UTF-8")?;
[INFO] [stdout] 1058 +         *self_rc.location.borrow_mut() = bytes_to_str(&_io.read_bytes(64 as usize)?, "UTF-8")?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1058 -         *self_rc.location.borrow_mut() = bytes_to_str(&_io.read_bytes(64 as usize)?.into(), "UTF-8")?;
[INFO] [stdout] 1058 +         *self_rc.location.borrow_mut() = bytes_to_str(&<Vec<u8> as Into<_>>::into(_io.read_bytes(64 as usize)?), "UTF-8")?;
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]     --> src/autel_drone_log.rs:1059:44
[INFO] [stdout]      |
[INFO] [stdout] 1059 |         *self_rc.drone_type.borrow_mut() = _io.read_u1()?.into();
[INFO] [stdout]      |                                            ^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1059 -         *self_rc.drone_type.borrow_mut() = _io.read_u1()?.into();
[INFO] [stdout] 1059 +         *self_rc.drone_type.borrow_mut() = _io.read_u1()?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1059 -         *self_rc.drone_type.borrow_mut() = _io.read_u1()?.into();
[INFO] [stdout] 1059 +         *self_rc.drone_type.borrow_mut() = <u8 as Into<_>>::into(_io.read_u1()?);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `f32`
[INFO] [stdout]     --> src/autel_drone_log.rs:1060:42
[INFO] [stdout]      |
[INFO] [stdout] 1060 |         *self_rc.distance.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout]      |                                          ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1060 -         *self_rc.distance.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout] 1060 +         *self_rc.distance.borrow_mut() = _io.read_f4le()?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1060 -         *self_rc.distance.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout] 1060 +         *self_rc.distance.borrow_mut() = <f32 as Into<_>>::into(_io.read_f4le()?);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]     --> src/autel_drone_log.rs:1061:51
[INFO] [stdout]      |
[INFO] [stdout] 1061 |         *self_rc.flight_duration_s.borrow_mut() = _io.read_u4le()?.into();
[INFO] [stdout]      |                                                   ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1061 -         *self_rc.flight_duration_s.borrow_mut() = _io.read_u4le()?.into();
[INFO] [stdout] 1061 +         *self_rc.flight_duration_s.borrow_mut() = _io.read_u4le()?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1061 -         *self_rc.flight_duration_s.borrow_mut() = _io.read_u4le()?.into();
[INFO] [stdout] 1061 +         *self_rc.flight_duration_s.borrow_mut() = <u32 as Into<_>>::into(_io.read_u4le()?);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `f32`
[INFO] [stdout]     --> src/autel_drone_log.rs:1062:46
[INFO] [stdout]      |
[INFO] [stdout] 1062 |         *self_rc.max_altitude.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout]      |                                              ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1062 -         *self_rc.max_altitude.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout] 1062 +         *self_rc.max_altitude.borrow_mut() = _io.read_f4le()?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1062 -         *self_rc.max_altitude.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout] 1062 +         *self_rc.max_altitude.borrow_mut() = <f32 as Into<_>>::into(_io.read_f4le()?);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]     --> src/autel_drone_log.rs:1063:48
[INFO] [stdout]      |
[INFO] [stdout] 1063 |         *self_rc.video_duration.borrow_mut() = _io.read_u4le()?.into();
[INFO] [stdout]      |                                                ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1063 -         *self_rc.video_duration.borrow_mut() = _io.read_u4le()?.into();
[INFO] [stdout] 1063 +         *self_rc.video_duration.borrow_mut() = _io.read_u4le()?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1063 -         *self_rc.video_duration.borrow_mut() = _io.read_u4le()?.into();
[INFO] [stdout] 1063 +         *self_rc.video_duration.borrow_mut() = <u32 as Into<_>>::into(_io.read_u4le()?);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `kaitai::OptRc<AutelDroneLog_OaSensorT>`
[INFO] [stdout]    --> src/autel_drone_log.rs:351:17
[INFO] [stdout]     |
[INFO] [stdout] 351 |         let t = Self::read_into::<_, AutelDroneLog_OaSensorT>(&*_io, Some(self_rc._root.clone()), None)?.into();
[INFO] [stdout]     |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 351 -         let t = Self::read_into::<_, AutelDroneLog_OaSensorT>(&*_io, Some(self_rc._root.clone()), None)?.into();
[INFO] [stdout] 351 +         let t = Self::read_into::<_, AutelDroneLog_OaSensorT>(&*_io, Some(self_rc._root.clone()), None)?;
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 351 -         let t = Self::read_into::<_, AutelDroneLog_OaSensorT>(&*_io, Some(self_rc._root.clone()), None)?.into();
[INFO] [stdout] 351 +         let t = <kaitai::OptRc<AutelDroneLog_OaSensorT> as Into<_>>::into(Self::read_into::<_, AutelDroneLog_OaSensorT>(&*_io, Some(self_rc._root.clone()), None)?);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u64`
[INFO] [stdout]     --> src/autel_drone_log.rs:1064:47
[INFO] [stdout]      |
[INFO] [stdout] 1064 |         *self_rc.start_time_ms.borrow_mut() = _io.read_u8le()?.into();
[INFO] [stdout]      |                                               ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1064 -         *self_rc.start_time_ms.borrow_mut() = _io.read_u8le()?.into();
[INFO] [stdout] 1064 +         *self_rc.start_time_ms.borrow_mut() = _io.read_u8le()?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1064 -         *self_rc.start_time_ms.borrow_mut() = _io.read_u8le()?.into();
[INFO] [stdout] 1064 +         *self_rc.start_time_ms.borrow_mut() = <u64 as Into<_>>::into(_io.read_u8le()?);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]    --> src/autel_drone_log.rs:353:40
[INFO] [stdout]     |
[INFO] [stdout] 353 |         *self_rc.param1.borrow_mut() = _io.read_u4le()?.into();
[INFO] [stdout]     |                                        ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 353 -         *self_rc.param1.borrow_mut() = _io.read_u4le()?.into();
[INFO] [stdout] 353 +         *self_rc.param1.borrow_mut() = _io.read_u4le()?;
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 353 -         *self_rc.param1.borrow_mut() = _io.read_u4le()?.into();
[INFO] [stdout] 353 +         *self_rc.param1.borrow_mut() = <u32 as Into<_>>::into(_io.read_u4le()?);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]     --> src/autel_drone_log.rs:1065:42
[INFO] [stdout]      |
[INFO] [stdout] 1065 |         *self_rc.timezone.borrow_mut() = _io.read_u4le()?.into();
[INFO] [stdout]      |                                          ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1065 -         *self_rc.timezone.borrow_mut() = _io.read_u4le()?.into();
[INFO] [stdout] 1065 +         *self_rc.timezone.borrow_mut() = _io.read_u4le()?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1065 -         *self_rc.timezone.borrow_mut() = _io.read_u4le()?.into();
[INFO] [stdout] 1065 +         *self_rc.timezone.borrow_mut() = <u32 as Into<_>>::into(_io.read_u4le()?);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]    --> src/autel_drone_log.rs:354:40
[INFO] [stdout]     |
[INFO] [stdout] 354 |         *self_rc.param2.borrow_mut() = _io.read_u4le()?.into();
[INFO] [stdout]     |                                        ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 354 -         *self_rc.param2.borrow_mut() = _io.read_u4le()?.into();
[INFO] [stdout] 354 +         *self_rc.param2.borrow_mut() = _io.read_u4le()?;
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 354 -         *self_rc.param2.borrow_mut() = _io.read_u4le()?.into();
[INFO] [stdout] 354 +         *self_rc.param2.borrow_mut() = <u32 as Into<_>>::into(_io.read_u4le()?);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `f32`
[INFO] [stdout]     --> src/autel_drone_log.rs:1066:48
[INFO] [stdout]      |
[INFO] [stdout] 1066 |         *self_rc.start_latitude.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout]      |                                                ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1066 -         *self_rc.start_latitude.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout] 1066 +         *self_rc.start_latitude.borrow_mut() = _io.read_f4le()?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1066 -         *self_rc.start_latitude.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout] 1066 +         *self_rc.start_latitude.borrow_mut() = <f32 as Into<_>>::into(_io.read_f4le()?);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/autel_drone_log.rs:480:45
[INFO] [stdout]     |
[INFO] [stdout] 480 |         *self_rc.camera_mode.borrow_mut() = _io.read_u1()?.into();
[INFO] [stdout]     |                                             ^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 480 -         *self_rc.camera_mode.borrow_mut() = _io.read_u1()?.into();
[INFO] [stdout] 480 +         *self_rc.camera_mode.borrow_mut() = _io.read_u1()?;
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 480 -         *self_rc.camera_mode.borrow_mut() = _io.read_u1()?.into();
[INFO] [stdout] 480 +         *self_rc.camera_mode.borrow_mut() = <u8 as Into<_>>::into(_io.read_u1()?);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/autel_drone_log.rs:481:43
[INFO] [stdout]     |
[INFO] [stdout] 481 |         *self_rc.gnss_rssi.borrow_mut() = _io.read_u1()?.into();
[INFO] [stdout]     |                                           ^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 481 -         *self_rc.gnss_rssi.borrow_mut() = _io.read_u1()?.into();
[INFO] [stdout] 481 +         *self_rc.gnss_rssi.borrow_mut() = _io.read_u1()?;
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 481 -         *self_rc.gnss_rssi.borrow_mut() = _io.read_u1()?.into();
[INFO] [stdout] 481 +         *self_rc.gnss_rssi.borrow_mut() = <u8 as Into<_>>::into(_io.read_u1()?);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `f32`
[INFO] [stdout]     --> src/autel_drone_log.rs:1067:49
[INFO] [stdout]      |
[INFO] [stdout] 1067 |         *self_rc.start_longitude.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout]      |                                                 ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1067 -         *self_rc.start_longitude.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout] 1067 +         *self_rc.start_longitude.borrow_mut() = _io.read_f4le()?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1067 -         *self_rc.start_longitude.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout] 1067 +         *self_rc.start_longitude.borrow_mut() = <f32 as Into<_>>::into(_io.read_f4le()?);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/autel_drone_log.rs:482:49
[INFO] [stdout]     |
[INFO] [stdout] 482 |         *self_rc.controller_rssi.borrow_mut() = _io.read_u1()?.into();
[INFO] [stdout]     |                                                 ^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 482 -         *self_rc.controller_rssi.borrow_mut() = _io.read_u1()?.into();
[INFO] [stdout] 482 +         *self_rc.controller_rssi.borrow_mut() = _io.read_u1()?;
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 482 -         *self_rc.controller_rssi.borrow_mut() = _io.read_u1()?.into();
[INFO] [stdout] 482 +         *self_rc.controller_rssi.borrow_mut() = <u8 as Into<_>>::into(_io.read_u1()?);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/autel_drone_log.rs:483:44
[INFO] [stdout]     |
[INFO] [stdout] 483 |         *self_rc.stick_mode.borrow_mut() = _io.read_u1()?.into();
[INFO] [stdout]     |                                            ^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 483 -         *self_rc.stick_mode.borrow_mut() = _io.read_u1()?.into();
[INFO] [stdout] 483 +         *self_rc.stick_mode.borrow_mut() = _io.read_u1()?;
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 483 -         *self_rc.stick_mode.borrow_mut() = _io.read_u1()?.into();
[INFO] [stdout] 483 +         *self_rc.stick_mode.borrow_mut() = <u8 as Into<_>>::into(_io.read_u1()?);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u16`
[INFO] [stdout]     --> src/autel_drone_log.rs:1068:45
[INFO] [stdout]      |
[INFO] [stdout] 1068 |         *self_rc.image_count.borrow_mut() = _io.read_u2le()?.into();
[INFO] [stdout]      |                                             ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1068 -         *self_rc.image_count.borrow_mut() = _io.read_u2le()?.into();
[INFO] [stdout] 1068 +         *self_rc.image_count.borrow_mut() = _io.read_u2le()?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1068 -         *self_rc.image_count.borrow_mut() = _io.read_u2le()?.into();
[INFO] [stdout] 1068 +         *self_rc.image_count.borrow_mut() = <u16 as Into<_>>::into(_io.read_u2le()?);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `kaitai::OptRc<AutelDroneLog_HomeInfoT>`
[INFO] [stdout]    --> src/autel_drone_log.rs:484:17
[INFO] [stdout]     |
[INFO] [stdout] 484 | ... t = Self::read_into::<_, AutelDroneLog_HomeInfoT>(&*_io, Some(self_rc._root.clone()), Some(self_rc._self.clone()))?.into();
[INFO] [stdout]     |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 484 -         let t = Self::read_into::<_, AutelDroneLog_HomeInfoT>(&*_io, Some(self_rc._root.clone()), Some(self_rc._self.clone()))?.into();
[INFO] [stdout] 484 +         let t = Self::read_into::<_, AutelDroneLog_HomeInfoT>(&*_io, Some(self_rc._root.clone()), Some(self_rc._self.clone()))?;
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 484 -         let t = Self::read_into::<_, AutelDroneLog_HomeInfoT>(&*_io, Some(self_rc._root.clone()), Some(self_rc._self.clone()))?.into();
[INFO] [stdout] 484 +         let t = <kaitai::OptRc<AutelDroneLog_HomeInfoT> as Into<_>>::into(Self::read_into::<_, AutelDroneLog_HomeInfoT>(&*_io, Some(self_rc._root.clone()), Some(self_rc._self.clone()))?);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `f32`
[INFO] [stdout]    --> src/autel_drone_log.rs:486:48
[INFO] [stdout]     |
[INFO] [stdout] 486 |         *self_rc.distance_flown.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout]     |                                                ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 486 -         *self_rc.distance_flown.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout] 486 +         *self_rc.distance_flown.borrow_mut() = _io.read_f4le()?;
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 486 -         *self_rc.distance_flown.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout] 486 +         *self_rc.distance_flown.borrow_mut() = <f32 as Into<_>>::into(_io.read_f4le()?);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u16`
[INFO] [stdout]     --> src/autel_drone_log.rs:1069:45
[INFO] [stdout]      |
[INFO] [stdout] 1069 |         *self_rc.video_count.borrow_mut() = _io.read_u2le()?.into();
[INFO] [stdout]      |                                             ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1069 -         *self_rc.video_count.borrow_mut() = _io.read_u2le()?.into();
[INFO] [stdout] 1069 +         *self_rc.video_count.borrow_mut() = _io.read_u2le()?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1069 -         *self_rc.video_count.borrow_mut() = _io.read_u2le()?.into();
[INFO] [stdout] 1069 +         *self_rc.video_count.borrow_mut() = <u16 as Into<_>>::into(_io.read_u2le()?);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]    --> src/autel_drone_log.rs:487:53
[INFO] [stdout]     |
[INFO] [stdout] 487 |         *self_rc.drone_warning_flags.borrow_mut() = _io.read_u4le()?.into();
[INFO] [stdout]     |                                                     ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 487 -         *self_rc.drone_warning_flags.borrow_mut() = _io.read_u4le()?.into();
[INFO] [stdout] 487 +         *self_rc.drone_warning_flags.borrow_mut() = _io.read_u4le()?;
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 487 -         *self_rc.drone_warning_flags.borrow_mut() = _io.read_u4le()?.into();
[INFO] [stdout] 487 +         *self_rc.drone_warning_flags.borrow_mut() = <u32 as Into<_>>::into(_io.read_u4le()?);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u16`
[INFO] [stdout]     --> src/autel_drone_log.rs:1070:49
[INFO] [stdout]      |
[INFO] [stdout] 1070 |         *self_rc.firmware_length.borrow_mut() = _io.read_u2le()?.into();
[INFO] [stdout]      |                                                 ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1070 -         *self_rc.firmware_length.borrow_mut() = _io.read_u2le()?.into();
[INFO] [stdout] 1070 +         *self_rc.firmware_length.borrow_mut() = _io.read_u2le()?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1070 -         *self_rc.firmware_length.borrow_mut() = _io.read_u2le()?.into();
[INFO] [stdout] 1070 +         *self_rc.firmware_length.borrow_mut() = <u16 as Into<_>>::into(_io.read_u2le()?);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]    --> src/autel_drone_log.rs:488:57
[INFO] [stdout]     |
[INFO] [stdout] 488 |         *self_rc.drone_ext_warning_flags.borrow_mut() = _io.read_u4le()?.into();
[INFO] [stdout]     |                                                         ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 488 -         *self_rc.drone_ext_warning_flags.borrow_mut() = _io.read_u4le()?.into();
[INFO] [stdout] 488 +         *self_rc.drone_ext_warning_flags.borrow_mut() = _io.read_u4le()?;
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 488 -         *self_rc.drone_ext_warning_flags.borrow_mut() = _io.read_u4le()?.into();
[INFO] [stdout] 488 +         *self_rc.drone_ext_warning_flags.borrow_mut() = <u32 as Into<_>>::into(_io.read_u4le()?);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]    --> src/autel_drone_log.rs:489:54
[INFO] [stdout]     |
[INFO] [stdout] 489 |         *self_rc.gimbal_warning_flags.borrow_mut() = _io.read_u4le()?.into();
[INFO] [stdout]     |                                                      ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 489 -         *self_rc.gimbal_warning_flags.borrow_mut() = _io.read_u4le()?.into();
[INFO] [stdout] 489 +         *self_rc.gimbal_warning_flags.borrow_mut() = _io.read_u4le()?;
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 489 -         *self_rc.gimbal_warning_flags.borrow_mut() = _io.read_u4le()?.into();
[INFO] [stdout] 489 +         *self_rc.gimbal_warning_flags.borrow_mut() = <u32 as Into<_>>::into(_io.read_u4le()?);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]    --> src/autel_drone_log.rs:490:48
[INFO] [stdout]     |
[INFO] [stdout] 490 |         *self_rc.time_remaining.borrow_mut() = _io.read_u4le()?.into();
[INFO] [stdout]     |                                                ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 490 -         *self_rc.time_remaining.borrow_mut() = _io.read_u4le()?.into();
[INFO] [stdout] 490 +         *self_rc.time_remaining.borrow_mut() = _io.read_u4le()?;
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 490 -         *self_rc.time_remaining.borrow_mut() = _io.read_u4le()?.into();
[INFO] [stdout] 490 +         *self_rc.time_remaining.borrow_mut() = <u32 as Into<_>>::into(_io.read_u4le()?);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Vec<u8>`
[INFO] [stdout]     --> src/autel_drone_log.rs:1071:61
[INFO] [stdout]      |
[INFO] [stdout] 1071 |         *self_rc.firmware_info.borrow_mut() = bytes_to_str(&_io.read_bytes(*self_rc.firmware_length() as usize)?.into(), "UTF-8")?;
[INFO] [stdout]      |                                                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1071 -         *self_rc.firmware_info.borrow_mut() = bytes_to_str(&_io.read_bytes(*self_rc.firmware_length() as usize)?.into(), "UTF-8")?;
[INFO] [stdout] 1071 +         *self_rc.firmware_info.borrow_mut() = bytes_to_str(&_io.read_bytes(*self_rc.firmware_length() as usize)?, "UTF-8")?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1071 -         *self_rc.firmware_info.borrow_mut() = bytes_to_str(&_io.read_bytes(*self_rc.firmware_length() as usize)?.into(), "UTF-8")?;
[INFO] [stdout] 1071 +         *self_rc.firmware_info.borrow_mut() = bytes_to_str(&<Vec<u8> as Into<_>>::into(_io.read_bytes(*self_rc.firmware_length() as usize)?), "UTF-8")?;
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]    --> src/autel_drone_log.rs:491:43
[INFO] [stdout]     |
[INFO] [stdout] 491 |         *self_rc.back_time.borrow_mut() = _io.read_u4le()?.into();
[INFO] [stdout]     |                                           ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 491 -         *self_rc.back_time.borrow_mut() = _io.read_u4le()?.into();
[INFO] [stdout] 491 +         *self_rc.back_time.borrow_mut() = _io.read_u4le()?;
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 491 -         *self_rc.back_time.borrow_mut() = _io.read_u4le()?.into();
[INFO] [stdout] 491 +         *self_rc.back_time.borrow_mut() = <u32 as Into<_>>::into(_io.read_u4le()?);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `f32`
[INFO] [stdout]     --> src/autel_drone_log.rs:1195:47
[INFO] [stdout]      |
[INFO] [stdout] 1195 |         *self_rc.home_latitude.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout]      |                                               ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1195 -         *self_rc.home_latitude.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout] 1195 +         *self_rc.home_latitude.borrow_mut() = _io.read_f4le()?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1195 -         *self_rc.home_latitude.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout] 1195 +         *self_rc.home_latitude.borrow_mut() = <f32 as Into<_>>::into(_io.read_f4le()?);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/autel_drone_log.rs:492:49
[INFO] [stdout]     |
[INFO] [stdout] 492 |         *self_rc.satellite_count.borrow_mut() = _io.read_u1()?.into();
[INFO] [stdout]     |                                                 ^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 492 -         *self_rc.satellite_count.borrow_mut() = _io.read_u1()?.into();
[INFO] [stdout] 492 +         *self_rc.satellite_count.borrow_mut() = _io.read_u1()?;
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 492 -         *self_rc.satellite_count.borrow_mut() = _io.read_u1()?.into();
[INFO] [stdout] 492 +         *self_rc.satellite_count.borrow_mut() = <u8 as Into<_>>::into(_io.read_u1()?);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `kaitai::OptRc<AutelDroneLog_PowerInfoT>`
[INFO] [stdout]    --> src/autel_drone_log.rs:493:17
[INFO] [stdout]     |
[INFO] [stdout] 493 | ...t = Self::read_into::<_, AutelDroneLog_PowerInfoT>(&*_io, Some(self_rc._root.clone()), Some(self_rc._self.clone()))?.into();
[INFO] [stdout]     |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 493 -         let t = Self::read_into::<_, AutelDroneLog_PowerInfoT>(&*_io, Some(self_rc._root.clone()), Some(self_rc._self.clone()))?.into();
[INFO] [stdout] 493 +         let t = Self::read_into::<_, AutelDroneLog_PowerInfoT>(&*_io, Some(self_rc._root.clone()), Some(self_rc._self.clone()))?;
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 493 -         let t = Self::read_into::<_, AutelDroneLog_PowerInfoT>(&*_io, Some(self_rc._root.clone()), Some(self_rc._self.clone()))?.into();
[INFO] [stdout] 493 +         let t = <kaitai::OptRc<AutelDroneLog_PowerInfoT> as Into<_>>::into(Self::read_into::<_, AutelDroneLog_PowerInfoT>(&*_io, Some(self_rc._root.clone()), Some(self_rc._self.clone()))?);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `f32`
[INFO] [stdout]     --> src/autel_drone_log.rs:1196:48
[INFO] [stdout]      |
[INFO] [stdout] 1196 |         *self_rc.home_longitude.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout]      |                                                ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1196 -         *self_rc.home_longitude.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout] 1196 +         *self_rc.home_longitude.borrow_mut() = _io.read_f4le()?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1196 -         *self_rc.home_longitude.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout] 1196 +         *self_rc.home_longitude.borrow_mut() = <f32 as Into<_>>::into(_io.read_f4le()?);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `f32`
[INFO] [stdout]     --> src/autel_drone_log.rs:1197:52
[INFO] [stdout]      |
[INFO] [stdout] 1197 |         *self_rc.distance_to_home_m.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout]      |                                                    ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1197 -         *self_rc.distance_to_home_m.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout] 1197 +         *self_rc.distance_to_home_m.borrow_mut() = _io.read_f4le()?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1197 -         *self_rc.distance_to_home_m.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout] 1197 +         *self_rc.distance_to_home_m.borrow_mut() = <f32 as Into<_>>::into(_io.read_f4le()?);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `kaitai::OptRc<AutelDroneLog_SettingsT>`
[INFO] [stdout]    --> src/autel_drone_log.rs:495:17
[INFO] [stdout]     |
[INFO] [stdout] 495 | ... t = Self::read_into::<_, AutelDroneLog_SettingsT>(&*_io, Some(self_rc._root.clone()), Some(self_rc._self.clone()))?.into();
[INFO] [stdout]     |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 495 -         let t = Self::read_into::<_, AutelDroneLog_SettingsT>(&*_io, Some(self_rc._root.clone()), Some(self_rc._self.clone()))?.into();
[INFO] [stdout] 495 +         let t = Self::read_into::<_, AutelDroneLog_SettingsT>(&*_io, Some(self_rc._root.clone()), Some(self_rc._self.clone()))?;
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 495 -         let t = Self::read_into::<_, AutelDroneLog_SettingsT>(&*_io, Some(self_rc._root.clone()), Some(self_rc._self.clone()))?.into();
[INFO] [stdout] 495 +         let t = <kaitai::OptRc<AutelDroneLog_SettingsT> as Into<_>>::into(Self::read_into::<_, AutelDroneLog_SettingsT>(&*_io, Some(self_rc._root.clone()), Some(self_rc._self.clone()))?);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `f64`
[INFO] [stdout]     --> src/autel_drone_log.rs:1255:43
[INFO] [stdout]      |
[INFO] [stdout] 1255 |         *self_rc.timestamp.borrow_mut() = _io.read_f8le()?.into();
[INFO] [stdout]      |                                           ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1255 -         *self_rc.timestamp.borrow_mut() = _io.read_f8le()?.into();
[INFO] [stdout] 1255 +         *self_rc.timestamp.borrow_mut() = _io.read_f8le()?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1255 -         *self_rc.timestamp.borrow_mut() = _io.read_f8le()?.into();
[INFO] [stdout] 1255 +         *self_rc.timestamp.borrow_mut() = <f64 as Into<_>>::into(_io.read_f8le()?);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `f32`
[INFO] [stdout]     --> src/autel_drone_log.rs:1256:46
[INFO] [stdout]      |
[INFO] [stdout] 1256 |         *self_rc.front_sensor.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout]      |                                              ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1256 -         *self_rc.front_sensor.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout] 1256 +         *self_rc.front_sensor.borrow_mut() = _io.read_f4le()?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1256 -         *self_rc.front_sensor.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout] 1256 +         *self_rc.front_sensor.borrow_mut() = <f32 as Into<_>>::into(_io.read_f4le()?);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u16`
[INFO] [stdout]    --> src/autel_drone_log.rs:642:46
[INFO] [stdout]     |
[INFO] [stdout] 642 |         *self_rc.left_stick_x.borrow_mut() = _io.read_u2le()?.into();
[INFO] [stdout]     |                                              ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 642 -         *self_rc.left_stick_x.borrow_mut() = _io.read_u2le()?.into();
[INFO] [stdout] 642 +         *self_rc.left_stick_x.borrow_mut() = _io.read_u2le()?;
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 642 -         *self_rc.left_stick_x.borrow_mut() = _io.read_u2le()?.into();
[INFO] [stdout] 642 +         *self_rc.left_stick_x.borrow_mut() = <u16 as Into<_>>::into(_io.read_u2le()?);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u16`
[INFO] [stdout]    --> src/autel_drone_log.rs:643:46
[INFO] [stdout]     |
[INFO] [stdout] 643 |         *self_rc.left_stick_y.borrow_mut() = _io.read_u2le()?.into();
[INFO] [stdout]     |                                              ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 643 -         *self_rc.left_stick_y.borrow_mut() = _io.read_u2le()?.into();
[INFO] [stdout] 643 +         *self_rc.left_stick_y.borrow_mut() = _io.read_u2le()?;
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 643 -         *self_rc.left_stick_y.borrow_mut() = _io.read_u2le()?.into();
[INFO] [stdout] 643 +         *self_rc.left_stick_y.borrow_mut() = <u16 as Into<_>>::into(_io.read_u2le()?);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `f32`
[INFO] [stdout]     --> src/autel_drone_log.rs:1257:45
[INFO] [stdout]      |
[INFO] [stdout] 1257 |         *self_rc.rear_sensor.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout]      |                                             ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1257 -         *self_rc.rear_sensor.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout] 1257 +         *self_rc.rear_sensor.borrow_mut() = _io.read_f4le()?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1257 -         *self_rc.rear_sensor.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout] 1257 +         *self_rc.rear_sensor.borrow_mut() = <f32 as Into<_>>::into(_io.read_f4le()?);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u16`
[INFO] [stdout]    --> src/autel_drone_log.rs:644:47
[INFO] [stdout]     |
[INFO] [stdout] 644 |         *self_rc.right_stick_x.borrow_mut() = _io.read_u2le()?.into();
[INFO] [stdout]     |                                               ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 644 -         *self_rc.right_stick_x.borrow_mut() = _io.read_u2le()?.into();
[INFO] [stdout] 644 +         *self_rc.right_stick_x.borrow_mut() = _io.read_u2le()?;
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 644 -         *self_rc.right_stick_x.borrow_mut() = _io.read_u2le()?.into();
[INFO] [stdout] 644 +         *self_rc.right_stick_x.borrow_mut() = <u16 as Into<_>>::into(_io.read_u2le()?);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u16`
[INFO] [stdout]    --> src/autel_drone_log.rs:645:47
[INFO] [stdout]     |
[INFO] [stdout] 645 |         *self_rc.right_stick_y.borrow_mut() = _io.read_u2le()?.into();
[INFO] [stdout]     |                                               ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 645 -         *self_rc.right_stick_y.borrow_mut() = _io.read_u2le()?.into();
[INFO] [stdout] 645 +         *self_rc.right_stick_y.borrow_mut() = _io.read_u2le()?;
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 645 -         *self_rc.right_stick_y.borrow_mut() = _io.read_u2le()?.into();
[INFO] [stdout] 645 +         *self_rc.right_stick_y.borrow_mut() = <u16 as Into<_>>::into(_io.read_u2le()?);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `f32`
[INFO] [stdout]    --> src/autel_drone_log.rs:718:48
[INFO] [stdout]     |
[INFO] [stdout] 718 |         *self_rc.drone_latitude.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout]     |                                                ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 718 -         *self_rc.drone_latitude.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout] 718 +         *self_rc.drone_latitude.borrow_mut() = _io.read_f4le()?;
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 718 -         *self_rc.drone_latitude.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout] 718 +         *self_rc.drone_latitude.borrow_mut() = <f32 as Into<_>>::into(_io.read_f4le()?);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `f32`
[INFO] [stdout]    --> src/autel_drone_log.rs:719:49
[INFO] [stdout]     |
[INFO] [stdout] 719 |         *self_rc.drone_longitude.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout]     |                                                 ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 719 -         *self_rc.drone_longitude.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout] 719 +         *self_rc.drone_longitude.borrow_mut() = _io.read_f4le()?;
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 719 -         *self_rc.drone_longitude.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout] 719 +         *self_rc.drone_longitude.borrow_mut() = <f32 as Into<_>>::into(_io.read_f4le()?);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `f32`
[INFO] [stdout]    --> src/autel_drone_log.rs:720:48
[INFO] [stdout]     |
[INFO] [stdout] 720 |         *self_rc.drone_altitude.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout]     |                                                ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 720 -         *self_rc.drone_altitude.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout] 720 +         *self_rc.drone_altitude.borrow_mut() = _io.read_f4le()?;
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 720 -         *self_rc.drone_altitude.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout] 720 +         *self_rc.drone_altitude.borrow_mut() = <f32 as Into<_>>::into(_io.read_f4le()?);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `f32`
[INFO] [stdout]    --> src/autel_drone_log.rs:721:47
[INFO] [stdout]     |
[INFO] [stdout] 721 |         *self_rc.drone_x_speed.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout]     |                                               ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 721 -         *self_rc.drone_x_speed.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout] 721 +         *self_rc.drone_x_speed.borrow_mut() = _io.read_f4le()?;
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 721 -         *self_rc.drone_x_speed.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout] 721 +         *self_rc.drone_x_speed.borrow_mut() = <f32 as Into<_>>::into(_io.read_f4le()?);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `f32`
[INFO] [stdout]    --> src/autel_drone_log.rs:722:47
[INFO] [stdout]     |
[INFO] [stdout] 722 |         *self_rc.drone_y_speed.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout]     |                                               ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 722 -         *self_rc.drone_y_speed.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout] 722 +         *self_rc.drone_y_speed.borrow_mut() = _io.read_f4le()?;
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 722 -         *self_rc.drone_y_speed.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout] 722 +         *self_rc.drone_y_speed.borrow_mut() = <f32 as Into<_>>::into(_io.read_f4le()?);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `f32`
[INFO] [stdout]    --> src/autel_drone_log.rs:723:47
[INFO] [stdout]     |
[INFO] [stdout] 723 |         *self_rc.drone_z_speed.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout]     |                                               ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 723 -         *self_rc.drone_z_speed.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout] 723 +         *self_rc.drone_z_speed.borrow_mut() = _io.read_f4le()?;
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 723 -         *self_rc.drone_z_speed.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout] 723 +         *self_rc.drone_z_speed.borrow_mut() = <f32 as Into<_>>::into(_io.read_f4le()?);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `f32`
[INFO] [stdout]    --> src/autel_drone_log.rs:724:46
[INFO] [stdout]     |
[INFO] [stdout] 724 |         *self_rc.gimbal_pitch.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout]     |                                              ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 724 -         *self_rc.gimbal_pitch.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout] 724 +         *self_rc.gimbal_pitch.borrow_mut() = _io.read_f4le()?;
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 724 -         *self_rc.gimbal_pitch.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout] 724 +         *self_rc.gimbal_pitch.borrow_mut() = <f32 as Into<_>>::into(_io.read_f4le()?);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `f32`
[INFO] [stdout]    --> src/autel_drone_log.rs:725:45
[INFO] [stdout]     |
[INFO] [stdout] 725 |         *self_rc.gimbal_roll.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout]     |                                             ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 725 -         *self_rc.gimbal_roll.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout] 725 +         *self_rc.gimbal_roll.borrow_mut() = _io.read_f4le()?;
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 725 -         *self_rc.gimbal_roll.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout] 725 +         *self_rc.gimbal_roll.borrow_mut() = <f32 as Into<_>>::into(_io.read_f4le()?);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `f32`
[INFO] [stdout]    --> src/autel_drone_log.rs:726:44
[INFO] [stdout]     |
[INFO] [stdout] 726 |         *self_rc.gimbal_yaw.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout]     |                                            ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 726 -         *self_rc.gimbal_yaw.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout] 726 +         *self_rc.gimbal_yaw.borrow_mut() = _io.read_f4le()?;
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 726 -         *self_rc.gimbal_yaw.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout] 726 +         *self_rc.gimbal_yaw.borrow_mut() = <f32 as Into<_>>::into(_io.read_f4le()?);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `f32`
[INFO] [stdout]    --> src/autel_drone_log.rs:727:45
[INFO] [stdout]     |
[INFO] [stdout] 727 |         *self_rc.drone_pitch.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout]     |                                             ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 727 -         *self_rc.drone_pitch.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout] 727 +         *self_rc.drone_pitch.borrow_mut() = _io.read_f4le()?;
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 727 -         *self_rc.drone_pitch.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout] 727 +         *self_rc.drone_pitch.borrow_mut() = <f32 as Into<_>>::into(_io.read_f4le()?);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `f32`
[INFO] [stdout]     --> src/autel_drone_log.rs:1258:45
[INFO] [stdout]      |
[INFO] [stdout] 1258 |         *self_rc.left_sensor.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout]      |                                             ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1258 -         *self_rc.left_sensor.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout] 1258 +         *self_rc.left_sensor.borrow_mut() = _io.read_f4le()?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1258 -         *self_rc.left_sensor.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout] 1258 +         *self_rc.left_sensor.borrow_mut() = <f32 as Into<_>>::into(_io.read_f4le()?);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `f32`
[INFO] [stdout]    --> src/autel_drone_log.rs:728:44
[INFO] [stdout]     |
[INFO] [stdout] 728 |         *self_rc.drone_roll.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout]     |                                            ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 728 -         *self_rc.drone_roll.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout] 728 +         *self_rc.drone_roll.borrow_mut() = _io.read_f4le()?;
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 728 -         *self_rc.drone_roll.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout] 728 +         *self_rc.drone_roll.borrow_mut() = <f32 as Into<_>>::into(_io.read_f4le()?);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `f32`
[INFO] [stdout]    --> src/autel_drone_log.rs:729:43
[INFO] [stdout]     |
[INFO] [stdout] 729 |         *self_rc.drone_yaw.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout]     |                                           ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 729 -         *self_rc.drone_yaw.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout] 729 +         *self_rc.drone_yaw.borrow_mut() = _io.read_f4le()?;
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 729 -         *self_rc.drone_yaw.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout] 729 +         *self_rc.drone_yaw.borrow_mut() = <f32 as Into<_>>::into(_io.read_f4le()?);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]    --> src/autel_drone_log.rs:879:49
[INFO] [stdout]     |
[INFO] [stdout] 879 |         *self_rc.mission_time_ms.borrow_mut() = _io.read_u4le()?.into();
[INFO] [stdout]     |                                                 ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 879 -         *self_rc.mission_time_ms.borrow_mut() = _io.read_u4le()?.into();
[INFO] [stdout] 879 +         *self_rc.mission_time_ms.borrow_mut() = _io.read_u4le()?;
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 879 -         *self_rc.mission_time_ms.borrow_mut() = _io.read_u4le()?.into();
[INFO] [stdout] 879 +         *self_rc.mission_time_ms.borrow_mut() = <u32 as Into<_>>::into(_io.read_u4le()?);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `kaitai::OptRc<AutelDroneLog_DroneAttitudeT>`
[INFO] [stdout]    --> src/autel_drone_log.rs:880:17
[INFO] [stdout]     |
[INFO] [stdout] 880 |         let t = Self::read_into::<_, AutelDroneLog_DroneAttitudeT>(&*_io, Some(self_rc._root.clone()), None)?.into();
[INFO] [stdout]     |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 880 -         let t = Self::read_into::<_, AutelDroneLog_DroneAttitudeT>(&*_io, Some(self_rc._root.clone()), None)?.into();
[INFO] [stdout] 880 +         let t = Self::read_into::<_, AutelDroneLog_DroneAttitudeT>(&*_io, Some(self_rc._root.clone()), None)?;
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 880 -         let t = Self::read_into::<_, AutelDroneLog_DroneAttitudeT>(&*_io, Some(self_rc._root.clone()), None)?.into();
[INFO] [stdout] 880 +         let t = <kaitai::OptRc<AutelDroneLog_DroneAttitudeT> as Into<_>>::into(Self::read_into::<_, AutelDroneLog_DroneAttitudeT>(&*_io, Some(self_rc._root.clone()), None)?);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `kaitai::OptRc<AutelDroneLog_ControllerT>`
[INFO] [stdout]    --> src/autel_drone_log.rs:882:17
[INFO] [stdout]     |
[INFO] [stdout] 882 |         let t = Self::read_into::<_, AutelDroneLog_ControllerT>(&*_io, Some(self_rc._root.clone()), None)?.into();
[INFO] [stdout]     |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 882 -         let t = Self::read_into::<_, AutelDroneLog_ControllerT>(&*_io, Some(self_rc._root.clone()), None)?.into();
[INFO] [stdout] 882 +         let t = Self::read_into::<_, AutelDroneLog_ControllerT>(&*_io, Some(self_rc._root.clone()), None)?;
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 882 -         let t = Self::read_into::<_, AutelDroneLog_ControllerT>(&*_io, Some(self_rc._root.clone()), None)?.into();
[INFO] [stdout] 882 +         let t = <kaitai::OptRc<AutelDroneLog_ControllerT> as Into<_>>::into(Self::read_into::<_, AutelDroneLog_ControllerT>(&*_io, Some(self_rc._root.clone()), None)?);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `f32`
[INFO] [stdout]     --> src/autel_drone_log.rs:1259:46
[INFO] [stdout]      |
[INFO] [stdout] 1259 |         *self_rc.right_sensor.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout]      |                                              ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1259 -         *self_rc.right_sensor.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout] 1259 +         *self_rc.right_sensor.borrow_mut() = _io.read_f4le()?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1259 -         *self_rc.right_sensor.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout] 1259 +         *self_rc.right_sensor.borrow_mut() = <f32 as Into<_>>::into(_io.read_f4le()?);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `f32`
[INFO] [stdout]     --> src/autel_drone_log.rs:1260:44
[INFO] [stdout]      |
[INFO] [stdout] 1260 |         *self_rc.top_sensor.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout]      |                                            ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1260 -         *self_rc.top_sensor.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout] 1260 +         *self_rc.top_sensor.borrow_mut() = _io.read_f4le()?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1260 -         *self_rc.top_sensor.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout] 1260 +         *self_rc.top_sensor.borrow_mut() = <f32 as Into<_>>::into(_io.read_f4le()?);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `f32`
[INFO] [stdout]     --> src/autel_drone_log.rs:1261:47
[INFO] [stdout]      |
[INFO] [stdout] 1261 |         *self_rc.bottom_sensor.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout]      |                                               ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1261 -         *self_rc.bottom_sensor.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout] 1261 +         *self_rc.bottom_sensor.borrow_mut() = _io.read_f4le()?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1261 -         *self_rc.bottom_sensor.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout] 1261 +         *self_rc.bottom_sensor.borrow_mut() = <f32 as Into<_>>::into(_io.read_f4le()?);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Vec<u8>`
[INFO] [stdout]     --> src/autel_drone_log.rs:1341:57
[INFO] [stdout]      |
[INFO] [stdout] 1341 |         *self_rc.file_name.borrow_mut() = bytes_to_str(&_io.read_bytes(64 as usize)?.into(), "UTF-8")?;
[INFO] [stdout]      |                                                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1341 -         *self_rc.file_name.borrow_mut() = bytes_to_str(&_io.read_bytes(64 as usize)?.into(), "UTF-8")?;
[INFO] [stdout] 1341 +         *self_rc.file_name.borrow_mut() = bytes_to_str(&_io.read_bytes(64 as usize)?, "UTF-8")?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1341 -         *self_rc.file_name.borrow_mut() = bytes_to_str(&_io.read_bytes(64 as usize)?.into(), "UTF-8")?;
[INFO] [stdout] 1341 +         *self_rc.file_name.borrow_mut() = bytes_to_str(&<Vec<u8> as Into<_>>::into(_io.read_bytes(64 as usize)?), "UTF-8")?;
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u64`
[INFO] [stdout]     --> src/autel_drone_log.rs:1342:43
[INFO] [stdout]      |
[INFO] [stdout] 1342 |         *self_rc.timestamp.borrow_mut() = _io.read_u8le()?.into();
[INFO] [stdout]      |                                           ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1342 -         *self_rc.timestamp.borrow_mut() = _io.read_u8le()?.into();
[INFO] [stdout] 1342 +         *self_rc.timestamp.borrow_mut() = _io.read_u8le()?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1342 -         *self_rc.timestamp.borrow_mut() = _io.read_u8le()?.into();
[INFO] [stdout] 1342 +         *self_rc.timestamp.borrow_mut() = <u64 as Into<_>>::into(_io.read_u8le()?);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `f32`
[INFO] [stdout]     --> src/autel_drone_log.rs:1343:42
[INFO] [stdout]      |
[INFO] [stdout] 1343 |         *self_rc.latitude.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout]      |                                          ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1343 -         *self_rc.latitude.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout] 1343 +         *self_rc.latitude.borrow_mut() = _io.read_f4le()?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1343 -         *self_rc.latitude.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout] 1343 +         *self_rc.latitude.borrow_mut() = <f32 as Into<_>>::into(_io.read_f4le()?);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `f32`
[INFO] [stdout]     --> src/autel_drone_log.rs:1344:43
[INFO] [stdout]      |
[INFO] [stdout] 1344 |         *self_rc.longitude.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout]      |                                           ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1344 -         *self_rc.longitude.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout] 1344 +         *self_rc.longitude.borrow_mut() = _io.read_f4le()?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1344 -         *self_rc.longitude.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout] 1344 +         *self_rc.longitude.borrow_mut() = <f32 as Into<_>>::into(_io.read_f4le()?);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]     --> src/autel_drone_log.rs:1415:49
[INFO] [stdout]      |
[INFO] [stdout] 1415 |         *self_rc.designed_volume.borrow_mut() = _io.read_u4le()?.into();
[INFO] [stdout]      |                                                 ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1415 -         *self_rc.designed_volume.borrow_mut() = _io.read_u4le()?.into();
[INFO] [stdout] 1415 +         *self_rc.designed_volume.borrow_mut() = _io.read_u4le()?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1415 -         *self_rc.designed_volume.borrow_mut() = _io.read_u4le()?.into();
[INFO] [stdout] 1415 +         *self_rc.designed_volume.borrow_mut() = <u32 as Into<_>>::into(_io.read_u4le()?);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]     --> src/autel_drone_log.rs:1416:54
[INFO] [stdout]      |
[INFO] [stdout] 1416 |         *self_rc.maximum_capacity_mah.borrow_mut() = _io.read_u4le()?.into();
[INFO] [stdout]      |                                                      ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1416 -         *self_rc.maximum_capacity_mah.borrow_mut() = _io.read_u4le()?.into();
[INFO] [stdout] 1416 +         *self_rc.maximum_capacity_mah.borrow_mut() = _io.read_u4le()?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1416 -         *self_rc.maximum_capacity_mah.borrow_mut() = _io.read_u4le()?.into();
[INFO] [stdout] 1416 +         *self_rc.maximum_capacity_mah.borrow_mut() = <u32 as Into<_>>::into(_io.read_u4le()?);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `f32`
[INFO] [stdout]     --> src/autel_drone_log.rs:1417:54
[INFO] [stdout]      |
[INFO] [stdout] 1417 |         *self_rc.current_capacity_mah.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout]      |                                                      ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1417 -         *self_rc.current_capacity_mah.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout] 1417 +         *self_rc.current_capacity_mah.borrow_mut() = _io.read_f4le()?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1417 -         *self_rc.current_capacity_mah.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout] 1417 +         *self_rc.current_capacity_mah.borrow_mut() = <f32 as Into<_>>::into(_io.read_f4le()?);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/autel_drone_log.rs:884:41
[INFO] [stdout]     |
[INFO] [stdout] 884 |         *self_rc.rc_mode.borrow_mut() = _io.read_u1()?.into();
[INFO] [stdout]     |                                         ^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 884 -         *self_rc.rc_mode.borrow_mut() = _io.read_u1()?.into();
[INFO] [stdout] 884 +         *self_rc.rc_mode.borrow_mut() = _io.read_u1()?;
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 884 -         *self_rc.rc_mode.borrow_mut() = _io.read_u1()?.into();
[INFO] [stdout] 884 +         *self_rc.rc_mode.borrow_mut() = <u8 as Into<_>>::into(_io.read_u1()?);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]    --> src/autel_drone_log.rs:885:50
[INFO] [stdout]     |
[INFO] [stdout] 885 |         *self_rc.offline_duration.borrow_mut() = _io.read_u4le()?.into();
[INFO] [stdout]     |                                                  ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 885 -         *self_rc.offline_duration.borrow_mut() = _io.read_u4le()?.into();
[INFO] [stdout] 885 +         *self_rc.offline_duration.borrow_mut() = _io.read_u4le()?;
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 885 -         *self_rc.offline_duration.borrow_mut() = _io.read_u4le()?.into();
[INFO] [stdout] 885 +         *self_rc.offline_duration.borrow_mut() = <u32 as Into<_>>::into(_io.read_u4le()?);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `f32`
[INFO] [stdout]     --> src/autel_drone_log.rs:1418:44
[INFO] [stdout]      |
[INFO] [stdout] 1418 |         *self_rc.voltage_mv.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout]      |                                            ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1418 -         *self_rc.voltage_mv.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout] 1418 +         *self_rc.voltage_mv.borrow_mut() = _io.read_f4le()?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1418 -         *self_rc.voltage_mv.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout] 1418 +         *self_rc.voltage_mv.borrow_mut() = <f32 as Into<_>>::into(_io.read_f4le()?);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]    --> src/autel_drone_log.rs:886:44
[INFO] [stdout]     |
[INFO] [stdout] 886 |         *self_rc.rc_buttons.borrow_mut() = _io.read_u1()?.into();
[INFO] [stdout]     |                                            ^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 886 -         *self_rc.rc_buttons.borrow_mut() = _io.read_u1()?.into();
[INFO] [stdout] 886 +         *self_rc.rc_buttons.borrow_mut() = _io.read_u1()?;
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 886 -         *self_rc.rc_buttons.borrow_mut() = _io.read_u1()?.into();
[INFO] [stdout] 886 +         *self_rc.rc_buttons.borrow_mut() = <u8 as Into<_>>::into(_io.read_u1()?);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `f64`
[INFO] [stdout]    --> src/autel_drone_log.rs:887:52
[INFO] [stdout]     |
[INFO] [stdout] 887 |         *self_rc.controller_heading.borrow_mut() = _io.read_f8le()?.into();
[INFO] [stdout]     |                                                    ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 887 -         *self_rc.controller_heading.borrow_mut() = _io.read_f8le()?.into();
[INFO] [stdout] 887 +         *self_rc.controller_heading.borrow_mut() = _io.read_f8le()?;
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 887 -         *self_rc.controller_heading.borrow_mut() = _io.read_f8le()?.into();
[INFO] [stdout] 887 +         *self_rc.controller_heading.borrow_mut() = <f64 as Into<_>>::into(_io.read_f8le()?);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `f32`
[INFO] [stdout]     --> src/autel_drone_log.rs:1419:46
[INFO] [stdout]      |
[INFO] [stdout] 1419 |         *self_rc.current_draw.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout]      |                                              ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1419 -         *self_rc.current_draw.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout] 1419 +         *self_rc.current_draw.borrow_mut() = _io.read_f4le()?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1419 -         *self_rc.current_draw.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout] 1419 +         *self_rc.current_draw.borrow_mut() = <f32 as Into<_>>::into(_io.read_f4le()?);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `kaitai::OptRc<AutelDroneLog_OaSensorT>`
[INFO] [stdout]    --> src/autel_drone_log.rs:888:17
[INFO] [stdout]     |
[INFO] [stdout] 888 |         let t = Self::read_into::<_, AutelDroneLog_OaSensorT>(&*_io, Some(self_rc._root.clone()), None)?.into();
[INFO] [stdout]     |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 888 -         let t = Self::read_into::<_, AutelDroneLog_OaSensorT>(&*_io, Some(self_rc._root.clone()), None)?.into();
[INFO] [stdout] 888 +         let t = Self::read_into::<_, AutelDroneLog_OaSensorT>(&*_io, Some(self_rc._root.clone()), None)?;
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 888 -         let t = Self::read_into::<_, AutelDroneLog_OaSensorT>(&*_io, Some(self_rc._root.clone()), None)?.into();
[INFO] [stdout] 888 +         let t = <kaitai::OptRc<AutelDroneLog_OaSensorT> as Into<_>>::into(Self::read_into::<_, AutelDroneLog_OaSensorT>(&*_io, Some(self_rc._root.clone()), None)?);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `kaitai::OptRc<AutelDroneLog_ConfigurationT>`
[INFO] [stdout]    --> src/autel_drone_log.rs:890:17
[INFO] [stdout]     |
[INFO] [stdout] 890 | ... = Self::read_into::<_, AutelDroneLog_ConfigurationT>(&*_io, Some(self_rc._root.clone()), Some(self_rc._self.clone()))?.into();
[INFO] [stdout]     |       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 890 -         let t = Self::read_into::<_, AutelDroneLog_ConfigurationT>(&*_io, Some(self_rc._root.clone()), Some(self_rc._self.clone()))?.into();
[INFO] [stdout] 890 +         let t = Self::read_into::<_, AutelDroneLog_ConfigurationT>(&*_io, Some(self_rc._root.clone()), Some(self_rc._self.clone()))?;
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 890 -         let t = Self::read_into::<_, AutelDroneLog_ConfigurationT>(&*_io, Some(self_rc._root.clone()), Some(self_rc._self.clone()))?.into();
[INFO] [stdout] 890 +         let t = <kaitai::OptRc<AutelDroneLog_ConfigurationT> as Into<_>>::into(Self::read_into::<_, AutelDroneLog_ConfigurationT>(&*_io, Some(self_rc._root.clone()), Some(self_rc._self.clone()))?);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]    --> src/autel_drone_log.rs:892:40
[INFO] [stdout]     |
[INFO] [stdout] 892 |         *self_rc.param1.borrow_mut() = _io.read_u4le()?.into();
[INFO] [stdout]     |                                        ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 892 -         *self_rc.param1.borrow_mut() = _io.read_u4le()?.into();
[INFO] [stdout] 892 +         *self_rc.param1.borrow_mut() = _io.read_u4le()?;
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 892 -         *self_rc.param1.borrow_mut() = _io.read_u4le()?.into();
[INFO] [stdout] 892 +         *self_rc.param1.borrow_mut() = <u32 as Into<_>>::into(_io.read_u4le()?);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]     --> src/autel_drone_log.rs:1420:53
[INFO] [stdout]      |
[INFO] [stdout] 1420 |         *self_rc.remaining_charge_pc.borrow_mut() = _io.read_u1()?.into();
[INFO] [stdout]      |                                                     ^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1420 -         *self_rc.remaining_charge_pc.borrow_mut() = _io.read_u1()?.into();
[INFO] [stdout] 1420 +         *self_rc.remaining_charge_pc.borrow_mut() = _io.read_u1()?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1420 -         *self_rc.remaining_charge_pc.borrow_mut() = _io.read_u1()?.into();
[INFO] [stdout] 1420 +         *self_rc.remaining_charge_pc.borrow_mut() = <u8 as Into<_>>::into(_io.read_u1()?);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]    --> src/autel_drone_log.rs:893:40
[INFO] [stdout]     |
[INFO] [stdout] 893 |         *self_rc.param2.borrow_mut() = _io.read_u4le()?.into();
[INFO] [stdout]     |                                        ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 893 -         *self_rc.param2.borrow_mut() = _io.read_u4le()?.into();
[INFO] [stdout] 893 +         *self_rc.param2.borrow_mut() = _io.read_u4le()?;
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 893 -         *self_rc.param2.borrow_mut() = _io.read_u4le()?.into();
[INFO] [stdout] 893 +         *self_rc.param2.borrow_mut() = <u32 as Into<_>>::into(_io.read_u4le()?);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]    --> src/autel_drone_log.rs:894:40
[INFO] [stdout]     |
[INFO] [stdout] 894 |         *self_rc.param3.borrow_mut() = _io.read_u4le()?.into();
[INFO] [stdout]     |                                        ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 894 -         *self_rc.param3.borrow_mut() = _io.read_u4le()?.into();
[INFO] [stdout] 894 +         *self_rc.param3.borrow_mut() = _io.read_u4le()?;
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 894 -         *self_rc.param3.borrow_mut() = _io.read_u4le()?.into();
[INFO] [stdout] 894 +         *self_rc.param3.borrow_mut() = <u32 as Into<_>>::into(_io.read_u4le()?);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]    --> src/autel_drone_log.rs:895:40
[INFO] [stdout]     |
[INFO] [stdout] 895 |         *self_rc.param4.borrow_mut() = _io.read_u4le()?.into();
[INFO] [stdout]     |                                        ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 895 -         *self_rc.param4.borrow_mut() = _io.read_u4le()?.into();
[INFO] [stdout] 895 +         *self_rc.param4.borrow_mut() = _io.read_u4le()?;
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 895 -         *self_rc.param4.borrow_mut() = _io.read_u4le()?.into();
[INFO] [stdout] 895 +         *self_rc.param4.borrow_mut() = <u32 as Into<_>>::into(_io.read_u4le()?);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `f32`
[INFO] [stdout]     --> src/autel_drone_log.rs:1421:59
[INFO] [stdout]      |
[INFO] [stdout] 1421 |         *self_rc.battery_temperature_deg_c.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout]      |                                                           ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1421 -         *self_rc.battery_temperature_deg_c.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout] 1421 +         *self_rc.battery_temperature_deg_c.borrow_mut() = _io.read_f4le()?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1421 -         *self_rc.battery_temperature_deg_c.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout] 1421 +         *self_rc.battery_temperature_deg_c.borrow_mut() = <f32 as Into<_>>::into(_io.read_f4le()?);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]    --> src/autel_drone_log.rs:896:40
[INFO] [stdout]     |
[INFO] [stdout] 896 |         *self_rc.param5.borrow_mut() = _io.read_u4le()?.into();
[INFO] [stdout]     |                                        ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 896 -         *self_rc.param5.borrow_mut() = _io.read_u4le()?.into();
[INFO] [stdout] 896 +         *self_rc.param5.borrow_mut() = _io.read_u4le()?;
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 896 -         *self_rc.param5.borrow_mut() = _io.read_u4le()?.into();
[INFO] [stdout] 896 +         *self_rc.param5.borrow_mut() = <u32 as Into<_>>::into(_io.read_u4le()?);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]     --> src/autel_drone_log.rs:1423:57
[INFO] [stdout]      |
[INFO] [stdout] 1423 |         *self_rc.battery_discharge_count.borrow_mut() = _io.read_u4le()?.into();
[INFO] [stdout]      |                                                         ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1423 -         *self_rc.battery_discharge_count.borrow_mut() = _io.read_u4le()?.into();
[INFO] [stdout] 1423 +         *self_rc.battery_discharge_count.borrow_mut() = _io.read_u4le()?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1423 -         *self_rc.battery_discharge_count.borrow_mut() = _io.read_u4le()?.into();
[INFO] [stdout] 1423 +         *self_rc.battery_discharge_count.borrow_mut() = <u32 as Into<_>>::into(_io.read_u4le()?);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]     --> src/autel_drone_log.rs:1424:44
[INFO] [stdout]      |
[INFO] [stdout] 1424 |         *self_rc.cell_count.borrow_mut() = _io.read_u1()?.into();
[INFO] [stdout]      |                                            ^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1424 -         *self_rc.cell_count.borrow_mut() = _io.read_u1()?.into();
[INFO] [stdout] 1424 +         *self_rc.cell_count.borrow_mut() = _io.read_u1()?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1424 -         *self_rc.cell_count.borrow_mut() = _io.read_u1()?.into();
[INFO] [stdout] 1424 +         *self_rc.cell_count.borrow_mut() = <u8 as Into<_>>::into(_io.read_u1()?);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `f32`
[INFO] [stdout]     --> src/autel_drone_log.rs:1428:52
[INFO] [stdout]      |
[INFO] [stdout] 1428 |             self_rc.cell_voltage.borrow_mut().push(_io.read_f4le()?.into());
[INFO] [stdout]      |                                                    ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1428 -             self_rc.cell_voltage.borrow_mut().push(_io.read_f4le()?.into());
[INFO] [stdout] 1428 +             self_rc.cell_voltage.borrow_mut().push(_io.read_f4le()?);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1428 -             self_rc.cell_voltage.borrow_mut().push(_io.read_f4le()?.into());
[INFO] [stdout] 1428 +             self_rc.cell_voltage.borrow_mut().push(<f32 as Into<_>>::into(_io.read_f4le()?));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u16`
[INFO] [stdout]     --> src/autel_drone_log.rs:1055:45
[INFO] [stdout]      |
[INFO] [stdout] 1055 |         *self_rc.header_size.borrow_mut() = _io.read_u2le()?.into();
[INFO] [stdout]      |                                             ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1055 -         *self_rc.header_size.borrow_mut() = _io.read_u2le()?.into();
[INFO] [stdout] 1055 +         *self_rc.header_size.borrow_mut() = _io.read_u2le()?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1055 -         *self_rc.header_size.borrow_mut() = _io.read_u2le()?.into();
[INFO] [stdout] 1055 +         *self_rc.header_size.borrow_mut() = <u16 as Into<_>>::into(_io.read_u2le()?);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]     --> src/autel_drone_log.rs:1595:45
[INFO] [stdout]      |
[INFO] [stdout] 1595 |         *self_rc.record_type.borrow_mut() = _io.read_u1()?.into();
[INFO] [stdout]      |                                             ^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1595 -         *self_rc.record_type.borrow_mut() = _io.read_u1()?.into();
[INFO] [stdout] 1595 +         *self_rc.record_type.borrow_mut() = _io.read_u1()?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1595 -         *self_rc.record_type.borrow_mut() = _io.read_u1()?.into();
[INFO] [stdout] 1595 +         *self_rc.record_type.borrow_mut() = <u8 as Into<_>>::into(_io.read_u1()?);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]     --> src/autel_drone_log.rs:1684:52
[INFO] [stdout]      |
[INFO] [stdout] 1684 |         *self_rc.oa_warning_enabled.borrow_mut() = _io.read_u4le()?.into();
[INFO] [stdout]      |                                                    ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1684 -         *self_rc.oa_warning_enabled.borrow_mut() = _io.read_u4le()?.into();
[INFO] [stdout] 1684 +         *self_rc.oa_warning_enabled.borrow_mut() = _io.read_u4le()?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1684 -         *self_rc.oa_warning_enabled.borrow_mut() = _io.read_u4le()?.into();
[INFO] [stdout] 1684 +         *self_rc.oa_warning_enabled.borrow_mut() = <u32 as Into<_>>::into(_io.read_u4le()?);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Vec<u8>`
[INFO] [stdout]     --> src/autel_drone_log.rs:1056:60
[INFO] [stdout]      |
[INFO] [stdout] 1056 |         *self_rc.drone_serial.borrow_mut() = bytes_to_str(&_io.read_bytes(18 as usize)?.into(), "UTF-8")?;
[INFO] [stdout]      |                                                            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1056 -         *self_rc.drone_serial.borrow_mut() = bytes_to_str(&_io.read_bytes(18 as usize)?.into(), "UTF-8")?;
[INFO] [stdout] 1056 +         *self_rc.drone_serial.borrow_mut() = bytes_to_str(&_io.read_bytes(18 as usize)?, "UTF-8")?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1056 -         *self_rc.drone_serial.borrow_mut() = bytes_to_str(&_io.read_bytes(18 as usize)?.into(), "UTF-8")?;
[INFO] [stdout] 1056 +         *self_rc.drone_serial.borrow_mut() = bytes_to_str(&<Vec<u8> as Into<_>>::into(_io.read_bytes(18 as usize)?), "UTF-8")?;
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]     --> src/autel_drone_log.rs:1685:56
[INFO] [stdout]      |
[INFO] [stdout] 1685 |         *self_rc.oa_ext_warning_enabled.borrow_mut() = _io.read_u4le()?.into();
[INFO] [stdout]      |                                                        ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1685 -         *self_rc.oa_ext_warning_enabled.borrow_mut() = _io.read_u4le()?.into();
[INFO] [stdout] 1685 +         *self_rc.oa_ext_warning_enabled.borrow_mut() = _io.read_u4le()?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1685 -         *self_rc.oa_ext_warning_enabled.borrow_mut() = _io.read_u4le()?.into();
[INFO] [stdout] 1685 +         *self_rc.oa_ext_warning_enabled.borrow_mut() = <u32 as Into<_>>::into(_io.read_u4le()?);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Vec<u8>`
[INFO] [stdout]     --> src/autel_drone_log.rs:1057:62
[INFO] [stdout]      |
[INFO] [stdout] 1057 |         *self_rc.battery_serial.borrow_mut() = bytes_to_str(&_io.read_bytes(32 as usize)?.into(), "UTF-8")?;
[INFO] [stdout]      |                                                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1057 -         *self_rc.battery_serial.borrow_mut() = bytes_to_str(&_io.read_bytes(32 as usize)?.into(), "UTF-8")?;
[INFO] [stdout] 1057 +         *self_rc.battery_serial.borrow_mut() = bytes_to_str(&_io.read_bytes(32 as usize)?, "UTF-8")?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1057 -         *self_rc.battery_serial.borrow_mut() = bytes_to_str(&_io.read_bytes(32 as usize)?.into(), "UTF-8")?;
[INFO] [stdout] 1057 +         *self_rc.battery_serial.borrow_mut() = bytes_to_str(&<Vec<u8> as Into<_>>::into(_io.read_bytes(32 as usize)?), "UTF-8")?;
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]     --> src/autel_drone_log.rs:1686:47
[INFO] [stdout]      |
[INFO] [stdout] 1686 |         *self_rc.oa_error_code.borrow_mut() = _io.read_u4le()?.into();
[INFO] [stdout]      |                                               ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1686 -         *self_rc.oa_error_code.borrow_mut() = _io.read_u4le()?.into();
[INFO] [stdout] 1686 +         *self_rc.oa_error_code.borrow_mut() = _io.read_u4le()?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1686 -         *self_rc.oa_error_code.borrow_mut() = _io.read_u4le()?.into();
[INFO] [stdout] 1686 +         *self_rc.oa_error_code.borrow_mut() = <u32 as Into<_>>::into(_io.read_u4le()?);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Vec<u8>`
[INFO] [stdout]     --> src/autel_drone_log.rs:1058:56
[INFO] [stdout]      |
[INFO] [stdout] 1058 |         *self_rc.location.borrow_mut() = bytes_to_str(&_io.read_bytes(64 as usize)?.into(), "UTF-8")?;
[INFO] [stdout]      |                                                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1058 -         *self_rc.location.borrow_mut() = bytes_to_str(&_io.read_bytes(64 as usize)?.into(), "UTF-8")?;
[INFO] [stdout] 1058 +         *self_rc.location.borrow_mut() = bytes_to_str(&_io.read_bytes(64 as usize)?, "UTF-8")?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1058 -         *self_rc.location.borrow_mut() = bytes_to_str(&_io.read_bytes(64 as usize)?.into(), "UTF-8")?;
[INFO] [stdout] 1058 +         *self_rc.location.borrow_mut() = bytes_to_str(&<Vec<u8> as Into<_>>::into(_io.read_bytes(64 as usize)?), "UTF-8")?;
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `f32`
[INFO] [stdout]     --> src/autel_drone_log.rs:1687:48
[INFO] [stdout]      |
[INFO] [stdout] 1687 |         *self_rc.max_altitude_m.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout]      |                                                ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1687 -         *self_rc.max_altitude_m.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout] 1687 +         *self_rc.max_altitude_m.borrow_mut() = _io.read_f4le()?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1687 -         *self_rc.max_altitude_m.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout] 1687 +         *self_rc.max_altitude_m.borrow_mut() = <f32 as Into<_>>::into(_io.read_f4le()?);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]     --> src/autel_drone_log.rs:1059:44
[INFO] [stdout]      |
[INFO] [stdout] 1059 |         *self_rc.drone_type.borrow_mut() = _io.read_u1()?.into();
[INFO] [stdout]      |                                            ^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1059 -         *self_rc.drone_type.borrow_mut() = _io.read_u1()?.into();
[INFO] [stdout] 1059 +         *self_rc.drone_type.borrow_mut() = _io.read_u1()?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1059 -         *self_rc.drone_type.borrow_mut() = _io.read_u1()?.into();
[INFO] [stdout] 1059 +         *self_rc.drone_type.borrow_mut() = <u8 as Into<_>>::into(_io.read_u1()?);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `f32`
[INFO] [stdout]     --> src/autel_drone_log.rs:1688:59
[INFO] [stdout]      |
[INFO] [stdout] 1688 |         *self_rc.return_to_home_altitude_m.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout]      |                                                           ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1688 -         *self_rc.return_to_home_altitude_m.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout] 1688 +         *self_rc.return_to_home_altitude_m.borrow_mut() = _io.read_f4le()?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1688 -         *self_rc.return_to_home_altitude_m.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout] 1688 +         *self_rc.return_to_home_altitude_m.borrow_mut() = <f32 as Into<_>>::into(_io.read_f4le()?);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]     --> src/autel_drone_log.rs:1689:55
[INFO] [stdout]      |
[INFO] [stdout] 1689 |         *self_rc.beginner_mode_enabled.borrow_mut() = _io.read_u1()?.into();
[INFO] [stdout]      |                                                       ^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1689 -         *self_rc.beginner_mode_enabled.borrow_mut() = _io.read_u1()?.into();
[INFO] [stdout] 1689 +         *self_rc.beginner_mode_enabled.borrow_mut() = _io.read_u1()?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1689 -         *self_rc.beginner_mode_enabled.borrow_mut() = _io.read_u1()?.into();
[INFO] [stdout] 1689 +         *self_rc.beginner_mode_enabled.borrow_mut() = <u8 as Into<_>>::into(_io.read_u1()?);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `f32`
[INFO] [stdout]     --> src/autel_drone_log.rs:1060:42
[INFO] [stdout]      |
[INFO] [stdout] 1060 |         *self_rc.distance.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout]      |                                          ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1060 -         *self_rc.distance.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout] 1060 +         *self_rc.distance.borrow_mut() = _io.read_f4le()?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1060 -         *self_rc.distance.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout] 1060 +         *self_rc.distance.borrow_mut() = <f32 as Into<_>>::into(_io.read_f4le()?);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]     --> src/autel_drone_log.rs:1061:51
[INFO] [stdout]      |
[INFO] [stdout] 1061 |         *self_rc.flight_duration_s.borrow_mut() = _io.read_u4le()?.into();
[INFO] [stdout]      |                                                   ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1061 -         *self_rc.flight_duration_s.borrow_mut() = _io.read_u4le()?.into();
[INFO] [stdout] 1061 +         *self_rc.flight_duration_s.borrow_mut() = _io.read_u4le()?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1061 -         *self_rc.flight_duration_s.borrow_mut() = _io.read_u4le()?.into();
[INFO] [stdout] 1061 +         *self_rc.flight_duration_s.borrow_mut() = <u32 as Into<_>>::into(_io.read_u4le()?);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `f32`
[INFO] [stdout]     --> src/autel_drone_log.rs:1062:46
[INFO] [stdout]      |
[INFO] [stdout] 1062 |         *self_rc.max_altitude.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout]      |                                              ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1062 -         *self_rc.max_altitude.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout] 1062 +         *self_rc.max_altitude.borrow_mut() = _io.read_f4le()?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1062 -         *self_rc.max_altitude.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout] 1062 +         *self_rc.max_altitude.borrow_mut() = <f32 as Into<_>>::into(_io.read_f4le()?);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]     --> src/autel_drone_log.rs:1063:48
[INFO] [stdout]      |
[INFO] [stdout] 1063 |         *self_rc.video_duration.borrow_mut() = _io.read_u4le()?.into();
[INFO] [stdout]      |                                                ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1063 -         *self_rc.video_duration.borrow_mut() = _io.read_u4le()?.into();
[INFO] [stdout] 1063 +         *self_rc.video_duration.borrow_mut() = _io.read_u4le()?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1063 -         *self_rc.video_duration.borrow_mut() = _io.read_u4le()?.into();
[INFO] [stdout] 1063 +         *self_rc.video_duration.borrow_mut() = <u32 as Into<_>>::into(_io.read_u4le()?);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]     --> src/autel_drone_log.rs:1690:63
[INFO] [stdout]      |
[INFO] [stdout] 1690 |         *self_rc.low_battery_threshold_enabled.borrow_mut() = _io.read_u1()?.into();
[INFO] [stdout]      |                                                               ^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1690 -         *self_rc.low_battery_threshold_enabled.borrow_mut() = _io.read_u1()?.into();
[INFO] [stdout] 1690 +         *self_rc.low_battery_threshold_enabled.borrow_mut() = _io.read_u1()?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1690 -         *self_rc.low_battery_threshold_enabled.borrow_mut() = _io.read_u1()?.into();
[INFO] [stdout] 1690 +         *self_rc.low_battery_threshold_enabled.borrow_mut() = <u8 as Into<_>>::into(_io.read_u1()?);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u64`
[INFO] [stdout]     --> src/autel_drone_log.rs:1064:47
[INFO] [stdout]      |
[INFO] [stdout] 1064 |         *self_rc.start_time_ms.borrow_mut() = _io.read_u8le()?.into();
[INFO] [stdout]      |                                               ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1064 -         *self_rc.start_time_ms.borrow_mut() = _io.read_u8le()?.into();
[INFO] [stdout] 1064 +         *self_rc.start_time_ms.borrow_mut() = _io.read_u8le()?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1064 -         *self_rc.start_time_ms.borrow_mut() = _io.read_u8le()?.into();
[INFO] [stdout] 1064 +         *self_rc.start_time_ms.borrow_mut() = <u64 as Into<_>>::into(_io.read_u8le()?);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]     --> src/autel_drone_log.rs:1691:68
[INFO] [stdout]      |
[INFO] [stdout] 1691 |         *self_rc.critical_battery_threshold_enabled.borrow_mut() = _io.read_u1()?.into();
[INFO] [stdout]      |                                                                    ^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1691 -         *self_rc.critical_battery_threshold_enabled.borrow_mut() = _io.read_u1()?.into();
[INFO] [stdout] 1691 +         *self_rc.critical_battery_threshold_enabled.borrow_mut() = _io.read_u1()?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1691 -         *self_rc.critical_battery_threshold_enabled.borrow_mut() = _io.read_u1()?.into();
[INFO] [stdout] 1691 +         *self_rc.critical_battery_threshold_enabled.borrow_mut() = <u8 as Into<_>>::into(_io.read_u1()?);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `f32`
[INFO] [stdout]     --> src/autel_drone_log.rs:1692:55
[INFO] [stdout]      |
[INFO] [stdout] 1692 |         *self_rc.max_flight_distance_m.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout]      |                                                       ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1692 -         *self_rc.max_flight_distance_m.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout] 1692 +         *self_rc.max_flight_distance_m.borrow_mut() = _io.read_f4le()?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1692 -         *self_rc.max_flight_distance_m.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout] 1692 +         *self_rc.max_flight_distance_m.borrow_mut() = <f32 as Into<_>>::into(_io.read_f4le()?);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `f32`
[INFO] [stdout]     --> src/autel_drone_log.rs:1693:54
[INFO] [stdout]      |
[INFO] [stdout] 1693 |         *self_rc.max_horizontal_speed.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout]      |                                                      ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1693 -         *self_rc.max_horizontal_speed.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout] 1693 +         *self_rc.max_horizontal_speed.borrow_mut() = _io.read_f4le()?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1693 -         *self_rc.max_horizontal_speed.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout] 1693 +         *self_rc.max_horizontal_speed.borrow_mut() = <f32 as Into<_>>::into(_io.read_f4le()?);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]     --> src/autel_drone_log.rs:1065:42
[INFO] [stdout]      |
[INFO] [stdout] 1065 |         *self_rc.timezone.borrow_mut() = _io.read_u4le()?.into();
[INFO] [stdout]      |                                          ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1065 -         *self_rc.timezone.borrow_mut() = _io.read_u4le()?.into();
[INFO] [stdout] 1065 +         *self_rc.timezone.borrow_mut() = _io.read_u4le()?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1065 -         *self_rc.timezone.borrow_mut() = _io.read_u4le()?.into();
[INFO] [stdout] 1065 +         *self_rc.timezone.borrow_mut() = <u32 as Into<_>>::into(_io.read_u4le()?);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]     --> src/autel_drone_log.rs:1694:44
[INFO] [stdout]      |
[INFO] [stdout] 1694 |         *self_rc.oa_enabled.borrow_mut() = _io.read_u1()?.into();
[INFO] [stdout]      |                                            ^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1694 -         *self_rc.oa_enabled.borrow_mut() = _io.read_u1()?.into();
[INFO] [stdout] 1694 +         *self_rc.oa_enabled.borrow_mut() = _io.read_u1()?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1694 -         *self_rc.oa_enabled.borrow_mut() = _io.read_u1()?.into();
[INFO] [stdout] 1694 +         *self_rc.oa_enabled.borrow_mut() = <u8 as Into<_>>::into(_io.read_u1()?);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]     --> src/autel_drone_log.rs:1695:47
[INFO] [stdout]      |
[INFO] [stdout] 1695 |         *self_rc.radar_enabled.borrow_mut() = _io.read_u1()?.into();
[INFO] [stdout]      |                                               ^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1695 -         *self_rc.radar_enabled.borrow_mut() = _io.read_u1()?.into();
[INFO] [stdout] 1695 +         *self_rc.radar_enabled.borrow_mut() = _io.read_u1()?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1695 -         *self_rc.radar_enabled.borrow_mut() = _io.read_u1()?.into();
[INFO] [stdout] 1695 +         *self_rc.radar_enabled.borrow_mut() = <u8 as Into<_>>::into(_io.read_u1()?);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]     --> src/autel_drone_log.rs:1696:43
[INFO] [stdout]      |
[INFO] [stdout] 1696 |         *self_rc.max_error.borrow_mut() = _io.read_u4le()?.into();
[INFO] [stdout]      |                                           ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1696 -         *self_rc.max_error.borrow_mut() = _io.read_u4le()?.into();
[INFO] [stdout] 1696 +         *self_rc.max_error.borrow_mut() = _io.read_u4le()?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1696 -         *self_rc.max_error.borrow_mut() = _io.read_u4le()?.into();
[INFO] [stdout] 1696 +         *self_rc.max_error.borrow_mut() = <u32 as Into<_>>::into(_io.read_u4le()?);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `f32`
[INFO] [stdout]     --> src/autel_drone_log.rs:1066:48
[INFO] [stdout]      |
[INFO] [stdout] 1066 |         *self_rc.start_latitude.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout]      |                                                ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1066 -         *self_rc.start_latitude.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout] 1066 +         *self_rc.start_latitude.borrow_mut() = _io.read_f4le()?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1066 -         *self_rc.start_latitude.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout] 1066 +         *self_rc.start_latitude.borrow_mut() = <f32 as Into<_>>::into(_io.read_f4le()?);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `f32`
[INFO] [stdout]     --> src/autel_drone_log.rs:1067:49
[INFO] [stdout]      |
[INFO] [stdout] 1067 |         *self_rc.start_longitude.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout]      |                                                 ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1067 -         *self_rc.start_longitude.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout] 1067 +         *self_rc.start_longitude.borrow_mut() = _io.read_f4le()?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1067 -         *self_rc.start_longitude.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout] 1067 +         *self_rc.start_longitude.borrow_mut() = <f32 as Into<_>>::into(_io.read_f4le()?);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Vec<u8>`
[INFO] [stdout]     --> src/autel_drone_log.rs:1806:57
[INFO] [stdout]      |
[INFO] [stdout] 1806 |         *self_rc.file_name.borrow_mut() = bytes_to_str(&_io.read_bytes(64 as usize)?.into(), "UTF-8")?;
[INFO] [stdout]      |                                                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1806 -         *self_rc.file_name.borrow_mut() = bytes_to_str(&_io.read_bytes(64 as usize)?.into(), "UTF-8")?;
[INFO] [stdout] 1806 +         *self_rc.file_name.borrow_mut() = bytes_to_str(&_io.read_bytes(64 as usize)?, "UTF-8")?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1806 -         *self_rc.file_name.borrow_mut() = bytes_to_str(&_io.read_bytes(64 as usize)?.into(), "UTF-8")?;
[INFO] [stdout] 1806 +         *self_rc.file_name.borrow_mut() = bytes_to_str(&<Vec<u8> as Into<_>>::into(_io.read_bytes(64 as usize)?), "UTF-8")?;
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u16`
[INFO] [stdout]     --> src/autel_drone_log.rs:1068:45
[INFO] [stdout]      |
[INFO] [stdout] 1068 |         *self_rc.image_count.borrow_mut() = _io.read_u2le()?.into();
[INFO] [stdout]      |                                             ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1068 -         *self_rc.image_count.borrow_mut() = _io.read_u2le()?.into();
[INFO] [stdout] 1068 +         *self_rc.image_count.borrow_mut() = _io.read_u2le()?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1068 -         *self_rc.image_count.borrow_mut() = _io.read_u2le()?.into();
[INFO] [stdout] 1068 +         *self_rc.image_count.borrow_mut() = <u16 as Into<_>>::into(_io.read_u2le()?);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u64`
[INFO] [stdout]     --> src/autel_drone_log.rs:1807:43
[INFO] [stdout]      |
[INFO] [stdout] 1807 |         *self_rc.timestamp.borrow_mut() = _io.read_u8le()?.into();
[INFO] [stdout]      |                                           ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1807 -         *self_rc.timestamp.borrow_mut() = _io.read_u8le()?.into();
[INFO] [stdout] 1807 +         *self_rc.timestamp.borrow_mut() = _io.read_u8le()?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1807 -         *self_rc.timestamp.borrow_mut() = _io.read_u8le()?.into();
[INFO] [stdout] 1807 +         *self_rc.timestamp.borrow_mut() = <u64 as Into<_>>::into(_io.read_u8le()?);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u16`
[INFO] [stdout]     --> src/autel_drone_log.rs:1069:45
[INFO] [stdout]      |
[INFO] [stdout] 1069 |         *self_rc.video_count.borrow_mut() = _io.read_u2le()?.into();
[INFO] [stdout]      |                                             ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1069 -         *self_rc.video_count.borrow_mut() = _io.read_u2le()?.into();
[INFO] [stdout] 1069 +         *self_rc.video_count.borrow_mut() = _io.read_u2le()?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1069 -         *self_rc.video_count.borrow_mut() = _io.read_u2le()?.into();
[INFO] [stdout] 1069 +         *self_rc.video_count.borrow_mut() = <u16 as Into<_>>::into(_io.read_u2le()?);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u16`
[INFO] [stdout]     --> src/autel_drone_log.rs:1070:49
[INFO] [stdout]      |
[INFO] [stdout] 1070 |         *self_rc.firmware_length.borrow_mut() = _io.read_u2le()?.into();
[INFO] [stdout]      |                                                 ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1070 -         *self_rc.firmware_length.borrow_mut() = _io.read_u2le()?.into();
[INFO] [stdout] 1070 +         *self_rc.firmware_length.borrow_mut() = _io.read_u2le()?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1070 -         *self_rc.firmware_length.borrow_mut() = _io.read_u2le()?.into();
[INFO] [stdout] 1070 +         *self_rc.firmware_length.borrow_mut() = <u16 as Into<_>>::into(_io.read_u2le()?);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `f32`
[INFO] [stdout]     --> src/autel_drone_log.rs:1808:42
[INFO] [stdout]      |
[INFO] [stdout] 1808 |         *self_rc.latitude.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout]      |                                          ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1808 -         *self_rc.latitude.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout] 1808 +         *self_rc.latitude.borrow_mut() = _io.read_f4le()?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1808 -         *self_rc.latitude.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout] 1808 +         *self_rc.latitude.borrow_mut() = <f32 as Into<_>>::into(_io.read_f4le()?);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `f32`
[INFO] [stdout]     --> src/autel_drone_log.rs:1809:43
[INFO] [stdout]      |
[INFO] [stdout] 1809 |         *self_rc.longitude.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout]      |                                           ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1809 -         *self_rc.longitude.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout] 1809 +         *self_rc.longitude.borrow_mut() = _io.read_f4le()?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1809 -         *self_rc.longitude.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout] 1809 +         *self_rc.longitude.borrow_mut() = <f32 as Into<_>>::into(_io.read_f4le()?);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]     --> src/autel_drone_log.rs:1810:44
[INFO] [stdout]      |
[INFO] [stdout] 1810 |         *self_rc.duration_s.borrow_mut() = _io.read_u4le()?.into();
[INFO] [stdout]      |                                            ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1810 -         *self_rc.duration_s.borrow_mut() = _io.read_u4le()?.into();
[INFO] [stdout] 1810 +         *self_rc.duration_s.borrow_mut() = _io.read_u4le()?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1810 -         *self_rc.duration_s.borrow_mut() = _io.read_u4le()?.into();
[INFO] [stdout] 1810 +         *self_rc.duration_s.borrow_mut() = <u32 as Into<_>>::into(_io.read_u4le()?);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Vec<u8>`
[INFO] [stdout]     --> src/autel_drone_log.rs:1071:61
[INFO] [stdout]      |
[INFO] [stdout] 1071 |         *self_rc.firmware_info.borrow_mut() = bytes_to_str(&_io.read_bytes(*self_rc.firmware_length() as usize)?.into(), "UTF-8")?;
[INFO] [stdout]      |                                                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1071 -         *self_rc.firmware_info.borrow_mut() = bytes_to_str(&_io.read_bytes(*self_rc.firmware_length() as usize)?.into(), "UTF-8")?;
[INFO] [stdout] 1071 +         *self_rc.firmware_info.borrow_mut() = bytes_to_str(&_io.read_bytes(*self_rc.firmware_length() as usize)?, "UTF-8")?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1071 -         *self_rc.firmware_info.borrow_mut() = bytes_to_str(&_io.read_bytes(*self_rc.firmware_length() as usize)?.into(), "UTF-8")?;
[INFO] [stdout] 1071 +         *self_rc.firmware_info.borrow_mut() = bytes_to_str(&<Vec<u8> as Into<_>>::into(_io.read_bytes(*self_rc.firmware_length() as usize)?), "UTF-8")?;
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `f32`
[INFO] [stdout]     --> src/autel_drone_log.rs:1195:47
[INFO] [stdout]      |
[INFO] [stdout] 1195 |         *self_rc.home_latitude.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout]      |                                               ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1195 -         *self_rc.home_latitude.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout] 1195 +         *self_rc.home_latitude.borrow_mut() = _io.read_f4le()?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1195 -         *self_rc.home_latitude.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout] 1195 +         *self_rc.home_latitude.borrow_mut() = <f32 as Into<_>>::into(_io.read_f4le()?);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `f32`
[INFO] [stdout]     --> src/autel_drone_log.rs:1196:48
[INFO] [stdout]      |
[INFO] [stdout] 1196 |         *self_rc.home_longitude.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout]      |                                                ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1196 -         *self_rc.home_longitude.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout] 1196 +         *self_rc.home_longitude.borrow_mut() = _io.read_f4le()?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1196 -         *self_rc.home_longitude.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout] 1196 +         *self_rc.home_longitude.borrow_mut() = <f32 as Into<_>>::into(_io.read_f4le()?);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `f32`
[INFO] [stdout]     --> src/autel_drone_log.rs:1197:52
[INFO] [stdout]      |
[INFO] [stdout] 1197 |         *self_rc.distance_to_home_m.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout]      |                                                    ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1197 -         *self_rc.distance_to_home_m.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout] 1197 +         *self_rc.distance_to_home_m.borrow_mut() = _io.read_f4le()?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1197 -         *self_rc.distance_to_home_m.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout] 1197 +         *self_rc.distance_to_home_m.borrow_mut() = <f32 as Into<_>>::into(_io.read_f4le()?);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `f64`
[INFO] [stdout]     --> src/autel_drone_log.rs:1255:43
[INFO] [stdout]      |
[INFO] [stdout] 1255 |         *self_rc.timestamp.borrow_mut() = _io.read_f8le()?.into();
[INFO] [stdout]      |                                           ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1255 -         *self_rc.timestamp.borrow_mut() = _io.read_f8le()?.into();
[INFO] [stdout] 1255 +         *self_rc.timestamp.borrow_mut() = _io.read_f8le()?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1255 -         *self_rc.timestamp.borrow_mut() = _io.read_f8le()?.into();
[INFO] [stdout] 1255 +         *self_rc.timestamp.borrow_mut() = <f64 as Into<_>>::into(_io.read_f8le()?);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `f32`
[INFO] [stdout]     --> src/autel_drone_log.rs:1256:46
[INFO] [stdout]      |
[INFO] [stdout] 1256 |         *self_rc.front_sensor.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout]      |                                              ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1256 -         *self_rc.front_sensor.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout] 1256 +         *self_rc.front_sensor.borrow_mut() = _io.read_f4le()?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1256 -         *self_rc.front_sensor.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout] 1256 +         *self_rc.front_sensor.borrow_mut() = <f32 as Into<_>>::into(_io.read_f4le()?);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `f32`
[INFO] [stdout]     --> src/autel_drone_log.rs:1257:45
[INFO] [stdout]      |
[INFO] [stdout] 1257 |         *self_rc.rear_sensor.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout]      |                                             ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1257 -         *self_rc.rear_sensor.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout] 1257 +         *self_rc.rear_sensor.borrow_mut() = _io.read_f4le()?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1257 -         *self_rc.rear_sensor.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout] 1257 +         *self_rc.rear_sensor.borrow_mut() = <f32 as Into<_>>::into(_io.read_f4le()?);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `f32`
[INFO] [stdout]     --> src/autel_drone_log.rs:1258:45
[INFO] [stdout]      |
[INFO] [stdout] 1258 |         *self_rc.left_sensor.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout]      |                                             ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1258 -         *self_rc.left_sensor.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout] 1258 +         *self_rc.left_sensor.borrow_mut() = _io.read_f4le()?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1258 -         *self_rc.left_sensor.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout] 1258 +         *self_rc.left_sensor.borrow_mut() = <f32 as Into<_>>::into(_io.read_f4le()?);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `f32`
[INFO] [stdout]     --> src/autel_drone_log.rs:1259:46
[INFO] [stdout]      |
[INFO] [stdout] 1259 |         *self_rc.right_sensor.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout]      |                                              ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1259 -         *self_rc.right_sensor.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout] 1259 +         *self_rc.right_sensor.borrow_mut() = _io.read_f4le()?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1259 -         *self_rc.right_sensor.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout] 1259 +         *self_rc.right_sensor.borrow_mut() = <f32 as Into<_>>::into(_io.read_f4le()?);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `f32`
[INFO] [stdout]     --> src/autel_drone_log.rs:1260:44
[INFO] [stdout]      |
[INFO] [stdout] 1260 |         *self_rc.top_sensor.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout]      |                                            ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1260 -         *self_rc.top_sensor.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout] 1260 +         *self_rc.top_sensor.borrow_mut() = _io.read_f4le()?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1260 -         *self_rc.top_sensor.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout] 1260 +         *self_rc.top_sensor.borrow_mut() = <f32 as Into<_>>::into(_io.read_f4le()?);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `f32`
[INFO] [stdout]     --> src/autel_drone_log.rs:1261:47
[INFO] [stdout]      |
[INFO] [stdout] 1261 |         *self_rc.bottom_sensor.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout]      |                                               ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1261 -         *self_rc.bottom_sensor.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout] 1261 +         *self_rc.bottom_sensor.borrow_mut() = _io.read_f4le()?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1261 -         *self_rc.bottom_sensor.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout] 1261 +         *self_rc.bottom_sensor.borrow_mut() = <f32 as Into<_>>::into(_io.read_f4le()?);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Vec<u8>`
[INFO] [stdout]     --> src/autel_drone_log.rs:1341:57
[INFO] [stdout]      |
[INFO] [stdout] 1341 |         *self_rc.file_name.borrow_mut() = bytes_to_str(&_io.read_bytes(64 as usize)?.into(), "UTF-8")?;
[INFO] [stdout]      |                                                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1341 -         *self_rc.file_name.borrow_mut() = bytes_to_str(&_io.read_bytes(64 as usize)?.into(), "UTF-8")?;
[INFO] [stdout] 1341 +         *self_rc.file_name.borrow_mut() = bytes_to_str(&_io.read_bytes(64 as usize)?, "UTF-8")?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1341 -         *self_rc.file_name.borrow_mut() = bytes_to_str(&_io.read_bytes(64 as usize)?.into(), "UTF-8")?;
[INFO] [stdout] 1341 +         *self_rc.file_name.borrow_mut() = bytes_to_str(&<Vec<u8> as Into<_>>::into(_io.read_bytes(64 as usize)?), "UTF-8")?;
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u64`
[INFO] [stdout]     --> src/autel_drone_log.rs:1342:43
[INFO] [stdout]      |
[INFO] [stdout] 1342 |         *self_rc.timestamp.borrow_mut() = _io.read_u8le()?.into();
[INFO] [stdout]      |                                           ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1342 -         *self_rc.timestamp.borrow_mut() = _io.read_u8le()?.into();
[INFO] [stdout] 1342 +         *self_rc.timestamp.borrow_mut() = _io.read_u8le()?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1342 -         *self_rc.timestamp.borrow_mut() = _io.read_u8le()?.into();
[INFO] [stdout] 1342 +         *self_rc.timestamp.borrow_mut() = <u64 as Into<_>>::into(_io.read_u8le()?);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `f32`
[INFO] [stdout]     --> src/autel_drone_log.rs:1343:42
[INFO] [stdout]      |
[INFO] [stdout] 1343 |         *self_rc.latitude.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout]      |                                          ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1343 -         *self_rc.latitude.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout] 1343 +         *self_rc.latitude.borrow_mut() = _io.read_f4le()?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1343 -         *self_rc.latitude.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout] 1343 +         *self_rc.latitude.borrow_mut() = <f32 as Into<_>>::into(_io.read_f4le()?);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `f32`
[INFO] [stdout]     --> src/autel_drone_log.rs:1344:43
[INFO] [stdout]      |
[INFO] [stdout] 1344 |         *self_rc.longitude.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout]      |                                           ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1344 -         *self_rc.longitude.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout] 1344 +         *self_rc.longitude.borrow_mut() = _io.read_f4le()?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1344 -         *self_rc.longitude.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout] 1344 +         *self_rc.longitude.borrow_mut() = <f32 as Into<_>>::into(_io.read_f4le()?);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]     --> src/autel_drone_log.rs:1415:49
[INFO] [stdout]      |
[INFO] [stdout] 1415 |         *self_rc.designed_volume.borrow_mut() = _io.read_u4le()?.into();
[INFO] [stdout]      |                                                 ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1415 -         *self_rc.designed_volume.borrow_mut() = _io.read_u4le()?.into();
[INFO] [stdout] 1415 +         *self_rc.designed_volume.borrow_mut() = _io.read_u4le()?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1415 -         *self_rc.designed_volume.borrow_mut() = _io.read_u4le()?.into();
[INFO] [stdout] 1415 +         *self_rc.designed_volume.borrow_mut() = <u32 as Into<_>>::into(_io.read_u4le()?);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]     --> src/autel_drone_log.rs:1416:54
[INFO] [stdout]      |
[INFO] [stdout] 1416 |         *self_rc.maximum_capacity_mah.borrow_mut() = _io.read_u4le()?.into();
[INFO] [stdout]      |                                                      ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1416 -         *self_rc.maximum_capacity_mah.borrow_mut() = _io.read_u4le()?.into();
[INFO] [stdout] 1416 +         *self_rc.maximum_capacity_mah.borrow_mut() = _io.read_u4le()?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1416 -         *self_rc.maximum_capacity_mah.borrow_mut() = _io.read_u4le()?.into();
[INFO] [stdout] 1416 +         *self_rc.maximum_capacity_mah.borrow_mut() = <u32 as Into<_>>::into(_io.read_u4le()?);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `f32`
[INFO] [stdout]     --> src/autel_drone_log.rs:1417:54
[INFO] [stdout]      |
[INFO] [stdout] 1417 |         *self_rc.current_capacity_mah.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout]      |                                                      ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1417 -         *self_rc.current_capacity_mah.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout] 1417 +         *self_rc.current_capacity_mah.borrow_mut() = _io.read_f4le()?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1417 -         *self_rc.current_capacity_mah.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout] 1417 +         *self_rc.current_capacity_mah.borrow_mut() = <f32 as Into<_>>::into(_io.read_f4le()?);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `f32`
[INFO] [stdout]     --> src/autel_drone_log.rs:1418:44
[INFO] [stdout]      |
[INFO] [stdout] 1418 |         *self_rc.voltage_mv.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout]      |                                            ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1418 -         *self_rc.voltage_mv.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout] 1418 +         *self_rc.voltage_mv.borrow_mut() = _io.read_f4le()?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1418 -         *self_rc.voltage_mv.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout] 1418 +         *self_rc.voltage_mv.borrow_mut() = <f32 as Into<_>>::into(_io.read_f4le()?);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `f32`
[INFO] [stdout]     --> src/autel_drone_log.rs:1419:46
[INFO] [stdout]      |
[INFO] [stdout] 1419 |         *self_rc.current_draw.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout]      |                                              ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1419 -         *self_rc.current_draw.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout] 1419 +         *self_rc.current_draw.borrow_mut() = _io.read_f4le()?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1419 -         *self_rc.current_draw.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout] 1419 +         *self_rc.current_draw.borrow_mut() = <f32 as Into<_>>::into(_io.read_f4le()?);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]     --> src/autel_drone_log.rs:1420:53
[INFO] [stdout]      |
[INFO] [stdout] 1420 |         *self_rc.remaining_charge_pc.borrow_mut() = _io.read_u1()?.into();
[INFO] [stdout]      |                                                     ^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1420 -         *self_rc.remaining_charge_pc.borrow_mut() = _io.read_u1()?.into();
[INFO] [stdout] 1420 +         *self_rc.remaining_charge_pc.borrow_mut() = _io.read_u1()?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1420 -         *self_rc.remaining_charge_pc.borrow_mut() = _io.read_u1()?.into();
[INFO] [stdout] 1420 +         *self_rc.remaining_charge_pc.borrow_mut() = <u8 as Into<_>>::into(_io.read_u1()?);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `f32`
[INFO] [stdout]     --> src/autel_drone_log.rs:1421:59
[INFO] [stdout]      |
[INFO] [stdout] 1421 |         *self_rc.battery_temperature_deg_c.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout]      |                                                           ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1421 -         *self_rc.battery_temperature_deg_c.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout] 1421 +         *self_rc.battery_temperature_deg_c.borrow_mut() = _io.read_f4le()?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1421 -         *self_rc.battery_temperature_deg_c.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout] 1421 +         *self_rc.battery_temperature_deg_c.borrow_mut() = <f32 as Into<_>>::into(_io.read_f4le()?);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]     --> src/autel_drone_log.rs:1423:57
[INFO] [stdout]      |
[INFO] [stdout] 1423 |         *self_rc.battery_discharge_count.borrow_mut() = _io.read_u4le()?.into();
[INFO] [stdout]      |                                                         ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1423 -         *self_rc.battery_discharge_count.borrow_mut() = _io.read_u4le()?.into();
[INFO] [stdout] 1423 +         *self_rc.battery_discharge_count.borrow_mut() = _io.read_u4le()?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1423 -         *self_rc.battery_discharge_count.borrow_mut() = _io.read_u4le()?.into();
[INFO] [stdout] 1423 +         *self_rc.battery_discharge_count.borrow_mut() = <u32 as Into<_>>::into(_io.read_u4le()?);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]     --> src/autel_drone_log.rs:1424:44
[INFO] [stdout]      |
[INFO] [stdout] 1424 |         *self_rc.cell_count.borrow_mut() = _io.read_u1()?.into();
[INFO] [stdout]      |                                            ^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1424 -         *self_rc.cell_count.borrow_mut() = _io.read_u1()?.into();
[INFO] [stdout] 1424 +         *self_rc.cell_count.borrow_mut() = _io.read_u1()?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1424 -         *self_rc.cell_count.borrow_mut() = _io.read_u1()?.into();
[INFO] [stdout] 1424 +         *self_rc.cell_count.borrow_mut() = <u8 as Into<_>>::into(_io.read_u1()?);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `f32`
[INFO] [stdout]     --> src/autel_drone_log.rs:1428:52
[INFO] [stdout]      |
[INFO] [stdout] 1428 |             self_rc.cell_voltage.borrow_mut().push(_io.read_f4le()?.into());
[INFO] [stdout]      |                                                    ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1428 -             self_rc.cell_voltage.borrow_mut().push(_io.read_f4le()?.into());
[INFO] [stdout] 1428 +             self_rc.cell_voltage.borrow_mut().push(_io.read_f4le()?);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1428 -             self_rc.cell_voltage.borrow_mut().push(_io.read_f4le()?.into());
[INFO] [stdout] 1428 +             self_rc.cell_voltage.borrow_mut().push(<f32 as Into<_>>::into(_io.read_f4le()?));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]     --> src/autel_drone_log.rs:1595:45
[INFO] [stdout]      |
[INFO] [stdout] 1595 |         *self_rc.record_type.borrow_mut() = _io.read_u1()?.into();
[INFO] [stdout]      |                                             ^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1595 -         *self_rc.record_type.borrow_mut() = _io.read_u1()?.into();
[INFO] [stdout] 1595 +         *self_rc.record_type.borrow_mut() = _io.read_u1()?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1595 -         *self_rc.record_type.borrow_mut() = _io.read_u1()?.into();
[INFO] [stdout] 1595 +         *self_rc.record_type.borrow_mut() = <u8 as Into<_>>::into(_io.read_u1()?);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]     --> src/autel_drone_log.rs:1684:52
[INFO] [stdout]      |
[INFO] [stdout] 1684 |         *self_rc.oa_warning_enabled.borrow_mut() = _io.read_u4le()?.into();
[INFO] [stdout]      |                                                    ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1684 -         *self_rc.oa_warning_enabled.borrow_mut() = _io.read_u4le()?.into();
[INFO] [stdout] 1684 +         *self_rc.oa_warning_enabled.borrow_mut() = _io.read_u4le()?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1684 -         *self_rc.oa_warning_enabled.borrow_mut() = _io.read_u4le()?.into();
[INFO] [stdout] 1684 +         *self_rc.oa_warning_enabled.borrow_mut() = <u32 as Into<_>>::into(_io.read_u4le()?);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]     --> src/autel_drone_log.rs:1685:56
[INFO] [stdout]      |
[INFO] [stdout] 1685 |         *self_rc.oa_ext_warning_enabled.borrow_mut() = _io.read_u4le()?.into();
[INFO] [stdout]      |                                                        ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1685 -         *self_rc.oa_ext_warning_enabled.borrow_mut() = _io.read_u4le()?.into();
[INFO] [stdout] 1685 +         *self_rc.oa_ext_warning_enabled.borrow_mut() = _io.read_u4le()?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1685 -         *self_rc.oa_ext_warning_enabled.borrow_mut() = _io.read_u4le()?.into();
[INFO] [stdout] 1685 +         *self_rc.oa_ext_warning_enabled.borrow_mut() = <u32 as Into<_>>::into(_io.read_u4le()?);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]     --> src/autel_drone_log.rs:1686:47
[INFO] [stdout]      |
[INFO] [stdout] 1686 |         *self_rc.oa_error_code.borrow_mut() = _io.read_u4le()?.into();
[INFO] [stdout]      |                                               ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1686 -         *self_rc.oa_error_code.borrow_mut() = _io.read_u4le()?.into();
[INFO] [stdout] 1686 +         *self_rc.oa_error_code.borrow_mut() = _io.read_u4le()?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1686 -         *self_rc.oa_error_code.borrow_mut() = _io.read_u4le()?.into();
[INFO] [stdout] 1686 +         *self_rc.oa_error_code.borrow_mut() = <u32 as Into<_>>::into(_io.read_u4le()?);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `f32`
[INFO] [stdout]     --> src/autel_drone_log.rs:1687:48
[INFO] [stdout]      |
[INFO] [stdout] 1687 |         *self_rc.max_altitude_m.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout]      |                                                ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1687 -         *self_rc.max_altitude_m.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout] 1687 +         *self_rc.max_altitude_m.borrow_mut() = _io.read_f4le()?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1687 -         *self_rc.max_altitude_m.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout] 1687 +         *self_rc.max_altitude_m.borrow_mut() = <f32 as Into<_>>::into(_io.read_f4le()?);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `f32`
[INFO] [stdout]     --> src/autel_drone_log.rs:1688:59
[INFO] [stdout]      |
[INFO] [stdout] 1688 |         *self_rc.return_to_home_altitude_m.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout]      |                                                           ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1688 -         *self_rc.return_to_home_altitude_m.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout] 1688 +         *self_rc.return_to_home_altitude_m.borrow_mut() = _io.read_f4le()?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1688 -         *self_rc.return_to_home_altitude_m.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout] 1688 +         *self_rc.return_to_home_altitude_m.borrow_mut() = <f32 as Into<_>>::into(_io.read_f4le()?);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]     --> src/autel_drone_log.rs:1689:55
[INFO] [stdout]      |
[INFO] [stdout] 1689 |         *self_rc.beginner_mode_enabled.borrow_mut() = _io.read_u1()?.into();
[INFO] [stdout]      |                                                       ^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1689 -         *self_rc.beginner_mode_enabled.borrow_mut() = _io.read_u1()?.into();
[INFO] [stdout] 1689 +         *self_rc.beginner_mode_enabled.borrow_mut() = _io.read_u1()?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1689 -         *self_rc.beginner_mode_enabled.borrow_mut() = _io.read_u1()?.into();
[INFO] [stdout] 1689 +         *self_rc.beginner_mode_enabled.borrow_mut() = <u8 as Into<_>>::into(_io.read_u1()?);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]     --> src/autel_drone_log.rs:1690:63
[INFO] [stdout]      |
[INFO] [stdout] 1690 |         *self_rc.low_battery_threshold_enabled.borrow_mut() = _io.read_u1()?.into();
[INFO] [stdout]      |                                                               ^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1690 -         *self_rc.low_battery_threshold_enabled.borrow_mut() = _io.read_u1()?.into();
[INFO] [stdout] 1690 +         *self_rc.low_battery_threshold_enabled.borrow_mut() = _io.read_u1()?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1690 -         *self_rc.low_battery_threshold_enabled.borrow_mut() = _io.read_u1()?.into();
[INFO] [stdout] 1690 +         *self_rc.low_battery_threshold_enabled.borrow_mut() = <u8 as Into<_>>::into(_io.read_u1()?);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]     --> src/autel_drone_log.rs:1691:68
[INFO] [stdout]      |
[INFO] [stdout] 1691 |         *self_rc.critical_battery_threshold_enabled.borrow_mut() = _io.read_u1()?.into();
[INFO] [stdout]      |                                                                    ^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1691 -         *self_rc.critical_battery_threshold_enabled.borrow_mut() = _io.read_u1()?.into();
[INFO] [stdout] 1691 +         *self_rc.critical_battery_threshold_enabled.borrow_mut() = _io.read_u1()?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1691 -         *self_rc.critical_battery_threshold_enabled.borrow_mut() = _io.read_u1()?.into();
[INFO] [stdout] 1691 +         *self_rc.critical_battery_threshold_enabled.borrow_mut() = <u8 as Into<_>>::into(_io.read_u1()?);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `f32`
[INFO] [stdout]     --> src/autel_drone_log.rs:1692:55
[INFO] [stdout]      |
[INFO] [stdout] 1692 |         *self_rc.max_flight_distance_m.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout]      |                                                       ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1692 -         *self_rc.max_flight_distance_m.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout] 1692 +         *self_rc.max_flight_distance_m.borrow_mut() = _io.read_f4le()?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1692 -         *self_rc.max_flight_distance_m.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout] 1692 +         *self_rc.max_flight_distance_m.borrow_mut() = <f32 as Into<_>>::into(_io.read_f4le()?);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `f32`
[INFO] [stdout]     --> src/autel_drone_log.rs:1693:54
[INFO] [stdout]      |
[INFO] [stdout] 1693 |         *self_rc.max_horizontal_speed.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout]      |                                                      ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1693 -         *self_rc.max_horizontal_speed.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout] 1693 +         *self_rc.max_horizontal_speed.borrow_mut() = _io.read_f4le()?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1693 -         *self_rc.max_horizontal_speed.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout] 1693 +         *self_rc.max_horizontal_speed.borrow_mut() = <f32 as Into<_>>::into(_io.read_f4le()?);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]     --> src/autel_drone_log.rs:1694:44
[INFO] [stdout]      |
[INFO] [stdout] 1694 |         *self_rc.oa_enabled.borrow_mut() = _io.read_u1()?.into();
[INFO] [stdout]      |                                            ^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1694 -         *self_rc.oa_enabled.borrow_mut() = _io.read_u1()?.into();
[INFO] [stdout] 1694 +         *self_rc.oa_enabled.borrow_mut() = _io.read_u1()?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1694 -         *self_rc.oa_enabled.borrow_mut() = _io.read_u1()?.into();
[INFO] [stdout] 1694 +         *self_rc.oa_enabled.borrow_mut() = <u8 as Into<_>>::into(_io.read_u1()?);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u8`
[INFO] [stdout]     --> src/autel_drone_log.rs:1695:47
[INFO] [stdout]      |
[INFO] [stdout] 1695 |         *self_rc.radar_enabled.borrow_mut() = _io.read_u1()?.into();
[INFO] [stdout]      |                                               ^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1695 -         *self_rc.radar_enabled.borrow_mut() = _io.read_u1()?.into();
[INFO] [stdout] 1695 +         *self_rc.radar_enabled.borrow_mut() = _io.read_u1()?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1695 -         *self_rc.radar_enabled.borrow_mut() = _io.read_u1()?.into();
[INFO] [stdout] 1695 +         *self_rc.radar_enabled.borrow_mut() = <u8 as Into<_>>::into(_io.read_u1()?);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]     --> src/autel_drone_log.rs:1696:43
[INFO] [stdout]      |
[INFO] [stdout] 1696 |         *self_rc.max_error.borrow_mut() = _io.read_u4le()?.into();
[INFO] [stdout]      |                                           ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1696 -         *self_rc.max_error.borrow_mut() = _io.read_u4le()?.into();
[INFO] [stdout] 1696 +         *self_rc.max_error.borrow_mut() = _io.read_u4le()?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1696 -         *self_rc.max_error.borrow_mut() = _io.read_u4le()?.into();
[INFO] [stdout] 1696 +         *self_rc.max_error.borrow_mut() = <u32 as Into<_>>::into(_io.read_u4le()?);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Vec<u8>`
[INFO] [stdout]     --> src/autel_drone_log.rs:1806:57
[INFO] [stdout]      |
[INFO] [stdout] 1806 |         *self_rc.file_name.borrow_mut() = bytes_to_str(&_io.read_bytes(64 as usize)?.into(), "UTF-8")?;
[INFO] [stdout]      |                                                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1806 -         *self_rc.file_name.borrow_mut() = bytes_to_str(&_io.read_bytes(64 as usize)?.into(), "UTF-8")?;
[INFO] [stdout] 1806 +         *self_rc.file_name.borrow_mut() = bytes_to_str(&_io.read_bytes(64 as usize)?, "UTF-8")?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1806 -         *self_rc.file_name.borrow_mut() = bytes_to_str(&_io.read_bytes(64 as usize)?.into(), "UTF-8")?;
[INFO] [stdout] 1806 +         *self_rc.file_name.borrow_mut() = bytes_to_str(&<Vec<u8> as Into<_>>::into(_io.read_bytes(64 as usize)?), "UTF-8")?;
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u64`
[INFO] [stdout]     --> src/autel_drone_log.rs:1807:43
[INFO] [stdout]      |
[INFO] [stdout] 1807 |         *self_rc.timestamp.borrow_mut() = _io.read_u8le()?.into();
[INFO] [stdout]      |                                           ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1807 -         *self_rc.timestamp.borrow_mut() = _io.read_u8le()?.into();
[INFO] [stdout] 1807 +         *self_rc.timestamp.borrow_mut() = _io.read_u8le()?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1807 -         *self_rc.timestamp.borrow_mut() = _io.read_u8le()?.into();
[INFO] [stdout] 1807 +         *self_rc.timestamp.borrow_mut() = <u64 as Into<_>>::into(_io.read_u8le()?);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `f32`
[INFO] [stdout]     --> src/autel_drone_log.rs:1808:42
[INFO] [stdout]      |
[INFO] [stdout] 1808 |         *self_rc.latitude.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout]      |                                          ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1808 -         *self_rc.latitude.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout] 1808 +         *self_rc.latitude.borrow_mut() = _io.read_f4le()?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1808 -         *self_rc.latitude.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout] 1808 +         *self_rc.latitude.borrow_mut() = <f32 as Into<_>>::into(_io.read_f4le()?);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `f32`
[INFO] [stdout]     --> src/autel_drone_log.rs:1809:43
[INFO] [stdout]      |
[INFO] [stdout] 1809 |         *self_rc.longitude.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout]      |                                           ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1809 -         *self_rc.longitude.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout] 1809 +         *self_rc.longitude.borrow_mut() = _io.read_f4le()?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1809 -         *self_rc.longitude.borrow_mut() = _io.read_f4le()?.into();
[INFO] [stdout] 1809 +         *self_rc.longitude.borrow_mut() = <f32 as Into<_>>::into(_io.read_f4le()?);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]     --> src/autel_drone_log.rs:1810:44
[INFO] [stdout]      |
[INFO] [stdout] 1810 |         *self_rc.duration_s.borrow_mut() = _io.read_u4le()?.into();
[INFO] [stdout]      |                                            ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1810 -         *self_rc.duration_s.borrow_mut() = _io.read_u4le()?.into();
[INFO] [stdout] 1810 +         *self_rc.duration_s.borrow_mut() = _io.read_u4le()?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1810 -         *self_rc.duration_s.borrow_mut() = _io.read_u4le()?.into();
[INFO] [stdout] 1810 +         *self_rc.duration_s.borrow_mut() = <u32 as Into<_>>::into(_io.read_u4le()?);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stderr] error: could not compile `autel-odl` (bin "autel-odl") due to 118 previous errors
[INFO] [stderr] warning: build failed, waiting for other jobs to finish...
[INFO] [stderr] error: could not compile `autel-odl` (bin "autel-odl" test) due to 118 previous errors
[INFO] running `Command { std: "docker" "inspect" "0c36cca878d669f3365b0bc692b1358861e57305350dd7b4eb314f496f42f4f2", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "rm" "-f" "0c36cca878d669f3365b0bc692b1358861e57305350dd7b4eb314f496f42f4f2", kill_on_drop: false }`
[INFO] [stdout] 0c36cca878d669f3365b0bc692b1358861e57305350dd7b4eb314f496f42f4f2
