[INFO] cloning repository https://github.com/claudiofsr/rust-sped
[INFO] running `Command { std: "git" "-c" "credential.helper=" "-c" "credential.helper=/workspace/cargo-home/bin/git-credential-null" "clone" "--bare" "https://github.com/claudiofsr/rust-sped" "/workspace/cache/git-repos/https%3A%2F%2Fgithub.com%2Fclaudiofsr%2Frust-sped", kill_on_drop: false }`
[INFO] [stderr] Cloning into bare repository '/workspace/cache/git-repos/https%3A%2F%2Fgithub.com%2Fclaudiofsr%2Frust-sped'...
[INFO] running `Command { std: "git" "rev-parse" "HEAD", kill_on_drop: false }`
[INFO] [stdout] 709d61e38e1020a3713952dad2b2988e4258e99a
[INFO] checking claudiofsr/rust-sped against 52995a223f2919dd3e2e427231db90a257350ded for pr-129249-4
[INFO] running `Command { std: "git" "clone" "/workspace/cache/git-repos/https%3A%2F%2Fgithub.com%2Fclaudiofsr%2Frust-sped" "/workspace/builds/worker-0-tc2/source", kill_on_drop: false }`
[INFO] [stderr] Cloning into '/workspace/builds/worker-0-tc2/source'...
[INFO] [stderr] done.
[INFO] removed /workspace/builds/worker-0-tc2/source/.cargo/config.toml
[INFO] started tweaking git repo https://github.com/claudiofsr/rust-sped
[INFO] removed 0 missing examples
[INFO] finished tweaking git repo https://github.com/claudiofsr/rust-sped
[INFO] tweaked toml for git repo https://github.com/claudiofsr/rust-sped written to /workspace/builds/worker-0-tc2/source/Cargo.toml
[INFO] validating manifest of git repo https://github.com/claudiofsr/rust-sped on toolchain 52995a223f2919dd3e2e427231db90a257350ded
[INFO] running `Command { std: CARGO_HOME="/workspace/cargo-home" RUSTUP_HOME="/workspace/rustup-home" "/workspace/cargo-home/bin/cargo" "+52995a223f2919dd3e2e427231db90a257350ded" "metadata" "--manifest-path" "Cargo.toml" "--no-deps", kill_on_drop: false }`
[INFO] crate git repo https://github.com/claudiofsr/rust-sped 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" "+52995a223f2919dd3e2e427231db90a257350ded" "fetch" "--manifest-path" "Cargo.toml", kill_on_drop: false }`
[INFO] [stderr] warning: `package.homepage` is redundant with `package.repository`
[INFO] [stderr]    --> Cargo.toml:113:12
[INFO] [stderr]     |
[INFO] [stderr] 113 | homepage = "https://github.com/claudiofsr/rust-sped"
[INFO] [stderr]     |            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stderr] ...
[INFO] [stderr] 119 | repository = "https://github.com/claudiofsr/rust-sped"
[INFO] [stderr]     |              -----------------------------------------
[INFO] [stderr]     |
[INFO] [stderr]     = note: `cargo::redundant_homepage` is set to `warn` by default
[INFO] [stderr] help: consider removing `package.homepage`
[INFO] [stderr] warning: `efd_contribuicoes` (manifest) generated 1 warning
[INFO] running `Command { std: "docker" "create" "-v" "/var/lib/crater-agent-workspace/builds/worker-0-tc2/source:/opt/rustwide/workdir:ro,Z" "-v" "/var/lib/crater-agent-workspace/builds/worker-0-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] 1f98edef3ac4e579cea54d9ee8417e1a3e1e85c63a2d3c842cef088fc9d0e42d
[INFO] running `Command { std: "docker" "start" "1f98edef3ac4e579cea54d9ee8417e1a3e1e85c63a2d3c842cef088fc9d0e42d", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "inspect" "1f98edef3ac4e579cea54d9ee8417e1a3e1e85c63a2d3c842cef088fc9d0e42d", 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" "1f98edef3ac4e579cea54d9ee8417e1a3e1e85c63a2d3c842cef088fc9d0e42d" "/opt/rustwide/cargo-home/bin/cargo" "+52995a223f2919dd3e2e427231db90a257350ded" "metadata" "--no-deps" "--format-version=1", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "inspect" "1f98edef3ac4e579cea54d9ee8417e1a3e1e85c63a2d3c842cef088fc9d0e42d", 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" "1f98edef3ac4e579cea54d9ee8417e1a3e1e85c63a2d3c842cef088fc9d0e42d" "/opt/rustwide/cargo-home/bin/cargo" "+52995a223f2919dd3e2e427231db90a257350ded" "check" "--frozen" "--all" "--all-targets" "--message-format=json", kill_on_drop: false }`
[INFO] [stderr] warning: `package.homepage` is redundant with `package.repository`
[INFO] [stderr]    --> Cargo.toml:113:12
[INFO] [stderr]     |
[INFO] [stderr] 113 | homepage = "https://github.com/claudiofsr/rust-sped"
[INFO] [stderr]     |            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stderr] ...
[INFO] [stderr] 119 | repository = "https://github.com/claudiofsr/rust-sped"
[INFO] [stderr]     |              -----------------------------------------
[INFO] [stderr]     |
[INFO] [stderr]     = note: `cargo::redundant_homepage` is set to `warn` by default
[INFO] [stderr] help: consider removing `package.homepage`
[INFO] [stderr] warning: `efd_contribuicoes` (manifest) generated 1 warning
[INFO] [stderr]    Compiling unicode-ident v1.0.26
[INFO] [stderr]     Checking cfg-if v1.0.5
[INFO] [stderr]    Compiling find-msvc-tools v0.1.13
[INFO] [stderr]     Checking memchr v2.8.3
[INFO] [stderr]    Compiling serde_core v1.0.229
[INFO] [stderr]    Compiling libc v0.2.189
[INFO] [stderr]    Compiling serde v1.0.229
[INFO] [stderr]    Compiling num-traits v0.2.19
[INFO] [stderr]     Checking simd-adler32 v0.3.10
[INFO] [stderr]    Compiling proc-macro2 v1.0.107
[INFO] [stderr]    Compiling crc32fast v1.5.2
[INFO] [stderr]    Compiling cc v1.4.7
[INFO] [stderr]     Checking bitflags v2.13.2
[INFO] [stderr]    Compiling crossbeam-utils v0.8.23
[INFO] [stderr]     Checking adler2 v2.0.1
[INFO] [stderr]     Checking arrayvec v0.7.8
[INFO] [stderr]    Compiling crossbeam-epoch v0.9.21
[INFO] [stderr]    Compiling quote v1.0.47
[INFO] [stderr]    Compiling rustix v1.1.5
[INFO] [stderr]     Checking log v0.4.34
[INFO] [stderr]    Compiling syn v3.0.6
[INFO] [stderr]    Compiling syn v2.0.119
[INFO] [stderr]     Checking miniz_oxide v0.9.1
[INFO] [stderr]     Checking zlib-rs v0.6.8
[INFO] [stderr]    Compiling crossbeam-deque v0.8.8
[INFO] [stderr]     Checking linux-raw-sys v0.12.1
[INFO] [stderr]    Compiling zmij v1.0.23
[INFO] [stderr]    Compiling rayon-core v1.13.0
[INFO] [stderr]     Checking utf8parse v0.2.2
[INFO] [stderr]     Checking either v1.18.0
[INFO] [stderr]     Checking anstyle-parse v1.0.0
[INFO] [stderr]     Checking aho-corasick v1.1.5
[INFO] [stderr]     Checking once_cell v1.21.4
[INFO] [stderr]    Compiling libz-sys v1.1.29
[INFO] [stderr]     Checking unicode-width v0.2.2
[INFO] [stderr]     Checking minimal-lexical v0.2.1
[INFO] [stderr]     Checking is_terminal_polyfill v1.70.2
[INFO] [stderr]     Checking itoa v1.0.18
[INFO] [stderr]     Checking flate2 v1.1.10
[INFO] [stderr]     Checking anstyle v1.0.14
[INFO] [stderr]     Checking regex-syntax v0.8.11
[INFO] [stderr]     Checking anstyle-query v1.1.5
[INFO] [stderr]     Checking colorchoice v1.0.5
[INFO] [stderr]     Checking iana-time-zone v0.1.65
[INFO] [stderr]     Checking anstream v1.0.0
[INFO] [stderr]     Checking nom v7.1.3
[INFO] [stderr]     Checking vte v0.14.1
[INFO] [stderr]     Checking rand_core v0.10.1
[INFO] [stderr]    Compiling serde_json v1.0.151
[INFO] [stderr]    Compiling getrandom v0.4.3
[INFO] [stderr]    Compiling pathfinder_simd v0.5.6
[INFO] [stderr]    Compiling freetype-sys v0.20.1
[INFO] [stderr]    Compiling yeslogic-fontconfig-sys v6.0.1
[INFO] [stderr]     Checking cpufeatures v0.3.1
[INFO] [stderr]     Checking clap_lex v1.1.1
[INFO] [stderr]     Checking strsim v0.11.1
[INFO] [stderr]    Compiling rust_decimal v1.43.0
[INFO] [stderr]    Compiling zerocopy v0.8.57
[INFO] [stderr]    Compiling portable-atomic v1.15.0
[INFO] [stderr]     Checking terminal_size v0.4.4
[INFO] [stderr]     Checking clap_builder v4.6.7
[INFO] [stderr]     Checking rayon v1.12.0
[INFO] [stderr]     Checking regex-automata v0.4.18
[INFO] [stderr]    Compiling blake3 v1.8.7
[INFO] [stderr]    Compiling encoding_rs v0.8.41
[INFO] [stderr]     Checking miniz_oxide v0.8.9
[INFO] [stderr]     Checking fdeflate v0.3.7
[INFO] [stderr]     Checking ansitok v0.3.0
[INFO] [stderr]     Checking libloading v0.8.9
[INFO] [stderr]     Checking option-ext v0.2.0
[INFO] [stderr]     Checking bitflags v1.3.2
[INFO] [stderr]     Checking color_quant v1.1.0
[INFO] [stderr]     Checking equivalent v1.0.2
[INFO] [stderr]     Checking hashbrown v0.17.1
[INFO] [stderr]     Checking byteorder v1.5.0
[INFO] [stderr]     Checking bumpalo v3.20.3
[INFO] [stderr]     Checking ansi-str v0.9.0
[INFO] [stderr]     Checking zopfli v0.8.3
[INFO] [stderr]     Checking png v0.17.16
[INFO] [stderr]     Checking indexmap v2.14.2
[INFO] [stderr]     Checking dirs-sys v0.5.0
[INFO] [stderr]     Checking dlib v0.5.3
[INFO] [stderr]    Compiling erased-serde v0.3.31
[INFO] [stderr]     Checking console v0.16.6
[INFO] [stderr]     Checking regex v1.13.1
[INFO] [stderr]     Checking ordered-float v2.10.1
[INFO] [stderr]     Checking bytemuck v1.25.2
[INFO] [stderr]    Compiling serde_derive v1.0.229
[INFO] [stderr]    Compiling clap_derive v4.6.7
[INFO] [stderr]    Compiling multiversion-macros v0.9.0
[INFO] [stderr]    Compiling zerocopy-derive v0.8.57
[INFO] [stderr]    Compiling multiversion_no_op v1.0.0
[INFO] [stderr]     Checking fnv v1.0.7
[INFO] [stderr]     Checking same-file v1.0.6
[INFO] [stderr]     Checking scopeguard v1.2.0
[INFO] [stderr]     Checking jpeg-decoder v0.3.2
[INFO] [stderr]    Compiling font-kit v0.14.3
[INFO] [stderr]     Checking fastrand v2.5.0
[INFO] [stderr]     Checking typed-path v0.12.3
[INFO] [stderr]     Checking unit-prefix v0.5.2
[INFO] [stderr]    Compiling struct_iterable_internal v0.1.1
[INFO] [stderr]     Checking constant_time_eq v0.4.2
[INFO] [stderr]     Checking ryu v1.0.23
[INFO] [stderr]     Checking core_detect v1.0.0
[INFO] [stderr]     Checking plotters-backend v0.3.7
[INFO] [stderr]     Checking simdutf8 v0.1.5
[INFO] [stderr]     Checking bytecount v0.6.9
[INFO] [stderr]     Checking jiff-core v0.1.1
[INFO] [stderr]     Checking weezl v0.1.12
[INFO] [stderr]     Checking papergrid v0.18.0
[INFO] [stderr]     Checking multiversion v0.9.0
[INFO] [stderr]     Checking gif v0.12.0
[INFO] [stderr]     Checking image v0.24.9
[INFO] [stderr]     Checking zip v8.6.0
[INFO] [stderr]     Checking clap v4.6.7
[INFO] [stderr]     Checking jiff v0.2.37
[INFO] [stderr]    Compiling struct_iterable_derive v0.1.0
[INFO] [stderr]     Checking indicatif v0.18.6
[INFO] [stderr]     Checking tempfile v3.27.0
[INFO] [stderr]    Compiling thiserror v2.0.20
[INFO] [stderr]     Checking walkdir v2.5.0
[INFO] [stderr]     Checking env_filter v2.0.0
[INFO] [stderr]    Compiling rust_xlsxwriter_derive v0.2.0
[INFO] [stderr]    Compiling tabled_derive v0.12.0
[INFO] [stderr]    Compiling rust_decimal_macros v1.40.0
[INFO] [stderr]    Compiling thiserror-impl v2.0.20
[INFO] [stderr]     Checking pathfinder_geometry v0.5.1
[INFO] [stderr]     Checking dirs v6.0.0
[INFO] [stderr]     Checking testing_table v0.3.0
[INFO] [stderr]     Checking chacha20 v0.10.2
[INFO] [stderr]    Compiling alloca v0.4.0
[INFO] [stderr]     Checking itertools v0.15.0
[INFO] [stderr]     Checking memmap2 v0.9.11
[INFO] [stderr]     Checking jobserver v0.1.35
[INFO] [stderr]     Checking castaway v0.2.4
[INFO] [stderr]     Checking csv-core v0.1.13
[INFO] [stderr]     Checking float-ord v0.3.2
[INFO] [stderr]     Checking static_assertions v1.1.0
[INFO] [stderr]     Checking ciborium-io v0.2.2
[INFO] [stderr]     Checking shlex v2.0.1
[INFO] [stderr]     Checking lazy_static v1.5.0
[INFO] [stderr]     Checking struct_iterable v0.1.1
[INFO] [stderr]     Checking tabled v0.22.0
[INFO] [stderr]     Checking csv v1.4.0
[INFO] [stderr]     Checking plotters-bitmap v0.3.7
[INFO] [stderr]     Checking rand v0.10.2
[INFO] [stderr]     Checking chrono v0.4.45
[INFO] [stderr]     Checking serde-value v0.7.0
[INFO] [stderr]     Checking compact_str v0.10.0
[INFO] [stderr]     Checking encoding_rs_io v0.1.8
[INFO] [stderr]     Checking env_logger v0.11.11
[INFO] [stderr]     Checking clap_complete v4.6.11
[INFO] [stderr]     Checking plotters-svg v0.3.7
[INFO] [stderr]     Checking itertools v0.13.0
[INFO] [stderr]     Checking execution-time v0.3.1
[INFO] [stderr]     Checking cast v0.3.0
[INFO] [stderr]     Checking glob v0.3.4
[INFO] [stderr]     Checking ttf-parser v0.20.0
[INFO] [stderr]     Checking colored v3.1.1
[INFO] [stderr]     Checking tinytemplate v1.2.1
[INFO] [stderr]     Checking page_size v0.6.0
[INFO] [stderr]     Checking oorandom v11.1.5
[INFO] [stderr]     Checking anes v0.1.6
[INFO] [stderr]     Checking serde-aux v4.7.0
[INFO] [stderr]     Checking rust_xlsxwriter v0.99.1
[INFO] [stderr]     Checking claudiofsr_lib v0.20.1
[INFO] [stderr]     Checking criterion-plot v0.8.2
[INFO] [stderr]     Checking plotters v0.3.7
[INFO] [stderr]     Checking half v2.7.1
[INFO] [stderr]     Checking ciborium-ll v0.2.2
[INFO] [stderr]     Checking ciborium v0.2.2
[INFO] [stderr]     Checking efd_contribuicoes v0.1.0 (/opt/rustwide/workdir)
[INFO] [stderr]     Checking criterion v0.8.2
[INFO] [stdout] error: useless conversion to the same type: `registro_0000::Registro0000`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_0000::Registro0000 as Into<registro_0000::Registro0000>::into(val) to avoid triggering this lint
[INFO] [stdout]     = note: `#[deny(self_type_conversion)]` on by default
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_0001::Registro0001`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_0001::Registro0001 as Into<registro_0001::Registro0001>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_0035::Registro0035`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_0035::Registro0035 as Into<registro_0035::Registro0035>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_0100::Registro0100`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_0100::Registro0100 as Into<registro_0100::Registro0100>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_0110::Registro0110`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_0110::Registro0110 as Into<registro_0110::Registro0110>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_0111::Registro0111`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_0111::Registro0111 as Into<registro_0111::Registro0111>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_0120::Registro0120`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_0120::Registro0120 as Into<registro_0120::Registro0120>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_0140::Registro0140`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_0140::Registro0140 as Into<registro_0140::Registro0140>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_0145::Registro0145`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_0145::Registro0145 as Into<registro_0145::Registro0145>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_0150::Registro0150`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_0150::Registro0150 as Into<registro_0150::Registro0150>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_0190::Registro0190`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_0190::Registro0190 as Into<registro_0190::Registro0190>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_0200::Registro0200`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_0200::Registro0200 as Into<registro_0200::Registro0200>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_0205::Registro0205`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_0205::Registro0205 as Into<registro_0205::Registro0205>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_0206::Registro0206`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_0206::Registro0206 as Into<registro_0206::Registro0206>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_0208::Registro0208`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_0208::Registro0208 as Into<registro_0208::Registro0208>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_0400::Registro0400`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_0400::Registro0400 as Into<registro_0400::Registro0400>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_0450::Registro0450`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_0450::Registro0450 as Into<registro_0450::Registro0450>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_0500::Registro0500`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_0500::Registro0500 as Into<registro_0500::Registro0500>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_0600::Registro0600`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_0600::Registro0600 as Into<registro_0600::Registro0600>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_0900::Registro0900`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_0900::Registro0900 as Into<registro_0900::Registro0900>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_0990::Registro0990`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_0990::Registro0990 as Into<registro_0990::Registro0990>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_1001::Registro1001`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_1001::Registro1001 as Into<registro_1001::Registro1001>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_1010::Registro1010`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_1010::Registro1010 as Into<registro_1010::Registro1010>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_1011::Registro1011`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_1011::Registro1011 as Into<registro_1011::Registro1011>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_1020::Registro1020`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_1020::Registro1020 as Into<registro_1020::Registro1020>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_1050::Registro1050`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_1050::Registro1050 as Into<registro_1050::Registro1050>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_1100::Registro1100`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_1100::Registro1100 as Into<registro_1100::Registro1100>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_1101::Registro1101`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_1101::Registro1101 as Into<registro_1101::Registro1101>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_1102::Registro1102`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_1102::Registro1102 as Into<registro_1102::Registro1102>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_1200::Registro1200`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_1200::Registro1200 as Into<registro_1200::Registro1200>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_1210::Registro1210`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_1210::Registro1210 as Into<registro_1210::Registro1210>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_1220::Registro1220`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_1220::Registro1220 as Into<registro_1220::Registro1220>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_1300::Registro1300`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_1300::Registro1300 as Into<registro_1300::Registro1300>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_1500::Registro1500`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_1500::Registro1500 as Into<registro_1500::Registro1500>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_1501::Registro1501`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_1501::Registro1501 as Into<registro_1501::Registro1501>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_1502::Registro1502`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_1502::Registro1502 as Into<registro_1502::Registro1502>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_1600::Registro1600`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_1600::Registro1600 as Into<registro_1600::Registro1600>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_1610::Registro1610`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_1610::Registro1610 as Into<registro_1610::Registro1610>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_1620::Registro1620`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_1620::Registro1620 as Into<registro_1620::Registro1620>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_1700::Registro1700`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_1700::Registro1700 as Into<registro_1700::Registro1700>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_1800::Registro1800`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_1800::Registro1800 as Into<registro_1800::Registro1800>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_1809::Registro1809`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_1809::Registro1809 as Into<registro_1809::Registro1809>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_1900::Registro1900`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_1900::Registro1900 as Into<registro_1900::Registro1900>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_1990::Registro1990`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_1990::Registro1990 as Into<registro_1990::Registro1990>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_a001::RegistroA001`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_a001::RegistroA001 as Into<registro_a001::RegistroA001>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_a010::RegistroA010`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_a010::RegistroA010 as Into<registro_a010::RegistroA010>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_a100::RegistroA100`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_a100::RegistroA100 as Into<registro_a100::RegistroA100>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_a110::RegistroA110`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_a110::RegistroA110 as Into<registro_a110::RegistroA110>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_a111::RegistroA111`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_a111::RegistroA111 as Into<registro_a111::RegistroA111>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_a120::RegistroA120`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_a120::RegistroA120 as Into<registro_a120::RegistroA120>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_a170::RegistroA170`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_a170::RegistroA170 as Into<registro_a170::RegistroA170>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_a990::RegistroA990`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_a990::RegistroA990 as Into<registro_a990::RegistroA990>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_c001::RegistroC001`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_c001::RegistroC001 as Into<registro_c001::RegistroC001>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_c010::RegistroC010`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_c010::RegistroC010 as Into<registro_c010::RegistroC010>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_c100::RegistroC100`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_c100::RegistroC100 as Into<registro_c100::RegistroC100>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_c110::RegistroC110`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_c110::RegistroC110 as Into<registro_c110::RegistroC110>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_c111::RegistroC111`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_c111::RegistroC111 as Into<registro_c111::RegistroC111>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_c120::RegistroC120`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_c120::RegistroC120 as Into<registro_c120::RegistroC120>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_c170::RegistroC170`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_c170::RegistroC170 as Into<registro_c170::RegistroC170>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_c175::RegistroC175`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_c175::RegistroC175 as Into<registro_c175::RegistroC175>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_c180::RegistroC180`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_c180::RegistroC180 as Into<registro_c180::RegistroC180>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_c181::RegistroC181`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_c181::RegistroC181 as Into<registro_c181::RegistroC181>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_c185::RegistroC185`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_c185::RegistroC185 as Into<registro_c185::RegistroC185>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_c188::RegistroC188`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_c188::RegistroC188 as Into<registro_c188::RegistroC188>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_c190::RegistroC190`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_c190::RegistroC190 as Into<registro_c190::RegistroC190>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_c191::RegistroC191`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_c191::RegistroC191 as Into<registro_c191::RegistroC191>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_c195::RegistroC195`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_c195::RegistroC195 as Into<registro_c195::RegistroC195>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_c198::RegistroC198`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_c198::RegistroC198 as Into<registro_c198::RegistroC198>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_c199::RegistroC199`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_c199::RegistroC199 as Into<registro_c199::RegistroC199>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_c380::RegistroC380`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_c380::RegistroC380 as Into<registro_c380::RegistroC380>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_c381::RegistroC381`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_c381::RegistroC381 as Into<registro_c381::RegistroC381>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_c385::RegistroC385`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_c385::RegistroC385 as Into<registro_c385::RegistroC385>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_c395::RegistroC395`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_c395::RegistroC395 as Into<registro_c395::RegistroC395>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_c396::RegistroC396`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_c396::RegistroC396 as Into<registro_c396::RegistroC396>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_c400::RegistroC400`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_c400::RegistroC400 as Into<registro_c400::RegistroC400>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_c405::RegistroC405`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_c405::RegistroC405 as Into<registro_c405::RegistroC405>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_c481::RegistroC481`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_c481::RegistroC481 as Into<registro_c481::RegistroC481>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_c485::RegistroC485`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_c485::RegistroC485 as Into<registro_c485::RegistroC485>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_c489::RegistroC489`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_c489::RegistroC489 as Into<registro_c489::RegistroC489>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_c490::RegistroC490`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_c490::RegistroC490 as Into<registro_c490::RegistroC490>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_c491::RegistroC491`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_c491::RegistroC491 as Into<registro_c491::RegistroC491>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_c495::RegistroC495`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_c495::RegistroC495 as Into<registro_c495::RegistroC495>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_c499::RegistroC499`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_c499::RegistroC499 as Into<registro_c499::RegistroC499>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_c500::RegistroC500`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_c500::RegistroC500 as Into<registro_c500::RegistroC500>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_c501::RegistroC501`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_c501::RegistroC501 as Into<registro_c501::RegistroC501>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_c505::RegistroC505`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_c505::RegistroC505 as Into<registro_c505::RegistroC505>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_c509::RegistroC509`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_c509::RegistroC509 as Into<registro_c509::RegistroC509>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_c600::RegistroC600`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_c600::RegistroC600 as Into<registro_c600::RegistroC600>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_c601::RegistroC601`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_c601::RegistroC601 as Into<registro_c601::RegistroC601>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_c605::RegistroC605`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_c605::RegistroC605 as Into<registro_c605::RegistroC605>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_c609::RegistroC609`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_c609::RegistroC609 as Into<registro_c609::RegistroC609>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_c800::RegistroC800`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_c800::RegistroC800 as Into<registro_c800::RegistroC800>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_c810::RegistroC810`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_c810::RegistroC810 as Into<registro_c810::RegistroC810>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_c820::RegistroC820`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_c820::RegistroC820 as Into<registro_c820::RegistroC820>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_c830::RegistroC830`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_c830::RegistroC830 as Into<registro_c830::RegistroC830>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_c860::RegistroC860`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_c860::RegistroC860 as Into<registro_c860::RegistroC860>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_c870::RegistroC870`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_c870::RegistroC870 as Into<registro_c870::RegistroC870>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_c880::RegistroC880`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_c880::RegistroC880 as Into<registro_c880::RegistroC880>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_c890::RegistroC890`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_c890::RegistroC890 as Into<registro_c890::RegistroC890>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_c990::RegistroC990`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_c990::RegistroC990 as Into<registro_c990::RegistroC990>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_d001::RegistroD001`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_d001::RegistroD001 as Into<registro_d001::RegistroD001>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_d010::RegistroD010`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_d010::RegistroD010 as Into<registro_d010::RegistroD010>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_d100::RegistroD100`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_d100::RegistroD100 as Into<registro_d100::RegistroD100>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_d101::RegistroD101`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_d101::RegistroD101 as Into<registro_d101::RegistroD101>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_d105::RegistroD105`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_d105::RegistroD105 as Into<registro_d105::RegistroD105>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_d111::RegistroD111`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_d111::RegistroD111 as Into<registro_d111::RegistroD111>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_d200::RegistroD200`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_d200::RegistroD200 as Into<registro_d200::RegistroD200>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_d201::RegistroD201`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_d201::RegistroD201 as Into<registro_d201::RegistroD201>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_d205::RegistroD205`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_d205::RegistroD205 as Into<registro_d205::RegistroD205>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_d209::RegistroD209`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_d209::RegistroD209 as Into<registro_d209::RegistroD209>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_d300::RegistroD300`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_d300::RegistroD300 as Into<registro_d300::RegistroD300>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_d309::RegistroD309`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_d309::RegistroD309 as Into<registro_d309::RegistroD309>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_d350::RegistroD350`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_d350::RegistroD350 as Into<registro_d350::RegistroD350>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_d359::RegistroD359`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_d359::RegistroD359 as Into<registro_d359::RegistroD359>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_d500::RegistroD500`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_d500::RegistroD500 as Into<registro_d500::RegistroD500>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_d501::RegistroD501`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_d501::RegistroD501 as Into<registro_d501::RegistroD501>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_d505::RegistroD505`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_d505::RegistroD505 as Into<registro_d505::RegistroD505>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_d509::RegistroD509`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_d509::RegistroD509 as Into<registro_d509::RegistroD509>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_d600::RegistroD600`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_d600::RegistroD600 as Into<registro_d600::RegistroD600>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_d601::RegistroD601`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_d601::RegistroD601 as Into<registro_d601::RegistroD601>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_d605::RegistroD605`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_d605::RegistroD605 as Into<registro_d605::RegistroD605>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_d609::RegistroD609`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_d609::RegistroD609 as Into<registro_d609::RegistroD609>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_d990::RegistroD990`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_d990::RegistroD990 as Into<registro_d990::RegistroD990>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_f001::RegistroF001`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_f001::RegistroF001 as Into<registro_f001::RegistroF001>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_f010::RegistroF010`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_f010::RegistroF010 as Into<registro_f010::RegistroF010>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_f100::RegistroF100`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_f100::RegistroF100 as Into<registro_f100::RegistroF100>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_f111::RegistroF111`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_f111::RegistroF111 as Into<registro_f111::RegistroF111>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_f120::RegistroF120`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_f120::RegistroF120 as Into<registro_f120::RegistroF120>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_f129::RegistroF129`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_f129::RegistroF129 as Into<registro_f129::RegistroF129>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_f130::RegistroF130`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_f130::RegistroF130 as Into<registro_f130::RegistroF130>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_f139::RegistroF139`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_f139::RegistroF139 as Into<registro_f139::RegistroF139>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_f150::RegistroF150`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_f150::RegistroF150 as Into<registro_f150::RegistroF150>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_f200::RegistroF200`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_f200::RegistroF200 as Into<registro_f200::RegistroF200>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_f205::RegistroF205`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_f205::RegistroF205 as Into<registro_f205::RegistroF205>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_f210::RegistroF210`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_f210::RegistroF210 as Into<registro_f210::RegistroF210>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_f211::RegistroF211`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_f211::RegistroF211 as Into<registro_f211::RegistroF211>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_f500::RegistroF500`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_f500::RegistroF500 as Into<registro_f500::RegistroF500>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_f509::RegistroF509`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_f509::RegistroF509 as Into<registro_f509::RegistroF509>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_f510::RegistroF510`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_f510::RegistroF510 as Into<registro_f510::RegistroF510>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_f519::RegistroF519`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_f519::RegistroF519 as Into<registro_f519::RegistroF519>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_f525::RegistroF525`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_f525::RegistroF525 as Into<registro_f525::RegistroF525>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_f550::RegistroF550`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_f550::RegistroF550 as Into<registro_f550::RegistroF550>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_f559::RegistroF559`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_f559::RegistroF559 as Into<registro_f559::RegistroF559>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_f560::RegistroF560`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_f560::RegistroF560 as Into<registro_f560::RegistroF560>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_f569::RegistroF569`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_f569::RegistroF569 as Into<registro_f569::RegistroF569>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_f600::RegistroF600`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_f600::RegistroF600 as Into<registro_f600::RegistroF600>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_f700::RegistroF700`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_f700::RegistroF700 as Into<registro_f700::RegistroF700>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_f800::RegistroF800`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_f800::RegistroF800 as Into<registro_f800::RegistroF800>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_f990::RegistroF990`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_f990::RegistroF990 as Into<registro_f990::RegistroF990>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_i001::RegistroI001`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_i001::RegistroI001 as Into<registro_i001::RegistroI001>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_i010::RegistroI010`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_i010::RegistroI010 as Into<registro_i010::RegistroI010>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_i100::RegistroI100`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_i100::RegistroI100 as Into<registro_i100::RegistroI100>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_i199::RegistroI199`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_i199::RegistroI199 as Into<registro_i199::RegistroI199>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_i200::RegistroI200`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_i200::RegistroI200 as Into<registro_i200::RegistroI200>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_i299::RegistroI299`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_i299::RegistroI299 as Into<registro_i299::RegistroI299>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_i300::RegistroI300`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_i300::RegistroI300 as Into<registro_i300::RegistroI300>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_i399::RegistroI399`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_i399::RegistroI399 as Into<registro_i399::RegistroI399>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_i990::RegistroI990`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_i990::RegistroI990 as Into<registro_i990::RegistroI990>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_m001::RegistroM001`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_m001::RegistroM001 as Into<registro_m001::RegistroM001>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_m100::RegistroM100`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_m100::RegistroM100 as Into<registro_m100::RegistroM100>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_m105::RegistroM105`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_m105::RegistroM105 as Into<registro_m105::RegistroM105>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_m110::RegistroM110`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_m110::RegistroM110 as Into<registro_m110::RegistroM110>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_m115::RegistroM115`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_m115::RegistroM115 as Into<registro_m115::RegistroM115>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_m200::RegistroM200`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_m200::RegistroM200 as Into<registro_m200::RegistroM200>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_m205::RegistroM205`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_m205::RegistroM205 as Into<registro_m205::RegistroM205>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_m211::RegistroM211`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_m211::RegistroM211 as Into<registro_m211::RegistroM211>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_m215::RegistroM215`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_m215::RegistroM215 as Into<registro_m215::RegistroM215>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_m220::RegistroM220`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_m220::RegistroM220 as Into<registro_m220::RegistroM220>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_m225::RegistroM225`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_m225::RegistroM225 as Into<registro_m225::RegistroM225>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_m230::RegistroM230`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_m230::RegistroM230 as Into<registro_m230::RegistroM230>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_m300::RegistroM300`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_m300::RegistroM300 as Into<registro_m300::RegistroM300>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_m350::RegistroM350`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_m350::RegistroM350 as Into<registro_m350::RegistroM350>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_m400::RegistroM400`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_m400::RegistroM400 as Into<registro_m400::RegistroM400>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_m410::RegistroM410`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_m410::RegistroM410 as Into<registro_m410::RegistroM410>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_m500::RegistroM500`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_m500::RegistroM500 as Into<registro_m500::RegistroM500>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_m505::RegistroM505`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_m505::RegistroM505 as Into<registro_m505::RegistroM505>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_m510::RegistroM510`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_m510::RegistroM510 as Into<registro_m510::RegistroM510>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_m515::RegistroM515`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_m515::RegistroM515 as Into<registro_m515::RegistroM515>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_m600::RegistroM600`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_m600::RegistroM600 as Into<registro_m600::RegistroM600>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_m605::RegistroM605`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_m605::RegistroM605 as Into<registro_m605::RegistroM605>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_m611::RegistroM611`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_m611::RegistroM611 as Into<registro_m611::RegistroM611>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_m615::RegistroM615`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_m615::RegistroM615 as Into<registro_m615::RegistroM615>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_m620::RegistroM620`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_m620::RegistroM620 as Into<registro_m620::RegistroM620>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_m625::RegistroM625`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_m625::RegistroM625 as Into<registro_m625::RegistroM625>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_m630::RegistroM630`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_m630::RegistroM630 as Into<registro_m630::RegistroM630>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_m700::RegistroM700`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_m700::RegistroM700 as Into<registro_m700::RegistroM700>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_m800::RegistroM800`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_m800::RegistroM800 as Into<registro_m800::RegistroM800>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_m810::RegistroM810`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_m810::RegistroM810 as Into<registro_m810::RegistroM810>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_m990::RegistroM990`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_m990::RegistroM990 as Into<registro_m990::RegistroM990>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_p001::RegistroP001`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_p001::RegistroP001 as Into<registro_p001::RegistroP001>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_p010::RegistroP010`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_p010::RegistroP010 as Into<registro_p010::RegistroP010>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_p100::RegistroP100`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_p100::RegistroP100 as Into<registro_p100::RegistroP100>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_p110::RegistroP110`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_p110::RegistroP110 as Into<registro_p110::RegistroP110>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_p199::RegistroP199`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_p199::RegistroP199 as Into<registro_p199::RegistroP199>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_p200::RegistroP200`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_p200::RegistroP200 as Into<registro_p200::RegistroP200>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_p210::RegistroP210`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_p210::RegistroP210 as Into<registro_p210::RegistroP210>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_p990::RegistroP990`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_p990::RegistroP990 as Into<registro_p990::RegistroP990>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_9001::Registro9001`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_9001::Registro9001 as Into<registro_9001::Registro9001>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_9900::Registro9900`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_9900::Registro9900 as Into<registro_9900::Registro9900>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_9990::Registro9990`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_9990::Registro9990 as Into<registro_9990::Registro9990>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_9999::Registro9999`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_9999::Registro9999 as Into<registro_9999::Registro9999>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_m210_antigo::RegistroM210Antigo`
[INFO] [stdout]    --> src/macros.rs:72:88
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  72 |                           $crate::SpedRecord::$bloco_name(Box::new($bloco_name::$reg_old(parsed.into())))
[INFO] [stdout]     |                                                                                          ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_m210_antigo::RegistroM210Antigo as Into<registro_m210_antigo::RegistroM210Antigo>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_m210::RegistroM210`
[INFO] [stdout]    --> src/macros.rs:75:88
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  75 |                           $crate::SpedRecord::$bloco_name(Box::new($bloco_name::$reg_new(parsed.into())))
[INFO] [stdout]     |                                                                                          ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_m210::RegistroM210 as Into<registro_m210::RegistroM210>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_m610_antigo::RegistroM610Antigo`
[INFO] [stdout]    --> src/macros.rs:72:88
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  72 |                           $crate::SpedRecord::$bloco_name(Box::new($bloco_name::$reg_old(parsed.into())))
[INFO] [stdout]     |                                                                                          ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_m610_antigo::RegistroM610Antigo as Into<registro_m610_antigo::RegistroM610Antigo>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_m610::RegistroM610`
[INFO] [stdout]    --> src/macros.rs:75:88
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  75 |                           $crate::SpedRecord::$bloco_name(Box::new($bloco_name::$reg_new(parsed.into())))
[INFO] [stdout]     |                                                                                          ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_m610::RegistroM610 as Into<registro_m610::RegistroM610>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stderr] error: could not compile `efd_contribuicoes` (lib) due to 205 previous errors
[INFO] [stderr] warning: build failed, waiting for other jobs to finish...
[INFO] [stdout] error: useless conversion to the same type: `registro_0000::Registro0000`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_0000::Registro0000 as Into<registro_0000::Registro0000>::into(val) to avoid triggering this lint
[INFO] [stdout]     = note: `#[deny(self_type_conversion)]` on by default
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_0001::Registro0001`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_0001::Registro0001 as Into<registro_0001::Registro0001>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_0035::Registro0035`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_0035::Registro0035 as Into<registro_0035::Registro0035>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_0100::Registro0100`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_0100::Registro0100 as Into<registro_0100::Registro0100>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_0110::Registro0110`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_0110::Registro0110 as Into<registro_0110::Registro0110>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_0111::Registro0111`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_0111::Registro0111 as Into<registro_0111::Registro0111>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_0120::Registro0120`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_0120::Registro0120 as Into<registro_0120::Registro0120>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_0140::Registro0140`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_0140::Registro0140 as Into<registro_0140::Registro0140>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_0145::Registro0145`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_0145::Registro0145 as Into<registro_0145::Registro0145>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_0150::Registro0150`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_0150::Registro0150 as Into<registro_0150::Registro0150>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_0190::Registro0190`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_0190::Registro0190 as Into<registro_0190::Registro0190>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_0200::Registro0200`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_0200::Registro0200 as Into<registro_0200::Registro0200>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_0205::Registro0205`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_0205::Registro0205 as Into<registro_0205::Registro0205>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_0206::Registro0206`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_0206::Registro0206 as Into<registro_0206::Registro0206>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_0208::Registro0208`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_0208::Registro0208 as Into<registro_0208::Registro0208>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_0400::Registro0400`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_0400::Registro0400 as Into<registro_0400::Registro0400>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_0450::Registro0450`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_0450::Registro0450 as Into<registro_0450::Registro0450>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_0500::Registro0500`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_0500::Registro0500 as Into<registro_0500::Registro0500>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_0600::Registro0600`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_0600::Registro0600 as Into<registro_0600::Registro0600>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_0900::Registro0900`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_0900::Registro0900 as Into<registro_0900::Registro0900>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_0990::Registro0990`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_0990::Registro0990 as Into<registro_0990::Registro0990>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_1001::Registro1001`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_1001::Registro1001 as Into<registro_1001::Registro1001>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_1010::Registro1010`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_1010::Registro1010 as Into<registro_1010::Registro1010>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_1011::Registro1011`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_1011::Registro1011 as Into<registro_1011::Registro1011>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_1020::Registro1020`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_1020::Registro1020 as Into<registro_1020::Registro1020>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_1050::Registro1050`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_1050::Registro1050 as Into<registro_1050::Registro1050>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_1100::Registro1100`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_1100::Registro1100 as Into<registro_1100::Registro1100>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_1101::Registro1101`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_1101::Registro1101 as Into<registro_1101::Registro1101>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_1102::Registro1102`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_1102::Registro1102 as Into<registro_1102::Registro1102>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_1200::Registro1200`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_1200::Registro1200 as Into<registro_1200::Registro1200>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_1210::Registro1210`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_1210::Registro1210 as Into<registro_1210::Registro1210>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_1220::Registro1220`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_1220::Registro1220 as Into<registro_1220::Registro1220>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_1300::Registro1300`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_1300::Registro1300 as Into<registro_1300::Registro1300>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_1500::Registro1500`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_1500::Registro1500 as Into<registro_1500::Registro1500>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_1501::Registro1501`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_1501::Registro1501 as Into<registro_1501::Registro1501>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_1502::Registro1502`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_1502::Registro1502 as Into<registro_1502::Registro1502>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_1600::Registro1600`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_1600::Registro1600 as Into<registro_1600::Registro1600>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_1610::Registro1610`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_1610::Registro1610 as Into<registro_1610::Registro1610>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_1620::Registro1620`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_1620::Registro1620 as Into<registro_1620::Registro1620>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_1700::Registro1700`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_1700::Registro1700 as Into<registro_1700::Registro1700>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_1800::Registro1800`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_1800::Registro1800 as Into<registro_1800::Registro1800>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_1809::Registro1809`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_1809::Registro1809 as Into<registro_1809::Registro1809>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_1900::Registro1900`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_1900::Registro1900 as Into<registro_1900::Registro1900>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_1990::Registro1990`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_1990::Registro1990 as Into<registro_1990::Registro1990>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_a001::RegistroA001`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_a001::RegistroA001 as Into<registro_a001::RegistroA001>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_a010::RegistroA010`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_a010::RegistroA010 as Into<registro_a010::RegistroA010>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_a100::RegistroA100`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_a100::RegistroA100 as Into<registro_a100::RegistroA100>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_a110::RegistroA110`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_a110::RegistroA110 as Into<registro_a110::RegistroA110>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_a111::RegistroA111`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_a111::RegistroA111 as Into<registro_a111::RegistroA111>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_a120::RegistroA120`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_a120::RegistroA120 as Into<registro_a120::RegistroA120>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_a170::RegistroA170`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_a170::RegistroA170 as Into<registro_a170::RegistroA170>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_a990::RegistroA990`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_a990::RegistroA990 as Into<registro_a990::RegistroA990>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_c001::RegistroC001`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_c001::RegistroC001 as Into<registro_c001::RegistroC001>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_c010::RegistroC010`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_c010::RegistroC010 as Into<registro_c010::RegistroC010>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_c100::RegistroC100`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_c100::RegistroC100 as Into<registro_c100::RegistroC100>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_c110::RegistroC110`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_c110::RegistroC110 as Into<registro_c110::RegistroC110>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_c111::RegistroC111`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_c111::RegistroC111 as Into<registro_c111::RegistroC111>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_c120::RegistroC120`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_c120::RegistroC120 as Into<registro_c120::RegistroC120>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_c170::RegistroC170`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_c170::RegistroC170 as Into<registro_c170::RegistroC170>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_c175::RegistroC175`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_c175::RegistroC175 as Into<registro_c175::RegistroC175>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_c180::RegistroC180`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_c180::RegistroC180 as Into<registro_c180::RegistroC180>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_c181::RegistroC181`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_c181::RegistroC181 as Into<registro_c181::RegistroC181>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_c185::RegistroC185`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_c185::RegistroC185 as Into<registro_c185::RegistroC185>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_c188::RegistroC188`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_c188::RegistroC188 as Into<registro_c188::RegistroC188>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_c190::RegistroC190`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_c190::RegistroC190 as Into<registro_c190::RegistroC190>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_c191::RegistroC191`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_c191::RegistroC191 as Into<registro_c191::RegistroC191>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_c195::RegistroC195`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_c195::RegistroC195 as Into<registro_c195::RegistroC195>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_c198::RegistroC198`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_c198::RegistroC198 as Into<registro_c198::RegistroC198>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_c199::RegistroC199`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_c199::RegistroC199 as Into<registro_c199::RegistroC199>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_c380::RegistroC380`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_c380::RegistroC380 as Into<registro_c380::RegistroC380>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_c381::RegistroC381`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_c381::RegistroC381 as Into<registro_c381::RegistroC381>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_c385::RegistroC385`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_c385::RegistroC385 as Into<registro_c385::RegistroC385>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_c395::RegistroC395`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_c395::RegistroC395 as Into<registro_c395::RegistroC395>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_c396::RegistroC396`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_c396::RegistroC396 as Into<registro_c396::RegistroC396>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_c400::RegistroC400`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_c400::RegistroC400 as Into<registro_c400::RegistroC400>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_c405::RegistroC405`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_c405::RegistroC405 as Into<registro_c405::RegistroC405>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_c481::RegistroC481`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_c481::RegistroC481 as Into<registro_c481::RegistroC481>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_c485::RegistroC485`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_c485::RegistroC485 as Into<registro_c485::RegistroC485>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_c489::RegistroC489`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_c489::RegistroC489 as Into<registro_c489::RegistroC489>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_c490::RegistroC490`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_c490::RegistroC490 as Into<registro_c490::RegistroC490>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_c491::RegistroC491`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_c491::RegistroC491 as Into<registro_c491::RegistroC491>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_c495::RegistroC495`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_c495::RegistroC495 as Into<registro_c495::RegistroC495>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_c499::RegistroC499`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_c499::RegistroC499 as Into<registro_c499::RegistroC499>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_c500::RegistroC500`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_c500::RegistroC500 as Into<registro_c500::RegistroC500>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_c501::RegistroC501`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_c501::RegistroC501 as Into<registro_c501::RegistroC501>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_c505::RegistroC505`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_c505::RegistroC505 as Into<registro_c505::RegistroC505>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_c509::RegistroC509`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_c509::RegistroC509 as Into<registro_c509::RegistroC509>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_c600::RegistroC600`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_c600::RegistroC600 as Into<registro_c600::RegistroC600>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_c601::RegistroC601`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_c601::RegistroC601 as Into<registro_c601::RegistroC601>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_c605::RegistroC605`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_c605::RegistroC605 as Into<registro_c605::RegistroC605>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_c609::RegistroC609`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_c609::RegistroC609 as Into<registro_c609::RegistroC609>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_c800::RegistroC800`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_c800::RegistroC800 as Into<registro_c800::RegistroC800>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_c810::RegistroC810`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_c810::RegistroC810 as Into<registro_c810::RegistroC810>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_c820::RegistroC820`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_c820::RegistroC820 as Into<registro_c820::RegistroC820>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_c830::RegistroC830`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_c830::RegistroC830 as Into<registro_c830::RegistroC830>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_c860::RegistroC860`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_c860::RegistroC860 as Into<registro_c860::RegistroC860>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_c870::RegistroC870`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_c870::RegistroC870 as Into<registro_c870::RegistroC870>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_c880::RegistroC880`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_c880::RegistroC880 as Into<registro_c880::RegistroC880>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_c890::RegistroC890`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_c890::RegistroC890 as Into<registro_c890::RegistroC890>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_c990::RegistroC990`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_c990::RegistroC990 as Into<registro_c990::RegistroC990>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_d001::RegistroD001`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_d001::RegistroD001 as Into<registro_d001::RegistroD001>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_d010::RegistroD010`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_d010::RegistroD010 as Into<registro_d010::RegistroD010>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_d100::RegistroD100`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_d100::RegistroD100 as Into<registro_d100::RegistroD100>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_d101::RegistroD101`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_d101::RegistroD101 as Into<registro_d101::RegistroD101>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_d105::RegistroD105`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_d105::RegistroD105 as Into<registro_d105::RegistroD105>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_d111::RegistroD111`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_d111::RegistroD111 as Into<registro_d111::RegistroD111>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_d200::RegistroD200`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_d200::RegistroD200 as Into<registro_d200::RegistroD200>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_d201::RegistroD201`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_d201::RegistroD201 as Into<registro_d201::RegistroD201>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_d205::RegistroD205`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_d205::RegistroD205 as Into<registro_d205::RegistroD205>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_d209::RegistroD209`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_d209::RegistroD209 as Into<registro_d209::RegistroD209>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_d300::RegistroD300`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_d300::RegistroD300 as Into<registro_d300::RegistroD300>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_d309::RegistroD309`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_d309::RegistroD309 as Into<registro_d309::RegistroD309>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_d350::RegistroD350`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_d350::RegistroD350 as Into<registro_d350::RegistroD350>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_d359::RegistroD359`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_d359::RegistroD359 as Into<registro_d359::RegistroD359>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_d500::RegistroD500`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_d500::RegistroD500 as Into<registro_d500::RegistroD500>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_d501::RegistroD501`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_d501::RegistroD501 as Into<registro_d501::RegistroD501>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_d505::RegistroD505`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_d505::RegistroD505 as Into<registro_d505::RegistroD505>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_d509::RegistroD509`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_d509::RegistroD509 as Into<registro_d509::RegistroD509>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_d600::RegistroD600`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_d600::RegistroD600 as Into<registro_d600::RegistroD600>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_d601::RegistroD601`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_d601::RegistroD601 as Into<registro_d601::RegistroD601>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_d605::RegistroD605`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_d605::RegistroD605 as Into<registro_d605::RegistroD605>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_d609::RegistroD609`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_d609::RegistroD609 as Into<registro_d609::RegistroD609>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_d990::RegistroD990`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_d990::RegistroD990 as Into<registro_d990::RegistroD990>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_f001::RegistroF001`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_f001::RegistroF001 as Into<registro_f001::RegistroF001>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_f010::RegistroF010`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_f010::RegistroF010 as Into<registro_f010::RegistroF010>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_f100::RegistroF100`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_f100::RegistroF100 as Into<registro_f100::RegistroF100>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_f111::RegistroF111`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_f111::RegistroF111 as Into<registro_f111::RegistroF111>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_f120::RegistroF120`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_f120::RegistroF120 as Into<registro_f120::RegistroF120>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_f129::RegistroF129`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_f129::RegistroF129 as Into<registro_f129::RegistroF129>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_f130::RegistroF130`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_f130::RegistroF130 as Into<registro_f130::RegistroF130>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_f139::RegistroF139`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_f139::RegistroF139 as Into<registro_f139::RegistroF139>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_f150::RegistroF150`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_f150::RegistroF150 as Into<registro_f150::RegistroF150>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_f200::RegistroF200`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_f200::RegistroF200 as Into<registro_f200::RegistroF200>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_f205::RegistroF205`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_f205::RegistroF205 as Into<registro_f205::RegistroF205>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_f210::RegistroF210`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_f210::RegistroF210 as Into<registro_f210::RegistroF210>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_f211::RegistroF211`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_f211::RegistroF211 as Into<registro_f211::RegistroF211>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_f500::RegistroF500`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_f500::RegistroF500 as Into<registro_f500::RegistroF500>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_f509::RegistroF509`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_f509::RegistroF509 as Into<registro_f509::RegistroF509>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_f510::RegistroF510`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_f510::RegistroF510 as Into<registro_f510::RegistroF510>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_f519::RegistroF519`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_f519::RegistroF519 as Into<registro_f519::RegistroF519>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_f525::RegistroF525`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_f525::RegistroF525 as Into<registro_f525::RegistroF525>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_f550::RegistroF550`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_f550::RegistroF550 as Into<registro_f550::RegistroF550>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_f559::RegistroF559`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_f559::RegistroF559 as Into<registro_f559::RegistroF559>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_f560::RegistroF560`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_f560::RegistroF560 as Into<registro_f560::RegistroF560>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_f569::RegistroF569`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_f569::RegistroF569 as Into<registro_f569::RegistroF569>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_f600::RegistroF600`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_f600::RegistroF600 as Into<registro_f600::RegistroF600>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_f700::RegistroF700`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_f700::RegistroF700 as Into<registro_f700::RegistroF700>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_f800::RegistroF800`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_f800::RegistroF800 as Into<registro_f800::RegistroF800>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_f990::RegistroF990`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_f990::RegistroF990 as Into<registro_f990::RegistroF990>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_i001::RegistroI001`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_i001::RegistroI001 as Into<registro_i001::RegistroI001>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_i010::RegistroI010`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_i010::RegistroI010 as Into<registro_i010::RegistroI010>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_i100::RegistroI100`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_i100::RegistroI100 as Into<registro_i100::RegistroI100>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_i199::RegistroI199`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_i199::RegistroI199 as Into<registro_i199::RegistroI199>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_i200::RegistroI200`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_i200::RegistroI200 as Into<registro_i200::RegistroI200>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_i299::RegistroI299`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_i299::RegistroI299 as Into<registro_i299::RegistroI299>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_i300::RegistroI300`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_i300::RegistroI300 as Into<registro_i300::RegistroI300>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_i399::RegistroI399`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_i399::RegistroI399 as Into<registro_i399::RegistroI399>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_i990::RegistroI990`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_i990::RegistroI990 as Into<registro_i990::RegistroI990>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_m001::RegistroM001`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_m001::RegistroM001 as Into<registro_m001::RegistroM001>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_m100::RegistroM100`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_m100::RegistroM100 as Into<registro_m100::RegistroM100>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_m105::RegistroM105`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_m105::RegistroM105 as Into<registro_m105::RegistroM105>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_m110::RegistroM110`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_m110::RegistroM110 as Into<registro_m110::RegistroM110>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_m115::RegistroM115`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_m115::RegistroM115 as Into<registro_m115::RegistroM115>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_m200::RegistroM200`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_m200::RegistroM200 as Into<registro_m200::RegistroM200>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_m205::RegistroM205`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_m205::RegistroM205 as Into<registro_m205::RegistroM205>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_m211::RegistroM211`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_m211::RegistroM211 as Into<registro_m211::RegistroM211>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_m215::RegistroM215`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_m215::RegistroM215 as Into<registro_m215::RegistroM215>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_m220::RegistroM220`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_m220::RegistroM220 as Into<registro_m220::RegistroM220>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_m225::RegistroM225`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_m225::RegistroM225 as Into<registro_m225::RegistroM225>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_m230::RegistroM230`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_m230::RegistroM230 as Into<registro_m230::RegistroM230>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_m300::RegistroM300`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_m300::RegistroM300 as Into<registro_m300::RegistroM300>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_m350::RegistroM350`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_m350::RegistroM350 as Into<registro_m350::RegistroM350>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_m400::RegistroM400`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_m400::RegistroM400 as Into<registro_m400::RegistroM400>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_m410::RegistroM410`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_m410::RegistroM410 as Into<registro_m410::RegistroM410>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_m500::RegistroM500`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_m500::RegistroM500 as Into<registro_m500::RegistroM500>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_m505::RegistroM505`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_m505::RegistroM505 as Into<registro_m505::RegistroM505>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_m510::RegistroM510`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_m510::RegistroM510 as Into<registro_m510::RegistroM510>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_m515::RegistroM515`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_m515::RegistroM515 as Into<registro_m515::RegistroM515>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_m600::RegistroM600`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_m600::RegistroM600 as Into<registro_m600::RegistroM600>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_m605::RegistroM605`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_m605::RegistroM605 as Into<registro_m605::RegistroM605>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_m611::RegistroM611`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_m611::RegistroM611 as Into<registro_m611::RegistroM611>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_m615::RegistroM615`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_m615::RegistroM615 as Into<registro_m615::RegistroM615>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_m620::RegistroM620`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_m620::RegistroM620 as Into<registro_m620::RegistroM620>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_m625::RegistroM625`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_m625::RegistroM625 as Into<registro_m625::RegistroM625>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_m630::RegistroM630`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_m630::RegistroM630 as Into<registro_m630::RegistroM630>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_m700::RegistroM700`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_m700::RegistroM700 as Into<registro_m700::RegistroM700>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_m800::RegistroM800`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_m800::RegistroM800 as Into<registro_m800::RegistroM800>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_m810::RegistroM810`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_m810::RegistroM810 as Into<registro_m810::RegistroM810>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_m990::RegistroM990`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_m990::RegistroM990 as Into<registro_m990::RegistroM990>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_p001::RegistroP001`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_p001::RegistroP001 as Into<registro_p001::RegistroP001>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_p010::RegistroP010`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_p010::RegistroP010 as Into<registro_p010::RegistroP010>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_p100::RegistroP100`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_p100::RegistroP100 as Into<registro_p100::RegistroP100>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_p110::RegistroP110`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_p110::RegistroP110 as Into<registro_p110::RegistroP110>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_p199::RegistroP199`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_p199::RegistroP199 as Into<registro_p199::RegistroP199>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_p200::RegistroP200`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_p200::RegistroP200 as Into<registro_p200::RegistroP200>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_p210::RegistroP210`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_p210::RegistroP210 as Into<registro_p210::RegistroP210>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_p990::RegistroP990`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_p990::RegistroP990 as Into<registro_p990::RegistroP990>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_9001::Registro9001`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_9001::Registro9001 as Into<registro_9001::Registro9001>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_9900::Registro9900`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_9900::Registro9900 as Into<registro_9900::Registro9900>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_9990::Registro9990`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_9990::Registro9990 as Into<registro_9990::Registro9990>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_9999::Registro9999`
[INFO] [stdout]    --> src/macros.rs:65:83
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  65 |                       Ok(Some($crate::SpedRecord::$bloco(Box::new($bloco::$registro(parsed.into())))))
[INFO] [stdout]     |                                                                                     ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_9999::Registro9999 as Into<registro_9999::Registro9999>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_m210_antigo::RegistroM210Antigo`
[INFO] [stdout]    --> src/macros.rs:72:88
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  72 |                           $crate::SpedRecord::$bloco_name(Box::new($bloco_name::$reg_old(parsed.into())))
[INFO] [stdout]     |                                                                                          ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_m210_antigo::RegistroM210Antigo as Into<registro_m210_antigo::RegistroM210Antigo>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_m210::RegistroM210`
[INFO] [stdout]    --> src/macros.rs:75:88
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  75 |                           $crate::SpedRecord::$bloco_name(Box::new($bloco_name::$reg_new(parsed.into())))
[INFO] [stdout]     |                                                                                          ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_m210::RegistroM210 as Into<registro_m210::RegistroM210>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_m610_antigo::RegistroM610Antigo`
[INFO] [stdout]    --> src/macros.rs:72:88
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  72 |                           $crate::SpedRecord::$bloco_name(Box::new($bloco_name::$reg_old(parsed.into())))
[INFO] [stdout]     |                                                                                          ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_m610_antigo::RegistroM610Antigo as Into<registro_m610_antigo::RegistroM610Antigo>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `registro_m610::RegistroM610`
[INFO] [stdout]    --> src/macros.rs:75:88
[INFO] [stdout]     |
[INFO] [stdout]  55 |   macro_rules! dispatch_sped_parsers {
[INFO] [stdout] ...
[INFO] [stdout]  75 |                           $crate::SpedRecord::$bloco_name(Box::new($bloco_name::$reg_new(parsed.into())))
[INFO] [stdout]     |                                                                                          ^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/parser.rs:51:5
[INFO] [stdout]     |
[INFO] [stdout]  51 | /     dispatch_sped_parsers!(
[INFO] [stdout]  52 | |         registro_uppercase, // Passamos o &str normalizado (ex: "C100")
[INFO] [stdout]  53 | |         file_path,
[INFO] [stdout]  54 | |         line_number,
[INFO] [stdout] ...   |
[INFO] [stdout] 186 | |     )
[INFO] [stdout]     | |_____- in this macro invocation
[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: you can instead use the fully-qualified path `<registro_m610::RegistroM610 as Into<registro_m610::RegistroM610>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stderr] error: could not compile `efd_contribuicoes` (lib test) due to 205 previous errors
[INFO] running `Command { std: "docker" "inspect" "1f98edef3ac4e579cea54d9ee8417e1a3e1e85c63a2d3c842cef088fc9d0e42d", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "rm" "-f" "1f98edef3ac4e579cea54d9ee8417e1a3e1e85c63a2d3c842cef088fc9d0e42d", kill_on_drop: false }`
[INFO] [stdout] 1f98edef3ac4e579cea54d9ee8417e1a3e1e85c63a2d3c842cef088fc9d0e42d
