diff --git a/Cargo.toml b/Cargo.toml
index 82020ecb9..1e86dc9ee 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -4,4 +4,5 @@ members = ["borsh", "borsh-derive", "fuzz/fuzz-run", "benchmarks"]
 [workspace.package]
 # shared version of all public crates in the workspace
 version = "1.5.1"
+# rust-version = "1.67.0"
 rust-version = "1.81.0"
diff --git a/borsh-derive/src/internals/attributes/item/mod.rs b/borsh-derive/src/internals/attributes/item/mod.rs
index b52f04b47..c509a6d85 100644
--- a/borsh-derive/src/internals/attributes/item/mod.rs
+++ b/borsh-derive/src/internals/attributes/item/mod.rs
@@ -36,6 +36,12 @@ pub fn check_attributes(derive_input: &DeriveInput) -> Result<(), Error> {
 }
 
 pub(crate) fn contains_use_discriminant(input: &ItemEnum) -> Result<bool, syn::Error> {
+    if input.variants.len() > 256 {
+        return Err(syn::Error::new(
+            input.span(),
+            "up to 256 enum variants are supported",
+        ));
+    }    
     let attrs: &Vec<Attribute> = &input.attrs;
     let mut use_discriminant = None;
     let attr = attrs.iter().find(|attr| attr.path() == BORSH);
@@ -75,14 +81,13 @@ pub(crate) fn contains_use_discriminant(input: &ItemEnum) -> Result<bool, syn::E
     Ok(use_discriminant.unwrap_or(false))
 }
 
-pub(crate) fn get_may_be_repr(inpute: &ItemEnum) -> Result<Option<(TypePath, Span)>, syn::Error> {
-    inpute
+pub(crate) fn get_maybe_rust_repr(input: &ItemEnum) -> Option<(TypePath, Span)> {
+    input
         .attrs
         .iter()
         .find(|attr| attr.path() == RUST_REPR)
-        .map(|attr| attr.parse_args::<TypePath>().map(|value| (attr, value)))
-        .transpose()
-        .map(|(attr, value)| value.map(|value| (value, attr.unwrap().span())))
+        .map(|attr| attr.parse_args::<TypePath>().map(|value| (attr, value)).unwrap())
+        .map(|(attr, value)| (value, attr.span()))
 }
 
 pub(crate) fn get_maybe_borsh_tag_width(
diff --git a/borsh-derive/src/internals/attributes/item/snapshots/check_attrs_borsh_invalid_on_whole_item.snap.new b/borsh-derive/src/internals/attributes/item/snapshots/check_attrs_borsh_invalid_on_whole_item.snap.new
index 8fa731ca6..2df21661a 100644
--- a/borsh-derive/src/internals/attributes/item/snapshots/check_attrs_borsh_invalid_on_whole_item.snap.new
+++ b/borsh-derive/src/internals/attributes/item/snapshots/check_attrs_borsh_invalid_on_whole_item.snap.new
@@ -1,6 +1,6 @@
 ---
 source: borsh-derive/src/internals/attributes/item/mod.rs
-assertion_line: 247
+assertion_line: 262
 expression: actual.unwrap_err()
 ---
 Error(
diff --git a/borsh-derive/src/internals/attributes/item/snapshots/check_attrs_borsh_skip_on_whole_item.snap.new b/borsh-derive/src/internals/attributes/item/snapshots/check_attrs_borsh_skip_on_whole_item.snap.new
index 564043c35..8c6579af7 100644
--- a/borsh-derive/src/internals/attributes/item/snapshots/check_attrs_borsh_skip_on_whole_item.snap.new
+++ b/borsh-derive/src/internals/attributes/item/snapshots/check_attrs_borsh_skip_on_whole_item.snap.new
@@ -1,6 +1,6 @@
 ---
 source: borsh-derive/src/internals/attributes/item/mod.rs
-assertion_line: 233
+assertion_line: 248
 expression: actual.unwrap_err()
 ---
 Error(
diff --git a/borsh-derive/src/internals/attributes/item/snapshots/check_attrs_init_function_wrong_format.snap.new b/borsh-derive/src/internals/attributes/item/snapshots/check_attrs_init_function_wrong_format.snap.new
index a55fa171c..d89523db6 100644
--- a/borsh-derive/src/internals/attributes/item/snapshots/check_attrs_init_function_wrong_format.snap.new
+++ b/borsh-derive/src/internals/attributes/item/snapshots/check_attrs_init_function_wrong_format.snap.new
@@ -1,6 +1,6 @@
 ---
 source: borsh-derive/src/internals/attributes/item/mod.rs
-assertion_line: 332
+assertion_line: 347
 expression: actual.unwrap_err()
 ---
 Error(
diff --git a/borsh-derive/src/internals/deserialize/enums/mod.rs b/borsh-derive/src/internals/deserialize/enums/mod.rs
index 54bda9c89..8a65c26c1 100644
--- a/borsh-derive/src/internals/deserialize/enums/mod.rs
+++ b/borsh-derive/src/internals/deserialize/enums/mod.rs
@@ -12,22 +12,17 @@ pub fn process(input: &ItemEnum, cratename: Path) -> syn::Result<TokenStream2> {
     let mut variant_arms = TokenStream2::new();
     let use_discriminant = item::contains_use_discriminant(input)?;
     let maybe_borsh_tag_width = item::get_maybe_borsh_tag_width(input)?;
-    let discriminants = Discriminants::new(&input.variants, maybe_borsh_tag_width)?;
+    let maybe_rust_repr = item::get_maybe_rust_repr(input);
+    let discriminants = Discriminants::new(&input.variants, maybe_borsh_tag_width, maybe_rust_repr, use_discriminant)?;
     let mut generics_output = deserialize::GenericsOutput::new(&generics);
     let discriminant_type = discriminants.discriminant_type();
     for (variant_idx, variant) in input.variants.iter().enumerate() {
         let variant_body = process_variant(variant, &cratename, &mut generics_output)?;
         let variant_ident = &variant.ident;
 
-        let discriminant_value = discriminants.get(variant_ident, use_discriminant, variant_idx)?;
+        let discriminant_value = discriminants.get(variant_ident, variant_idx)?;
         variant_arms.extend(quote! {
-            if TryInto::<(#discriminant_type)>::try_into(variant_tag).map_err(|_|
-                return #cratename::io::Error::new(
-                    #cratename::io::ErrorKind::InvalidData,
-                    #cratename::__private::maybestd::format!("Unexpected variant tag: {:?}", variant_tag),
-                )
-            )?
-                 == #discriminant_value { #name::#variant_ident #variant_body } else
+            if variant_tag == #discriminant_value { #name::#variant_ident #variant_body } else
         });
     }
     let init = if let Some(method_ident) = item::contains_initialize_with(&input.attrs)? {
@@ -39,36 +34,35 @@ pub fn process(input: &ItemEnum, cratename: Path) -> syn::Result<TokenStream2> {
     };
     generics_output.extend(&mut where_clause, &cratename);
 
-    let x = quote! {
+    let deserialize_variant = quote! {
+        let mut return_value =
+            #variant_arms {
+                return Err(#cratename::io::Error::new(
+                    #cratename::io::ErrorKind::InvalidData,
+                    #cratename::__private::maybestd::format!("Unexpected variant tag: {:?}", variant_tag),
+                ))
+            };
+        #init
+        Ok(return_value)
+    };
+
+    Ok(quote! {
         impl #impl_generics #cratename::de::BorshDeserialize for #name #ty_generics #where_clause {
             fn deserialize_reader<__R: #cratename::io::Read>(reader: &mut __R) -> ::core::result::Result<Self, #cratename::io::Error> {
-                let tag = <#discriminant_type as #cratename::de::BorshDeserialize>::deserialize_reader(reader)?;
-                <Self as #cratename::de::EnumExt>::deserialize_variant::<_, #discriminant_type>(reader, tag)
+                let variant_tag = <#discriminant_type as #cratename::de::BorshDeserialize>::deserialize_reader(reader)?;
+                #deserialize_variant
             }
         }
 
         impl #impl_generics #cratename::de::EnumExt for #name #ty_generics #where_clause {
-            fn deserialize_variant<__R: #cratename::io::Read,
-            Tag: borsh::BorshDeserialize + ::core::fmt::Debug + Eq
-            + ::core::convert::TryInto<u16> + ::core::convert::TryInto<u8> + Copy
-            >(
+            fn deserialize_variant<__R: #cratename::io::Read>(
                 reader: &mut __R,
-                variant_tag: Tag,
+                variant_tag: u8,
             ) -> ::core::result::Result<Self, #cratename::io::Error> {
-                use ::core::convert::TryInto;
-                let mut return_value =
-                    #variant_arms {
-                    return Err(#cratename::io::Error::new(
-                        #cratename::io::ErrorKind::InvalidData,
-                        #cratename::__private::maybestd::format!("Unexpected variant tag: {:?}", variant_tag),
-                    ))
-                };
-                #init
-                Ok(return_value)
+                #deserialize_variant
             }
         }
-    };
-    Ok(x)
+    })
 }
 
 fn process_variant(
diff --git a/borsh-derive/src/internals/deserialize/enums/snapshots/borsh_discriminant_false.snap.new b/borsh-derive/src/internals/deserialize/enums/snapshots/borsh_discriminant_false.snap.new
index 48a81d477..563b04198 100644
--- a/borsh-derive/src/internals/deserialize/enums/snapshots/borsh_discriminant_false.snap.new
+++ b/borsh-derive/src/internals/deserialize/enums/snapshots/borsh_discriminant_false.snap.new
@@ -1,91 +1,56 @@
 ---
 source: borsh-derive/src/internals/deserialize/enums/mod.rs
-assertion_line: 306
+assertion_line: 300
 expression: pretty_print_syn_str(&actual).unwrap()
 ---
 impl borsh::de::BorshDeserialize for X {
     fn deserialize_reader<__R: borsh::io::Read>(
         reader: &mut __R,
     ) -> ::core::result::Result<Self, borsh::io::Error> {
-        let tag = <u8 as borsh::de::BorshDeserialize>::deserialize_reader(reader)?;
-        <Self as borsh::de::EnumExt>::deserialize_variant::<_, u8>(reader, tag)
+        let variant_tag = <u8 as borsh::de::BorshDeserialize>::deserialize_reader(
+            reader,
+        )?;
+        let mut return_value = if variant_tag == 0u8 {
+            X::A
+        } else if variant_tag == 1u8 {
+            X::B
+        } else if variant_tag == 2u8 {
+            X::C
+        } else if variant_tag == 3u8 {
+            X::D
+        } else if variant_tag == 4u8 {
+            X::E
+        } else if variant_tag == 5u8 {
+            X::F
+        } else {
+            return Err(
+                borsh::io::Error::new(
+                    borsh::io::ErrorKind::InvalidData,
+                    borsh::__private::maybestd::format!(
+                        "Unexpected variant tag: {:?}", variant_tag
+                    ),
+                ),
+            )
+        };
+        Ok(return_value)
     }
 }
 impl borsh::de::EnumExt for X {
-    fn deserialize_variant<
-        __R: borsh::io::Read,
-        Tag: borsh::BorshDeserialize + ::core::fmt::Debug + Eq
-            + ::core::convert::TryInto<u16> + ::core::convert::TryInto<u8> + Copy,
-    >(
+    fn deserialize_variant<__R: borsh::io::Read>(
         reader: &mut __R,
-        variant_tag: Tag,
+        variant_tag: u8,
     ) -> ::core::result::Result<Self, borsh::io::Error> {
-        use ::core::convert::TryInto;
-        let mut return_value = if TryInto::<(u8)>::try_into(variant_tag)
-            .map_err(|_| {
-                return borsh::io::Error::new(
-                    borsh::io::ErrorKind::InvalidData,
-                    borsh::__private::maybestd::format!(
-                        "Unexpected variant tag: {:?}", variant_tag
-                    ),
-                );
-            })? == 0u8
-        {
+        let mut return_value = if variant_tag == 0u8 {
             X::A
-        } else if TryInto::<(u8)>::try_into(variant_tag)
-            .map_err(|_| {
-                return borsh::io::Error::new(
-                    borsh::io::ErrorKind::InvalidData,
-                    borsh::__private::maybestd::format!(
-                        "Unexpected variant tag: {:?}", variant_tag
-                    ),
-                );
-            })? == 1u8
-        {
+        } else if variant_tag == 1u8 {
             X::B
-        } else if TryInto::<(u8)>::try_into(variant_tag)
-            .map_err(|_| {
-                return borsh::io::Error::new(
-                    borsh::io::ErrorKind::InvalidData,
-                    borsh::__private::maybestd::format!(
-                        "Unexpected variant tag: {:?}", variant_tag
-                    ),
-                );
-            })? == 2u8
-        {
+        } else if variant_tag == 2u8 {
             X::C
-        } else if TryInto::<(u8)>::try_into(variant_tag)
-            .map_err(|_| {
-                return borsh::io::Error::new(
-                    borsh::io::ErrorKind::InvalidData,
-                    borsh::__private::maybestd::format!(
-                        "Unexpected variant tag: {:?}", variant_tag
-                    ),
-                );
-            })? == 3u8
-        {
+        } else if variant_tag == 3u8 {
             X::D
-        } else if TryInto::<(u8)>::try_into(variant_tag)
-            .map_err(|_| {
-                return borsh::io::Error::new(
-                    borsh::io::ErrorKind::InvalidData,
-                    borsh::__private::maybestd::format!(
-                        "Unexpected variant tag: {:?}", variant_tag
-                    ),
-                );
-            })? == 4u8
-        {
+        } else if variant_tag == 4u8 {
             X::E
-        } else if TryInto::<(u8)>::try_into(variant_tag)
-            .map_err(|_| {
-                return borsh::io::Error::new(
-                    borsh::io::ErrorKind::InvalidData,
-                    borsh::__private::maybestd::format!(
-                        "Unexpected variant tag: {:?}", variant_tag
-                    ),
-                );
-            })? == 5u8
-        {
+        } else if variant_tag == 5u8 {
             X::F
         } else {
             return Err(
diff --git a/borsh-derive/src/internals/deserialize/enums/snapshots/borsh_discriminant_true.snap.new b/borsh-derive/src/internals/deserialize/enums/snapshots/borsh_discriminant_true.snap.new
index 95136ffce..8d17b1221 100644
--- a/borsh-derive/src/internals/deserialize/enums/snapshots/borsh_discriminant_true.snap.new
+++ b/borsh-derive/src/internals/deserialize/enums/snapshots/borsh_discriminant_true.snap.new
@@ -1,91 +1,56 @@
 ---
 source: borsh-derive/src/internals/deserialize/enums/mod.rs
-assertion_line: 324
+assertion_line: 318
 expression: pretty_print_syn_str(&actual).unwrap()
 ---
 impl borsh::de::BorshDeserialize for X {
     fn deserialize_reader<__R: borsh::io::Read>(
         reader: &mut __R,
     ) -> ::core::result::Result<Self, borsh::io::Error> {
-        let tag = <u8 as borsh::de::BorshDeserialize>::deserialize_reader(reader)?;
-        <Self as borsh::de::EnumExt>::deserialize_variant::<_, u8>(reader, tag)
+        let variant_tag = <u8 as borsh::de::BorshDeserialize>::deserialize_reader(
+            reader,
+        )?;
+        let mut return_value = if variant_tag == 0 {
+            X::A
+        } else if variant_tag == 20 {
+            X::B
+        } else if variant_tag == 20 + 1 {
+            X::C
+        } else if variant_tag == 20 + 1 + 1 {
+            X::D
+        } else if variant_tag == 10 {
+            X::E
+        } else if variant_tag == 10 + 1 {
+            X::F
+        } else {
+            return Err(
+                borsh::io::Error::new(
+                    borsh::io::ErrorKind::InvalidData,
+                    borsh::__private::maybestd::format!(
+                        "Unexpected variant tag: {:?}", variant_tag
+                    ),
+                ),
+            )
+        };
+        Ok(return_value)
     }
 }
 impl borsh::de::EnumExt for X {
-    fn deserialize_variant<
-        __R: borsh::io::Read,
-        Tag: borsh::BorshDeserialize + ::core::fmt::Debug + Eq
-            + ::core::convert::TryInto<u16> + ::core::convert::TryInto<u8> + Copy,
-    >(
+    fn deserialize_variant<__R: borsh::io::Read>(
         reader: &mut __R,
-        variant_tag: Tag,
+        variant_tag: u8,
     ) -> ::core::result::Result<Self, borsh::io::Error> {
-        use ::core::convert::TryInto;
-        let mut return_value = if TryInto::<(u8)>::try_into(variant_tag)
-            .map_err(|_| {
-                return borsh::io::Error::new(
-                    borsh::io::ErrorKind::InvalidData,
-                    borsh::__private::maybestd::format!(
-                        "Unexpected variant tag: {:?}", variant_tag
-                    ),
-                );
-            })? == 0
-        {
+        let mut return_value = if variant_tag == 0 {
             X::A
-        } else if TryInto::<(u8)>::try_into(variant_tag)
-            .map_err(|_| {
-                return borsh::io::Error::new(
-                    borsh::io::ErrorKind::InvalidData,
-                    borsh::__private::maybestd::format!(
-                        "Unexpected variant tag: {:?}", variant_tag
-                    ),
-                );
-            })? == 20
-        {
+        } else if variant_tag == 20 {
             X::B
-        } else if TryInto::<(u8)>::try_into(variant_tag)
-            .map_err(|_| {
-                return borsh::io::Error::new(
-                    borsh::io::ErrorKind::InvalidData,
-                    borsh::__private::maybestd::format!(
-                        "Unexpected variant tag: {:?}", variant_tag
-                    ),
-                );
-            })? == 20 + 1
-        {
+        } else if variant_tag == 20 + 1 {
             X::C
-        } else if TryInto::<(u8)>::try_into(variant_tag)
-            .map_err(|_| {
-                return borsh::io::Error::new(
-                    borsh::io::ErrorKind::InvalidData,
-                    borsh::__private::maybestd::format!(
-                        "Unexpected variant tag: {:?}", variant_tag
-                    ),
-                );
-            })? == 20 + 1 + 1
-        {
+        } else if variant_tag == 20 + 1 + 1 {
             X::D
-        } else if TryInto::<(u8)>::try_into(variant_tag)
-            .map_err(|_| {
-                return borsh::io::Error::new(
-                    borsh::io::ErrorKind::InvalidData,
-                    borsh::__private::maybestd::format!(
-                        "Unexpected variant tag: {:?}", variant_tag
-                    ),
-                );
-            })? == 10
-        {
+        } else if variant_tag == 10 {
             X::E
-        } else if TryInto::<(u8)>::try_into(variant_tag)
-            .map_err(|_| {
-                return borsh::io::Error::new(
-                    borsh::io::ErrorKind::InvalidData,
-                    borsh::__private::maybestd::format!(
-                        "Unexpected variant tag: {:?}", variant_tag
-                    ),
-                );
-            })? == 10 + 1
-        {
+        } else if variant_tag == 10 + 1 {
             X::F
         } else {
             return Err(
diff --git a/borsh-derive/src/internals/deserialize/enums/snapshots/borsh_init_func.snap.new b/borsh-derive/src/internals/deserialize/enums/snapshots/borsh_init_func.snap.new
index 483efecff..485ec3bc7 100644
--- a/borsh-derive/src/internals/deserialize/enums/snapshots/borsh_init_func.snap.new
+++ b/borsh-derive/src/internals/deserialize/enums/snapshots/borsh_init_func.snap.new
@@ -1,91 +1,57 @@
 ---
 source: borsh-derive/src/internals/deserialize/enums/mod.rs
-assertion_line: 341
+assertion_line: 335
 expression: pretty_print_syn_str(&actual).unwrap()
 ---
 impl borsh::de::BorshDeserialize for A {
     fn deserialize_reader<__R: borsh::io::Read>(
         reader: &mut __R,
     ) -> ::core::result::Result<Self, borsh::io::Error> {
-        let tag = <u8 as borsh::de::BorshDeserialize>::deserialize_reader(reader)?;
-        <Self as borsh::de::EnumExt>::deserialize_variant::<_, u8>(reader, tag)
+        let variant_tag = <u8 as borsh::de::BorshDeserialize>::deserialize_reader(
+            reader,
+        )?;
+        let mut return_value = if variant_tag == 0u8 {
+            A::A
+        } else if variant_tag == 1u8 {
+            A::B
+        } else if variant_tag == 2u8 {
+            A::C
+        } else if variant_tag == 3u8 {
+            A::D
+        } else if variant_tag == 4u8 {
+            A::E
+        } else if variant_tag == 5u8 {
+            A::F
+        } else {
+            return Err(
+                borsh::io::Error::new(
+                    borsh::io::ErrorKind::InvalidData,
+                    borsh::__private::maybestd::format!(
+                        "Unexpected variant tag: {:?}", variant_tag
+                    ),
+                ),
+            )
+        };
+        return_value.initialization_method();
+        Ok(return_value)
     }
 }
 impl borsh::de::EnumExt for A {
-    fn deserialize_variant<
-        __R: borsh::io::Read,
-        Tag: borsh::BorshDeserialize + ::core::fmt::Debug + Eq
-            + ::core::convert::TryInto<u16> + ::core::convert::TryInto<u8> + Copy,
-    >(
+    fn deserialize_variant<__R: borsh::io::Read>(
         reader: &mut __R,
-        variant_tag: Tag,
+        variant_tag: u8,
     ) -> ::core::result::Result<Self, borsh::io::Error> {
-        use ::core::convert::TryInto;
-        let mut return_value = if TryInto::<(u8)>::try_into(variant_tag)
-            .map_err(|_| {
-                return borsh::io::Error::new(
-                    borsh::io::ErrorKind::InvalidData,
-                    borsh::__private::maybestd::format!(
-                        "Unexpected variant tag: {:?}", variant_tag
-                    ),
-                );
-            })? == 0u8
-        {
+        let mut return_value = if variant_tag == 0u8 {
             A::A
-        } else if TryInto::<(u8)>::try_into(variant_tag)
-            .map_err(|_| {
-                return borsh::io::Error::new(
-                    borsh::io::ErrorKind::InvalidData,
-                    borsh::__private::maybestd::format!(
-                        "Unexpected variant tag: {:?}", variant_tag
-                    ),
-                );
-            })? == 1u8
-        {
+        } else if variant_tag == 1u8 {
             A::B
-        } else if TryInto::<(u8)>::try_into(variant_tag)
-            .map_err(|_| {
-                return borsh::io::Error::new(
-                    borsh::io::ErrorKind::InvalidData,
-                    borsh::__private::maybestd::format!(
-                        "Unexpected variant tag: {:?}", variant_tag
-                    ),
-                );
-            })? == 2u8
-        {
+        } else if variant_tag == 2u8 {
             A::C
-        } else if TryInto::<(u8)>::try_into(variant_tag)
-            .map_err(|_| {
-                return borsh::io::Error::new(
-                    borsh::io::ErrorKind::InvalidData,
-                    borsh::__private::maybestd::format!(
-                        "Unexpected variant tag: {:?}", variant_tag
-                    ),
-                );
-            })? == 3u8
-        {
+        } else if variant_tag == 3u8 {
             A::D
-        } else if TryInto::<(u8)>::try_into(variant_tag)
-            .map_err(|_| {
-                return borsh::io::Error::new(
-                    borsh::io::ErrorKind::InvalidData,
-                    borsh::__private::maybestd::format!(
-                        "Unexpected variant tag: {:?}", variant_tag
-                    ),
-                );
-            })? == 4u8
-        {
+        } else if variant_tag == 4u8 {
             A::E
-        } else if TryInto::<(u8)>::try_into(variant_tag)
-            .map_err(|_| {
-                return borsh::io::Error::new(
-                    borsh::io::ErrorKind::InvalidData,
-                    borsh::__private::maybestd::format!(
-                        "Unexpected variant tag: {:?}", variant_tag
-                    ),
-                );
-            })? == 5u8
-        {
+        } else if variant_tag == 5u8 {
             A::F
         } else {
             return Err(
diff --git a/borsh-derive/src/internals/deserialize/enums/snapshots/borsh_skip_struct_variant_field.snap.new b/borsh-derive/src/internals/deserialize/enums/snapshots/borsh_skip_struct_variant_field.snap.new
index b1a3b4b2d..55b39b636 100644
--- a/borsh-derive/src/internals/deserialize/enums/snapshots/borsh_skip_struct_variant_field.snap.new
+++ b/borsh-derive/src/internals/deserialize/enums/snapshots/borsh_skip_struct_variant_field.snap.new
@@ -1,50 +1,48 @@
 ---
 source: borsh-derive/src/internals/deserialize/enums/mod.rs
-assertion_line: 123
+assertion_line: 117
 expression: pretty_print_syn_str(&actual).unwrap()
 ---
 impl borsh::de::BorshDeserialize for AA {
     fn deserialize_reader<__R: borsh::io::Read>(
         reader: &mut __R,
     ) -> ::core::result::Result<Self, borsh::io::Error> {
-        let tag = <u8 as borsh::de::BorshDeserialize>::deserialize_reader(reader)?;
-        <Self as borsh::de::EnumExt>::deserialize_variant::<_, u8>(reader, tag)
+        let variant_tag = <u8 as borsh::de::BorshDeserialize>::deserialize_reader(
+            reader,
+        )?;
+        let mut return_value = if variant_tag == 0u8 {
+            AA::B {
+                c: core::default::Default::default(),
+                d: borsh::BorshDeserialize::deserialize_reader(reader)?,
+            }
+        } else if variant_tag == 1u8 {
+            AA::NegatedVariant {
+                beta: borsh::BorshDeserialize::deserialize_reader(reader)?,
+            }
+        } else {
+            return Err(
+                borsh::io::Error::new(
+                    borsh::io::ErrorKind::InvalidData,
+                    borsh::__private::maybestd::format!(
+                        "Unexpected variant tag: {:?}", variant_tag
+                    ),
+                ),
+            )
+        };
+        Ok(return_value)
     }
 }
 impl borsh::de::EnumExt for AA {
-    fn deserialize_variant<
-        __R: borsh::io::Read,
-        Tag: borsh::BorshDeserialize + ::core::fmt::Debug + Eq
-            + ::core::convert::TryInto<u16> + ::core::convert::TryInto<u8> + Copy,
-    >(
+    fn deserialize_variant<__R: borsh::io::Read>(
         reader: &mut __R,
-        variant_tag: Tag,
+        variant_tag: u8,
     ) -> ::core::result::Result<Self, borsh::io::Error> {
-        use ::core::convert::TryInto;
-        let mut return_value = if TryInto::<(u8)>::try_into(variant_tag)
-            .map_err(|_| {
-                return borsh::io::Error::new(
-                    borsh::io::ErrorKind::InvalidData,
-                    borsh::__private::maybestd::format!(
-                        "Unexpected variant tag: {:?}", variant_tag
-                    ),
-                );
-            })? == 0u8
-        {
+        let mut return_value = if variant_tag == 0u8 {
             AA::B {
                 c: core::default::Default::default(),
                 d: borsh::BorshDeserialize::deserialize_reader(reader)?,
             }
-        } else if TryInto::<(u8)>::try_into(variant_tag)
-            .map_err(|_| {
-                return borsh::io::Error::new(
-                    borsh::io::ErrorKind::InvalidData,
-                    borsh::__private::maybestd::format!(
-                        "Unexpected variant tag: {:?}", variant_tag
-                    ),
-                );
-            })? == 1u8
-        {
+        } else if variant_tag == 1u8 {
             AA::NegatedVariant {
                 beta: borsh::BorshDeserialize::deserialize_reader(reader)?,
             }
diff --git a/borsh-derive/src/internals/deserialize/enums/snapshots/borsh_skip_tuple_variant_field.snap.new b/borsh-derive/src/internals/deserialize/enums/snapshots/borsh_skip_tuple_variant_field.snap.new
index f73a2f220..e3b91c361 100644
--- a/borsh-derive/src/internals/deserialize/enums/snapshots/borsh_skip_tuple_variant_field.snap.new
+++ b/borsh-derive/src/internals/deserialize/enums/snapshots/borsh_skip_tuple_variant_field.snap.new
@@ -1,50 +1,48 @@
 ---
 source: borsh-derive/src/internals/deserialize/enums/mod.rs
-assertion_line: 140
+assertion_line: 134
 expression: pretty_print_syn_str(&actual).unwrap()
 ---
 impl borsh::de::BorshDeserialize for AAT {
     fn deserialize_reader<__R: borsh::io::Read>(
         reader: &mut __R,
     ) -> ::core::result::Result<Self, borsh::io::Error> {
-        let tag = <u8 as borsh::de::BorshDeserialize>::deserialize_reader(reader)?;
-        <Self as borsh::de::EnumExt>::deserialize_variant::<_, u8>(reader, tag)
+        let variant_tag = <u8 as borsh::de::BorshDeserialize>::deserialize_reader(
+            reader,
+        )?;
+        let mut return_value = if variant_tag == 0u8 {
+            AAT::B(
+                core::default::Default::default(),
+                borsh::BorshDeserialize::deserialize_reader(reader)?,
+            )
+        } else if variant_tag == 1u8 {
+            AAT::NegatedVariant {
+                beta: borsh::BorshDeserialize::deserialize_reader(reader)?,
+            }
+        } else {
+            return Err(
+                borsh::io::Error::new(
+                    borsh::io::ErrorKind::InvalidData,
+                    borsh::__private::maybestd::format!(
+                        "Unexpected variant tag: {:?}", variant_tag
+                    ),
+                ),
+            )
+        };
+        Ok(return_value)
     }
 }
 impl borsh::de::EnumExt for AAT {
-    fn deserialize_variant<
-        __R: borsh::io::Read,
-        Tag: borsh::BorshDeserialize + ::core::fmt::Debug + Eq
-            + ::core::convert::TryInto<u16> + ::core::convert::TryInto<u8> + Copy,
-    >(
+    fn deserialize_variant<__R: borsh::io::Read>(
         reader: &mut __R,
-        variant_tag: Tag,
+        variant_tag: u8,
     ) -> ::core::result::Result<Self, borsh::io::Error> {
-        use ::core::convert::TryInto;
-        let mut return_value = if TryInto::<(u8)>::try_into(variant_tag)
-            .map_err(|_| {
-                return borsh::io::Error::new(
-                    borsh::io::ErrorKind::InvalidData,
-                    borsh::__private::maybestd::format!(
-                        "Unexpected variant tag: {:?}", variant_tag
-                    ),
-                );
-            })? == 0u8
-        {
+        let mut return_value = if variant_tag == 0u8 {
             AAT::B(
                 core::default::Default::default(),
                 borsh::BorshDeserialize::deserialize_reader(reader)?,
             )
-        } else if TryInto::<(u8)>::try_into(variant_tag)
-            .map_err(|_| {
-                return borsh::io::Error::new(
-                    borsh::io::ErrorKind::InvalidData,
-                    borsh::__private::maybestd::format!(
-                        "Unexpected variant tag: {:?}", variant_tag
-                    ),
-                );
-            })? == 1u8
-        {
+        } else if variant_tag == 1u8 {
             AAT::NegatedVariant {
                 beta: borsh::BorshDeserialize::deserialize_reader(reader)?,
             }
diff --git a/borsh-derive/src/internals/deserialize/enums/snapshots/bound_generics.snap.new b/borsh-derive/src/internals/deserialize/enums/snapshots/bound_generics.snap.new
index fc06f63d3..74aa01e12 100644
--- a/borsh-derive/src/internals/deserialize/enums/snapshots/bound_generics.snap.new
+++ b/borsh-derive/src/internals/deserialize/enums/snapshots/bound_generics.snap.new
@@ -1,6 +1,6 @@
 ---
 source: borsh-derive/src/internals/deserialize/enums/mod.rs
-assertion_line: 192
+assertion_line: 186
 expression: pretty_print_syn_str(&actual).unwrap()
 ---
 impl<K: Key, V, U> borsh::de::BorshDeserialize for A<K, V, U>
@@ -13,8 +13,30 @@ where
     fn deserialize_reader<__R: borsh::io::Read>(
         reader: &mut __R,
     ) -> ::core::result::Result<Self, borsh::io::Error> {
-        let tag = <u8 as borsh::de::BorshDeserialize>::deserialize_reader(reader)?;
-        <Self as borsh::de::EnumExt>::deserialize_variant::<_, u8>(reader, tag)
+        let variant_tag = <u8 as borsh::de::BorshDeserialize>::deserialize_reader(
+            reader,
+        )?;
+        let mut return_value = if variant_tag == 0u8 {
+            A::B {
+                x: borsh::BorshDeserialize::deserialize_reader(reader)?,
+                y: borsh::BorshDeserialize::deserialize_reader(reader)?,
+            }
+        } else if variant_tag == 1u8 {
+            A::C(
+                borsh::BorshDeserialize::deserialize_reader(reader)?,
+                borsh::BorshDeserialize::deserialize_reader(reader)?,
+            )
+        } else {
+            return Err(
+                borsh::io::Error::new(
+                    borsh::io::ErrorKind::InvalidData,
+                    borsh::__private::maybestd::format!(
+                        "Unexpected variant tag: {:?}", variant_tag
+                    ),
+                ),
+            )
+        };
+        Ok(return_value)
     }
 }
 impl<K: Key, V, U> borsh::de::EnumExt for A<K, V, U>
@@ -24,39 +46,16 @@ where
     V: borsh::de::BorshDeserialize,
     U: borsh::de::BorshDeserialize,
 {
-    fn deserialize_variant<
-        __R: borsh::io::Read,
-        Tag: borsh::BorshDeserialize + ::core::fmt::Debug + Eq
-            + ::core::convert::TryInto<u16> + ::core::convert::TryInto<u8> + Copy,
-    >(
+    fn deserialize_variant<__R: borsh::io::Read>(
         reader: &mut __R,
-        variant_tag: Tag,
+        variant_tag: u8,
     ) -> ::core::result::Result<Self, borsh::io::Error> {
-        use ::core::convert::TryInto;
-        let mut return_value = if TryInto::<(u8)>::try_into(variant_tag)
-            .map_err(|_| {
-                return borsh::io::Error::new(
-                    borsh::io::ErrorKind::InvalidData,
-                    borsh::__private::maybestd::format!(
-                        "Unexpected variant tag: {:?}", variant_tag
-                    ),
-                );
-            })? == 0u8
-        {
+        let mut return_value = if variant_tag == 0u8 {
             A::B {
                 x: borsh::BorshDeserialize::deserialize_reader(reader)?,
                 y: borsh::BorshDeserialize::deserialize_reader(reader)?,
             }
-        } else if TryInto::<(u8)>::try_into(variant_tag)
-            .map_err(|_| {
-                return borsh::io::Error::new(
-                    borsh::io::ErrorKind::InvalidData,
-                    borsh::__private::maybestd::format!(
-                        "Unexpected variant tag: {:?}", variant_tag
-                    ),
-                );
-            })? == 1u8
-        {
+        } else if variant_tag == 1u8 {
             A::C(
                 borsh::BorshDeserialize::deserialize_reader(reader)?,
                 borsh::BorshDeserialize::deserialize_reader(reader)?,
diff --git a/borsh-derive/src/internals/deserialize/enums/snapshots/check_deserialize_with_attr.snap.new b/borsh-derive/src/internals/deserialize/enums/snapshots/check_deserialize_with_attr.snap.new
index ca75637d3..d3436e453 100644
--- a/borsh-derive/src/internals/deserialize/enums/snapshots/check_deserialize_with_attr.snap.new
+++ b/borsh-derive/src/internals/deserialize/enums/snapshots/check_deserialize_with_attr.snap.new
@@ -1,6 +1,6 @@
 ---
 source: borsh-derive/src/internals/deserialize/enums/mod.rs
-assertion_line: 287
+assertion_line: 281
 expression: pretty_print_syn_str(&actual).unwrap()
 ---
 impl<K: Ord, V> borsh::de::BorshDeserialize for C<K, V>
@@ -11,8 +11,30 @@ where
     fn deserialize_reader<__R: borsh::io::Read>(
         reader: &mut __R,
     ) -> ::core::result::Result<Self, borsh::io::Error> {
-        let tag = <u8 as borsh::de::BorshDeserialize>::deserialize_reader(reader)?;
-        <Self as borsh::de::EnumExt>::deserialize_variant::<_, u8>(reader, tag)
+        let variant_tag = <u8 as borsh::de::BorshDeserialize>::deserialize_reader(
+            reader,
+        )?;
+        let mut return_value = if variant_tag == 0u8 {
+            C::C3(
+                borsh::BorshDeserialize::deserialize_reader(reader)?,
+                borsh::BorshDeserialize::deserialize_reader(reader)?,
+            )
+        } else if variant_tag == 1u8 {
+            C::C4 {
+                x: borsh::BorshDeserialize::deserialize_reader(reader)?,
+                y: third_party_impl::deserialize_third_party(reader)?,
+            }
+        } else {
+            return Err(
+                borsh::io::Error::new(
+                    borsh::io::ErrorKind::InvalidData,
+                    borsh::__private::maybestd::format!(
+                        "Unexpected variant tag: {:?}", variant_tag
+                    ),
+                ),
+            )
+        };
+        Ok(return_value)
     }
 }
 impl<K: Ord, V> borsh::de::EnumExt for C<K, V>
@@ -20,39 +42,16 @@ where
     K: borsh::de::BorshDeserialize,
     V: borsh::de::BorshDeserialize,
 {
-    fn deserialize_variant<
-        __R: borsh::io::Read,
-        Tag: borsh::BorshDeserialize + ::core::fmt::Debug + Eq
-            + ::core::convert::TryInto<u16> + ::core::convert::TryInto<u8> + Copy,
-    >(
+    fn deserialize_variant<__R: borsh::io::Read>(
         reader: &mut __R,
-        variant_tag: Tag,
+        variant_tag: u8,
     ) -> ::core::result::Result<Self, borsh::io::Error> {
-        use ::core::convert::TryInto;
-        let mut return_value = if TryInto::<(u8)>::try_into(variant_tag)
-            .map_err(|_| {
-                return borsh::io::Error::new(
-                    borsh::io::ErrorKind::InvalidData,
-                    borsh::__private::maybestd::format!(
-                        "Unexpected variant tag: {:?}", variant_tag
-                    ),
-                );
-            })? == 0u8
-        {
+        let mut return_value = if variant_tag == 0u8 {
             C::C3(
                 borsh::BorshDeserialize::deserialize_reader(reader)?,
                 borsh::BorshDeserialize::deserialize_reader(reader)?,
             )
-        } else if TryInto::<(u8)>::try_into(variant_tag)
-            .map_err(|_| {
-                return borsh::io::Error::new(
-                    borsh::io::ErrorKind::InvalidData,
-                    borsh::__private::maybestd::format!(
-                        "Unexpected variant tag: {:?}", variant_tag
-                    ),
-                );
-            })? == 1u8
-        {
+        } else if variant_tag == 1u8 {
             C::C4 {
                 x: borsh::BorshDeserialize::deserialize_reader(reader)?,
                 y: third_party_impl::deserialize_third_party(reader)?,
diff --git a/borsh-derive/src/internals/deserialize/enums/snapshots/generic_borsh_skip_struct_field.snap.new b/borsh-derive/src/internals/deserialize/enums/snapshots/generic_borsh_skip_struct_field.snap.new
index f5ec8bd9b..86068606b 100644
--- a/borsh-derive/src/internals/deserialize/enums/snapshots/generic_borsh_skip_struct_field.snap.new
+++ b/borsh-derive/src/internals/deserialize/enums/snapshots/generic_borsh_skip_struct_field.snap.new
@@ -1,6 +1,6 @@
 ---
 source: borsh-derive/src/internals/deserialize/enums/mod.rs
-assertion_line: 228
+assertion_line: 222
 expression: pretty_print_syn_str(&actual).unwrap()
 ---
 impl<K: Key, V, U> borsh::de::BorshDeserialize for A<K, V, U>
@@ -14,8 +14,30 @@ where
     fn deserialize_reader<__R: borsh::io::Read>(
         reader: &mut __R,
     ) -> ::core::result::Result<Self, borsh::io::Error> {
-        let tag = <u8 as borsh::de::BorshDeserialize>::deserialize_reader(reader)?;
-        <Self as borsh::de::EnumExt>::deserialize_variant::<_, u8>(reader, tag)
+        let variant_tag = <u8 as borsh::de::BorshDeserialize>::deserialize_reader(
+            reader,
+        )?;
+        let mut return_value = if variant_tag == 0u8 {
+            A::B {
+                x: core::default::Default::default(),
+                y: borsh::BorshDeserialize::deserialize_reader(reader)?,
+            }
+        } else if variant_tag == 1u8 {
+            A::C(
+                borsh::BorshDeserialize::deserialize_reader(reader)?,
+                borsh::BorshDeserialize::deserialize_reader(reader)?,
+            )
+        } else {
+            return Err(
+                borsh::io::Error::new(
+                    borsh::io::ErrorKind::InvalidData,
+                    borsh::__private::maybestd::format!(
+                        "Unexpected variant tag: {:?}", variant_tag
+                    ),
+                ),
+            )
+        };
+        Ok(return_value)
     }
 }
 impl<K: Key, V, U> borsh::de::EnumExt for A<K, V, U>
@@ -26,39 +48,16 @@ where
     K: core::default::Default,
     V: core::default::Default,
 {
-    fn deserialize_variant<
-        __R: borsh::io::Read,
-        Tag: borsh::BorshDeserialize + ::core::fmt::Debug + Eq
-            + ::core::convert::TryInto<u16> + ::core::convert::TryInto<u8> + Copy,
-    >(
+    fn deserialize_variant<__R: borsh::io::Read>(
         reader: &mut __R,
-        variant_tag: Tag,
+        variant_tag: u8,
     ) -> ::core::result::Result<Self, borsh::io::Error> {
-        use ::core::convert::TryInto;
-        let mut return_value = if TryInto::<(u8)>::try_into(variant_tag)
-            .map_err(|_| {
-                return borsh::io::Error::new(
-                    borsh::io::ErrorKind::InvalidData,
-                    borsh::__private::maybestd::format!(
-                        "Unexpected variant tag: {:?}", variant_tag
-                    ),
-                );
-            })? == 0u8
-        {
+        let mut return_value = if variant_tag == 0u8 {
             A::B {
                 x: core::default::Default::default(),
                 y: borsh::BorshDeserialize::deserialize_reader(reader)?,
             }
-        } else if TryInto::<(u8)>::try_into(variant_tag)
-            .map_err(|_| {
-                return borsh::io::Error::new(
-                    borsh::io::ErrorKind::InvalidData,
-                    borsh::__private::maybestd::format!(
-                        "Unexpected variant tag: {:?}", variant_tag
-                    ),
-                );
-            })? == 1u8
-        {
+        } else if variant_tag == 1u8 {
             A::C(
                 borsh::BorshDeserialize::deserialize_reader(reader)?,
                 borsh::BorshDeserialize::deserialize_reader(reader)?,
diff --git a/borsh-derive/src/internals/deserialize/enums/snapshots/generic_borsh_skip_tuple_field.snap.new b/borsh-derive/src/internals/deserialize/enums/snapshots/generic_borsh_skip_tuple_field.snap.new
index 251e9b027..49399f5bd 100644
--- a/borsh-derive/src/internals/deserialize/enums/snapshots/generic_borsh_skip_tuple_field.snap.new
+++ b/borsh-derive/src/internals/deserialize/enums/snapshots/generic_borsh_skip_tuple_field.snap.new
@@ -1,6 +1,6 @@
 ---
 source: borsh-derive/src/internals/deserialize/enums/mod.rs
-assertion_line: 246
+assertion_line: 240
 expression: pretty_print_syn_str(&actual).unwrap()
 ---
 impl<K: Key, V, U> borsh::de::BorshDeserialize for A<K, V, U>
@@ -13,8 +13,30 @@ where
     fn deserialize_reader<__R: borsh::io::Read>(
         reader: &mut __R,
     ) -> ::core::result::Result<Self, borsh::io::Error> {
-        let tag = <u8 as borsh::de::BorshDeserialize>::deserialize_reader(reader)?;
-        <Self as borsh::de::EnumExt>::deserialize_variant::<_, u8>(reader, tag)
+        let variant_tag = <u8 as borsh::de::BorshDeserialize>::deserialize_reader(
+            reader,
+        )?;
+        let mut return_value = if variant_tag == 0u8 {
+            A::B {
+                x: borsh::BorshDeserialize::deserialize_reader(reader)?,
+                y: borsh::BorshDeserialize::deserialize_reader(reader)?,
+            }
+        } else if variant_tag == 1u8 {
+            A::C(
+                borsh::BorshDeserialize::deserialize_reader(reader)?,
+                core::default::Default::default(),
+            )
+        } else {
+            return Err(
+                borsh::io::Error::new(
+                    borsh::io::ErrorKind::InvalidData,
+                    borsh::__private::maybestd::format!(
+                        "Unexpected variant tag: {:?}", variant_tag
+                    ),
+                ),
+            )
+        };
+        Ok(return_value)
     }
 }
 impl<K: Key, V, U> borsh::de::EnumExt for A<K, V, U>
@@ -24,39 +46,16 @@ where
     V: borsh::de::BorshDeserialize,
     U: core::default::Default,
 {
-    fn deserialize_variant<
-        __R: borsh::io::Read,
-        Tag: borsh::BorshDeserialize + ::core::fmt::Debug + Eq
-            + ::core::convert::TryInto<u16> + ::core::convert::TryInto<u8> + Copy,
-    >(
+    fn deserialize_variant<__R: borsh::io::Read>(
         reader: &mut __R,
-        variant_tag: Tag,
+        variant_tag: u8,
     ) -> ::core::result::Result<Self, borsh::io::Error> {
-        use ::core::convert::TryInto;
-        let mut return_value = if TryInto::<(u8)>::try_into(variant_tag)
-            .map_err(|_| {
-                return borsh::io::Error::new(
-                    borsh::io::ErrorKind::InvalidData,
-                    borsh::__private::maybestd::format!(
-                        "Unexpected variant tag: {:?}", variant_tag
-                    ),
-                );
-            })? == 0u8
-        {
+        let mut return_value = if variant_tag == 0u8 {
             A::B {
                 x: borsh::BorshDeserialize::deserialize_reader(reader)?,
                 y: borsh::BorshDeserialize::deserialize_reader(reader)?,
             }
-        } else if TryInto::<(u8)>::try_into(variant_tag)
-            .map_err(|_| {
-                return borsh::io::Error::new(
-                    borsh::io::ErrorKind::InvalidData,
-                    borsh::__private::maybestd::format!(
-                        "Unexpected variant tag: {:?}", variant_tag
-                    ),
-                );
-            })? == 1u8
-        {
+        } else if variant_tag == 1u8 {
             A::C(
                 borsh::BorshDeserialize::deserialize_reader(reader)?,
                 core::default::Default::default(),
diff --git a/borsh-derive/src/internals/deserialize/enums/snapshots/generic_deserialize_bound.snap.new b/borsh-derive/src/internals/deserialize/enums/snapshots/generic_deserialize_bound.snap.new
index f85be3e73..fe5ca6bd6 100644
--- a/borsh-derive/src/internals/deserialize/enums/snapshots/generic_deserialize_bound.snap.new
+++ b/borsh-derive/src/internals/deserialize/enums/snapshots/generic_deserialize_bound.snap.new
@@ -1,6 +1,6 @@
 ---
 source: borsh-derive/src/internals/deserialize/enums/mod.rs
-assertion_line: 268
+assertion_line: 262
 expression: pretty_print_syn_str(&actual).unwrap()
 ---
 impl<T: Debug, U> borsh::de::BorshDeserialize for A<T, U>
@@ -11,8 +11,30 @@ where
     fn deserialize_reader<__R: borsh::io::Read>(
         reader: &mut __R,
     ) -> ::core::result::Result<Self, borsh::io::Error> {
-        let tag = <u8 as borsh::de::BorshDeserialize>::deserialize_reader(reader)?;
-        <Self as borsh::de::EnumExt>::deserialize_variant::<_, u8>(reader, tag)
+        let variant_tag = <u8 as borsh::de::BorshDeserialize>::deserialize_reader(
+            reader,
+        )?;
+        let mut return_value = if variant_tag == 0u8 {
+            A::C {
+                a: borsh::BorshDeserialize::deserialize_reader(reader)?,
+                b: borsh::BorshDeserialize::deserialize_reader(reader)?,
+            }
+        } else if variant_tag == 1u8 {
+            A::D(
+                borsh::BorshDeserialize::deserialize_reader(reader)?,
+                borsh::BorshDeserialize::deserialize_reader(reader)?,
+            )
+        } else {
+            return Err(
+                borsh::io::Error::new(
+                    borsh::io::ErrorKind::InvalidData,
+                    borsh::__private::maybestd::format!(
+                        "Unexpected variant tag: {:?}", variant_tag
+                    ),
+                ),
+            )
+        };
+        Ok(return_value)
     }
 }
 impl<T: Debug, U> borsh::de::EnumExt for A<T, U>
@@ -20,39 +42,16 @@ where
     T: PartialOrd + Hash + Eq + borsh::de::BorshDeserialize,
     U: borsh::de::BorshDeserialize,
 {
-    fn deserialize_variant<
-        __R: borsh::io::Read,
-        Tag: borsh::BorshDeserialize + ::core::fmt::Debug + Eq
-            + ::core::convert::TryInto<u16> + ::core::convert::TryInto<u8> + Copy,
-    >(
+    fn deserialize_variant<__R: borsh::io::Read>(
         reader: &mut __R,
-        variant_tag: Tag,
+        variant_tag: u8,
     ) -> ::core::result::Result<Self, borsh::io::Error> {
-        use ::core::convert::TryInto;
-        let mut return_value = if TryInto::<(u8)>::try_into(variant_tag)
-            .map_err(|_| {
-                return borsh::io::Error::new(
-                    borsh::io::ErrorKind::InvalidData,
-                    borsh::__private::maybestd::format!(
-                        "Unexpected variant tag: {:?}", variant_tag
-                    ),
-                );
-            })? == 0u8
-        {
+        let mut return_value = if variant_tag == 0u8 {
             A::C {
                 a: borsh::BorshDeserialize::deserialize_reader(reader)?,
                 b: borsh::BorshDeserialize::deserialize_reader(reader)?,
             }
-        } else if TryInto::<(u8)>::try_into(variant_tag)
-            .map_err(|_| {
-                return borsh::io::Error::new(
-                    borsh::io::ErrorKind::InvalidData,
-                    borsh::__private::maybestd::format!(
-                        "Unexpected variant tag: {:?}", variant_tag
-                    ),
-                );
-            })? == 1u8
-        {
+        } else if variant_tag == 1u8 {
             A::D(
                 borsh::BorshDeserialize::deserialize_reader(reader)?,
                 borsh::BorshDeserialize::deserialize_reader(reader)?,
diff --git a/borsh-derive/src/internals/deserialize/enums/snapshots/recursive_enum.snap.new b/borsh-derive/src/internals/deserialize/enums/snapshots/recursive_enum.snap.new
index fbc4ed72b..b306b012f 100644
--- a/borsh-derive/src/internals/deserialize/enums/snapshots/recursive_enum.snap.new
+++ b/borsh-derive/src/internals/deserialize/enums/snapshots/recursive_enum.snap.new
@@ -1,6 +1,6 @@
 ---
 source: borsh-derive/src/internals/deserialize/enums/mod.rs
-assertion_line: 210
+assertion_line: 204
 expression: pretty_print_syn_str(&actual).unwrap()
 ---
 impl<K: Key, V> borsh::de::BorshDeserialize for A<K, V>
@@ -12,8 +12,30 @@ where
     fn deserialize_reader<__R: borsh::io::Read>(
         reader: &mut __R,
     ) -> ::core::result::Result<Self, borsh::io::Error> {
-        let tag = <u8 as borsh::de::BorshDeserialize>::deserialize_reader(reader)?;
-        <Self as borsh::de::EnumExt>::deserialize_variant::<_, u8>(reader, tag)
+        let variant_tag = <u8 as borsh::de::BorshDeserialize>::deserialize_reader(
+            reader,
+        )?;
+        let mut return_value = if variant_tag == 0u8 {
+            A::B {
+                x: borsh::BorshDeserialize::deserialize_reader(reader)?,
+                y: borsh::BorshDeserialize::deserialize_reader(reader)?,
+            }
+        } else if variant_tag == 1u8 {
+            A::C(
+                borsh::BorshDeserialize::deserialize_reader(reader)?,
+                borsh::BorshDeserialize::deserialize_reader(reader)?,
+            )
+        } else {
+            return Err(
+                borsh::io::Error::new(
+                    borsh::io::ErrorKind::InvalidData,
+                    borsh::__private::maybestd::format!(
+                        "Unexpected variant tag: {:?}", variant_tag
+                    ),
+                ),
+            )
+        };
+        Ok(return_value)
     }
 }
 impl<K: Key, V> borsh::de::EnumExt for A<K, V>
@@ -22,39 +44,16 @@ where
     K: borsh::de::BorshDeserialize,
     V: borsh::de::BorshDeserialize,
 {
-    fn deserialize_variant<
-        __R: borsh::io::Read,
-        Tag: borsh::BorshDeserialize + ::core::fmt::Debug + Eq
-            + ::core::convert::TryInto<u16> + ::core::convert::TryInto<u8> + Copy,
-    >(
+    fn deserialize_variant<__R: borsh::io::Read>(
         reader: &mut __R,
-        variant_tag: Tag,
+        variant_tag: u8,
     ) -> ::core::result::Result<Self, borsh::io::Error> {
-        use ::core::convert::TryInto;
-        let mut return_value = if TryInto::<(u8)>::try_into(variant_tag)
-            .map_err(|_| {
-                return borsh::io::Error::new(
-                    borsh::io::ErrorKind::InvalidData,
-                    borsh::__private::maybestd::format!(
-                        "Unexpected variant tag: {:?}", variant_tag
-                    ),
-                );
-            })? == 0u8
-        {
+        let mut return_value = if variant_tag == 0u8 {
             A::B {
                 x: borsh::BorshDeserialize::deserialize_reader(reader)?,
                 y: borsh::BorshDeserialize::deserialize_reader(reader)?,
             }
-        } else if TryInto::<(u8)>::try_into(variant_tag)
-            .map_err(|_| {
-                return borsh::io::Error::new(
-                    borsh::io::ErrorKind::InvalidData,
-                    borsh::__private::maybestd::format!(
-                        "Unexpected variant tag: {:?}", variant_tag
-                    ),
-                );
-            })? == 1u8
-        {
+        } else if variant_tag == 1u8 {
             A::C(
                 borsh::BorshDeserialize::deserialize_reader(reader)?,
                 borsh::BorshDeserialize::deserialize_reader(reader)?,
diff --git a/borsh-derive/src/internals/deserialize/enums/snapshots/simple_enum_with_custom_crate.snap.new b/borsh-derive/src/internals/deserialize/enums/snapshots/simple_enum_with_custom_crate.snap.new
index b5b16ef79..ec4091df5 100644
--- a/borsh-derive/src/internals/deserialize/enums/snapshots/simple_enum_with_custom_crate.snap.new
+++ b/borsh-derive/src/internals/deserialize/enums/snapshots/simple_enum_with_custom_crate.snap.new
@@ -1,55 +1,49 @@
 ---
 source: borsh-derive/src/internals/deserialize/enums/mod.rs
-assertion_line: 158
+assertion_line: 152
 expression: pretty_print_syn_str(&actual).unwrap()
 ---
 impl reexporter::borsh::de::BorshDeserialize for A {
     fn deserialize_reader<__R: reexporter::borsh::io::Read>(
         reader: &mut __R,
     ) -> ::core::result::Result<Self, reexporter::borsh::io::Error> {
-        let tag = <u8 as reexporter::borsh::de::BorshDeserialize>::deserialize_reader(
+        let variant_tag = <u8 as reexporter::borsh::de::BorshDeserialize>::deserialize_reader(
             reader,
         )?;
-        <Self as reexporter::borsh::de::EnumExt>::deserialize_variant::<
-            _,
-            u8,
-        >(reader, tag)
+        let mut return_value = if variant_tag == 0u8 {
+            A::B {
+                x: reexporter::borsh::BorshDeserialize::deserialize_reader(reader)?,
+                y: reexporter::borsh::BorshDeserialize::deserialize_reader(reader)?,
+            }
+        } else if variant_tag == 1u8 {
+            A::C(
+                reexporter::borsh::BorshDeserialize::deserialize_reader(reader)?,
+                reexporter::borsh::BorshDeserialize::deserialize_reader(reader)?,
+            )
+        } else {
+            return Err(
+                reexporter::borsh::io::Error::new(
+                    reexporter::borsh::io::ErrorKind::InvalidData,
+                    reexporter::borsh::__private::maybestd::format!(
+                        "Unexpected variant tag: {:?}", variant_tag
+                    ),
+                ),
+            )
+        };
+        Ok(return_value)
     }
 }
 impl reexporter::borsh::de::EnumExt for A {
-    fn deserialize_variant<
-        __R: reexporter::borsh::io::Read,
-        Tag: borsh::BorshDeserialize + ::core::fmt::Debug + Eq
-            + ::core::convert::TryInto<u16> + ::core::convert::TryInto<u8> + Copy,
-    >(
+    fn deserialize_variant<__R: reexporter::borsh::io::Read>(
         reader: &mut __R,
-        variant_tag: Tag,
+        variant_tag: u8,
     ) -> ::core::result::Result<Self, reexporter::borsh::io::Error> {
-        use ::core::convert::TryInto;
-        let mut return_value = if TryInto::<(u8)>::try_into(variant_tag)
-            .map_err(|_| {
-                return reexporter::borsh::io::Error::new(
-                    reexporter::borsh::io::ErrorKind::InvalidData,
-                    reexporter::borsh::__private::maybestd::format!(
-                        "Unexpected variant tag: {:?}", variant_tag
-                    ),
-                );
-            })? == 0u8
-        {
+        let mut return_value = if variant_tag == 0u8 {
             A::B {
                 x: reexporter::borsh::BorshDeserialize::deserialize_reader(reader)?,
                 y: reexporter::borsh::BorshDeserialize::deserialize_reader(reader)?,
             }
-        } else if TryInto::<(u8)>::try_into(variant_tag)
-            .map_err(|_| {
-                return reexporter::borsh::io::Error::new(
-                    reexporter::borsh::io::ErrorKind::InvalidData,
-                    reexporter::borsh::__private::maybestd::format!(
-                        "Unexpected variant tag: {:?}", variant_tag
-                    ),
-                );
-            })? == 1u8
-        {
+        } else if variant_tag == 1u8 {
             A::C(
                 reexporter::borsh::BorshDeserialize::deserialize_reader(reader)?,
                 reexporter::borsh::BorshDeserialize::deserialize_reader(reader)?,
diff --git a/borsh-derive/src/internals/deserialize/enums/snapshots/simple_generics.snap.new b/borsh-derive/src/internals/deserialize/enums/snapshots/simple_generics.snap.new
index d4a71b159..ee4281d66 100644
--- a/borsh-derive/src/internals/deserialize/enums/snapshots/simple_generics.snap.new
+++ b/borsh-derive/src/internals/deserialize/enums/snapshots/simple_generics.snap.new
@@ -1,6 +1,6 @@
 ---
 source: borsh-derive/src/internals/deserialize/enums/mod.rs
-assertion_line: 175
+assertion_line: 169
 expression: pretty_print_syn_str(&actual).unwrap()
 ---
 impl<K, V, U> borsh::de::BorshDeserialize for A<K, V, U>
@@ -12,8 +12,30 @@ where
     fn deserialize_reader<__R: borsh::io::Read>(
         reader: &mut __R,
     ) -> ::core::result::Result<Self, borsh::io::Error> {
-        let tag = <u8 as borsh::de::BorshDeserialize>::deserialize_reader(reader)?;
-        <Self as borsh::de::EnumExt>::deserialize_variant::<_, u8>(reader, tag)
+        let variant_tag = <u8 as borsh::de::BorshDeserialize>::deserialize_reader(
+            reader,
+        )?;
+        let mut return_value = if variant_tag == 0u8 {
+            A::B {
+                x: borsh::BorshDeserialize::deserialize_reader(reader)?,
+                y: borsh::BorshDeserialize::deserialize_reader(reader)?,
+            }
+        } else if variant_tag == 1u8 {
+            A::C(
+                borsh::BorshDeserialize::deserialize_reader(reader)?,
+                borsh::BorshDeserialize::deserialize_reader(reader)?,
+            )
+        } else {
+            return Err(
+                borsh::io::Error::new(
+                    borsh::io::ErrorKind::InvalidData,
+                    borsh::__private::maybestd::format!(
+                        "Unexpected variant tag: {:?}", variant_tag
+                    ),
+                ),
+            )
+        };
+        Ok(return_value)
     }
 }
 impl<K, V, U> borsh::de::EnumExt for A<K, V, U>
@@ -22,39 +44,16 @@ where
     V: borsh::de::BorshDeserialize,
     U: borsh::de::BorshDeserialize,
 {
-    fn deserialize_variant<
-        __R: borsh::io::Read,
-        Tag: borsh::BorshDeserialize + ::core::fmt::Debug + Eq
-            + ::core::convert::TryInto<u16> + ::core::convert::TryInto<u8> + Copy,
-    >(
+    fn deserialize_variant<__R: borsh::io::Read>(
         reader: &mut __R,
-        variant_tag: Tag,
+        variant_tag: u8,
     ) -> ::core::result::Result<Self, borsh::io::Error> {
-        use ::core::convert::TryInto;
-        let mut return_value = if TryInto::<(u8)>::try_into(variant_tag)
-            .map_err(|_| {
-                return borsh::io::Error::new(
-                    borsh::io::ErrorKind::InvalidData,
-                    borsh::__private::maybestd::format!(
-                        "Unexpected variant tag: {:?}", variant_tag
-                    ),
-                );
-            })? == 0u8
-        {
+        let mut return_value = if variant_tag == 0u8 {
             A::B {
                 x: borsh::BorshDeserialize::deserialize_reader(reader)?,
                 y: borsh::BorshDeserialize::deserialize_reader(reader)?,
             }
-        } else if TryInto::<(u8)>::try_into(variant_tag)
-            .map_err(|_| {
-                return borsh::io::Error::new(
-                    borsh::io::ErrorKind::InvalidData,
-                    borsh::__private::maybestd::format!(
-                        "Unexpected variant tag: {:?}", variant_tag
-                    ),
-                );
-            })? == 1u8
-        {
+        } else if variant_tag == 1u8 {
             A::C(
                 borsh::BorshDeserialize::deserialize_reader(reader)?,
                 borsh::BorshDeserialize::deserialize_reader(reader)?,
diff --git a/borsh-derive/src/internals/enum_discriminant.rs b/borsh-derive/src/internals/enum_discriminant.rs
index b2ca7a656..5602bba8c 100644
--- a/borsh-derive/src/internals/enum_discriminant.rs
+++ b/borsh-derive/src/internals/enum_discriminant.rs
@@ -6,21 +6,24 @@ use proc_macro2::{Ident, Span, TokenStream};
 use quote::{quote, ToTokens};
 use syn::{punctuated::Punctuated, spanned::Spanned, token::Comma, Variant};
 
-pub struct Discriminants((HashMap<Ident, TokenStream>, syn::TypePath));
+pub struct Discriminants{
+    variants: HashMap<Ident, TokenStream>, 
+    discriminant_type : syn::TypePath,
+    use_discriminant: bool,
+}
+
 impl Discriminants {
     /// Calculates the discriminant that will be assigned by the compiler.
     /// See: https://doc.rust-lang.org/reference/items/enumerations.html#assigning-discriminant-values
     pub fn new(
         variants: &Punctuated<Variant, Comma>,
         maybe_borsh_tag_width: Option<(u8, Span)>,
+        maybe_rust_repr: Option<(syn::TypePath,Span)>,
+        use_discriminant: bool,
     ) -> syn::Result<Self> {
         let mut map = HashMap::new();
         let mut next_discriminant_if_not_specified = quote! {0};
 
-        let min_tag_width: u8 = bytes_needed(variants.len())
-            .try_into()
-            .expect("variants cannot be bigger u64");
-
         for variant in variants {
             let this_discriminant = variant.discriminant.clone().map_or_else(
                 || quote! { #next_discriminant_if_not_specified },
@@ -29,65 +32,90 @@ impl Discriminants {
 
             next_discriminant_if_not_specified = quote! { #this_discriminant + 1 };
             map.insert(variant.ident.clone(), this_discriminant);
-        }
+        }    
 
-        if let Some((borsh_tag_width, span)) = maybe_borsh_tag_width {
-            if borsh_tag_width < min_tag_width {
+        let mut discriminant_type = syn::parse_str("u8").unwrap();
+
+        if let Some((tag_width, span)) = maybe_borsh_tag_width {
+            if !use_discriminant {
                 return Err(syn::Error::new(
                     span,
-                    format!(
-                        "borsh_tag_width={} is too small for the number of variants={}",
-                        borsh_tag_width,
-                        variants.len()
-                    ),
+                    "`tag_width` specifier is only allowed when `use_discriminant` is set to true",
                 ));
             }
-        }
-
-        let tag_width = maybe_borsh_tag_width
-            .map(|(tag_width, _)| tag_width)
-            .unwrap_or_else(|| (1).max(min_tag_width));
+            let Some((rust_repr, span)) = maybe_rust_repr else {
+                return Err(syn::Error::new(
+                    span,
+                    "`tag_width` specifier is only allowed when `repr` is set",
+                ));
+            };
+            match rust_repr.path.get_ident() {
+                Some(repr_type) =>  {
+                    let repr_size= match repr_type.to_string().as_str() {
+                        "u8" => {
+                            discriminant_type = syn::parse_str("u8").unwrap();
+                            1
+                        },
+                        "u16" => {
+                            discriminant_type = syn::parse_str("u16").unwrap();
+                            2
+                        },
+                        "u32" => {
+                            discriminant_type = syn::parse_str("u32").unwrap();
+                            4
+                        },
+                        _ => return Err(syn::Error::new(
+                            span,
+                            "`tag_width` specifier is only allowed when `repr` is set to a u8, u16, or u32",
+                        )),
+                    };
 
-        let tag_width_type = if tag_width <= 1 {
-            "u8"
-        } else if tag_width <= 2 {
-            "u16"
-        } else if tag_width <= 4 {
-            "u32"
-        } else if tag_width <= 8 {
-            "u64"
-        } else {
-            unreachable!("we eliminated such error earlier")
-        };
-        let discriminant_type = syn::parse_str(tag_width_type).expect("numeric");
+                    if repr_size != tag_width {
+                        return Err(syn::Error::new(
+                            span,
+                            "`tag_width` specifier must match the size of the `repr` type",
+                        ));
+                    }
+                }
+                None => {
+                    return Err(syn::Error::new(
+                        span,
+                        "`tag_width` specifier is only allowed when `repr` is set to a specific numeric type",
+                    ));
+                }
+            }
+        }
 
-        Ok(Self((map, discriminant_type)))
+        Ok(Self {
+            variants : map,
+            discriminant_type,
+            use_discriminant
+        })
     }
 
     pub fn discriminant_type(&self) -> &syn::TypePath {
-        &self.0 .1
+        &self.discriminant_type
     }
 
     pub fn get(
         &self,
         variant_ident: &Ident,
-        use_discriminant: bool,
         variant_idx: usize,
     ) -> syn::Result<TokenStream> {
-        let variant_idx: u8 = u8::try_from(variant_idx).map_err(|err| {
-            syn::Error::new(
-                variant_ident.span(),
-                format!(
-                    "up to {} enum variants are supported: {}",
-                    u8::MAX as usize + 1,
-                    err
-                ),
-            )
-        })?;
-        let result = if use_discriminant {
-            let discriminant_value = self.0 .0.get(variant_ident).unwrap();
+        let result = if self.use_discriminant {
+            let discriminant_value = self.variants.get(variant_ident).unwrap();
             quote! { #discriminant_value }
         } else {
+            let variant_idx = u8::try_from(variant_idx).map_err(|err| {
+                syn::Error::new(
+                    variant_ident.span(),
+                    format!(
+                        "up to {} enum variants are supported: {}",
+                        u8::MAX as usize + 1,
+                        err
+                    ),
+                )
+            })?;            
             quote! { #variant_idx }
         };
         Ok(result)
diff --git a/borsh-derive/src/internals/schema/enums/mod.rs b/borsh-derive/src/internals/schema/enums/mod.rs
index bfd7f9532..aef12c19c 100644
--- a/borsh-derive/src/internals/schema/enums/mod.rs
+++ b/borsh-derive/src/internals/schema/enums/mod.rs
@@ -37,7 +37,8 @@ pub fn process(input: &ItemEnum, cratename: Path) -> syn::Result<TokenStream2> {
     let mut generics_output = schema::GenericsOutput::new(&generics);
     let use_discriminant = item::contains_use_discriminant(input)?;
     let maybe_borsh_tag_width = item::get_maybe_borsh_tag_width(input)?;
-    let discriminants = Discriminants::new(&input.variants, maybe_borsh_tag_width);
+    let maybe_rust_repr = item::get_maybe_rust_repr(input);
+    let discriminants = Discriminants::new(&input.variants, maybe_borsh_tag_width, maybe_rust_repr, use_discriminant)?;
 
     // Generate functions that return the schema for variants.
     let mut variants_defs = vec![];
@@ -106,7 +107,7 @@ fn process_discriminant(
     info: DiscriminantInfo<'_>,
 ) -> syn::Result<TokenStream2> {
     info.discriminants
-        .get(variant_ident, info.use_discriminant, info.variant_idx)
+        .get(variant_ident, info.variant_idx)
 }
 
 fn process_variant(
diff --git a/borsh-derive/src/internals/serialize/enums/mod.rs b/borsh-derive/src/internals/serialize/enums/mod.rs
index 27830ebdc..e9e284040 100644
--- a/borsh-derive/src/internals/serialize/enums/mod.rs
+++ b/borsh-derive/src/internals/serialize/enums/mod.rs
@@ -18,12 +18,13 @@ pub fn process(input: &ItemEnum, cratename: Path) -> syn::Result<TokenStream2> {
     let mut fields_body = TokenStream2::new();
     let use_discriminant = item::contains_use_discriminant(input)?;
     let maybe_borsh_tag_width = item::get_maybe_borsh_tag_width(input)?;
-    let discriminants = Discriminants::new(&input.variants, maybe_borsh_tag_width)?;
+    let maybe_rust_repr = item::get_maybe_rust_repr(input);
+    let discriminants = Discriminants::new(&input.variants, maybe_borsh_tag_width, maybe_rust_repr, use_discriminant)?;
     let mut has_unit_variant = false;
 
     for (variant_idx, variant) in input.variants.iter().enumerate() {
         let variant_ident = &variant.ident;
-        let discriminant_value = discriminants.get(variant_ident, use_discriminant, variant_idx)?;
+        let discriminant_value = discriminants.get(variant_ident, variant_idx)?;
         let variant_output = process_variant(
             variant,
             enum_ident,
diff --git a/borsh/src/de/mod.rs b/borsh/src/de/mod.rs
index 1e81c5961..0abb36e3e 100644
--- a/borsh/src/de/mod.rs
+++ b/borsh/src/de/mod.rs
@@ -132,18 +132,7 @@ pub trait EnumExt: BorshDeserialize {
     /// # #[cfg(feature = "derive")]
     /// assert!(from_slice::<OneOrZero>(&data[..]).is_err());
     /// ```
-    fn deserialize_variant<
-        R: Read,
-        Tag: BorshDeserialize
-            + ::core::fmt::Debug
-            + Eq
-            + ::core::convert::TryInto<u16>
-            + ::core::convert::TryInto<u8>
-            + Copy,
-    >(
-        reader: &mut R,
-        tag: Tag,
-    ) -> Result<Self>;
+    fn deserialize_variant<R: Read>(reader: &mut R, tag: u8) -> Result<Self>;
 }
 
 fn unexpected_eof_to_unexpected_length_of_input(e: Error) -> Error {
diff --git a/borsh/tests/roundtrip/requires_derive_category/test_enum_discriminants.rs b/borsh/tests/roundtrip/requires_derive_category/test_enum_discriminants.rs
index 9b3065e7f..617a68b29 100644
--- a/borsh/tests/roundtrip/requires_derive_category/test_enum_discriminants.rs
+++ b/borsh/tests/roundtrip/requires_derive_category/test_enum_discriminants.rs
@@ -39,44 +39,44 @@ fn test_discriminant_serde_no_unit_type() {
     }
 }
 
-#[test]
-pub fn u16_discriminant() {
-    use borsh::{BorshDeserialize, BorshSerialize};
-    #[derive(BorshSerialize, BorshDeserialize, Debug, Eq, PartialEq)]
-    #[borsh(use_discriminant = true)]
-    #[repr(u32)]
-    enum U16Discriminant {
-        U8 { a: u16 } = 42,
-        U16 { b: u32 } = 666,
-    }
-    let mut buf = vec![];
-    let data = U16Discriminant::U16 { b: 1234567 };
-    data.serialize(&mut buf).unwrap();
-    assert_eq!(buf[0], 154);
-    assert_eq!(buf[1], 2);
-    assert!(buf.len(), 2);
-    let deserialized = U16Discriminant::deserialize(&mut buf.as_slice()).unwrap();
-    assert_eq!(deserialized, data);
-}
-
-#[test]
-pub fn u32_discriminant() {
-    use borsh::{BorshDeserialize, BorshSerialize};
-    #[derive(BorshSerialize, BorshDeserialize, Debug, Eq, PartialEq)]
-    #[borsh(use_discriminant = true)]
-    #[repr(u32)]
-    enum U32Discriminant {
-        U8 { a: u16 } = 42u32,
-        U32 { b: u32 } = u32::MAX,
-    }
-    let mut buf = vec![];
-    let data = U32Discriminant::U32 { b: 1234567 };
-    data.serialize(&mut buf).unwrap();
-    assert_eq!(buf[0], 154);
-    assert_eq!(buf[1], 2);
-    let deserialized = U32Discriminant::deserialize(&mut buf.as_slice()).unwrap();
-    assert_eq!(deserialized, data);
-}
+// #[test]
+// pub fn u16_discriminant() {
+//     use borsh::{BorshDeserialize, BorshSerialize};
+//     #[derive(BorshSerialize, BorshDeserialize, Debug, Eq, PartialEq)]
+//     #[borsh(use_discriminant = true)]
+//     #[repr(u32)]
+//     enum U16Discriminant {
+//         U8 { a: u16 } = 42,
+//         U16 { b: u32 } = 666,
+//     }
+//     let mut buf = vec![];
+//     let data = U16Discriminant::U16 { b: 1234567 };
+//     data.serialize(&mut buf).unwrap();
+//     assert_eq!(buf[0], 154);
+//     assert_eq!(buf[1], 2);
+//     assert!(buf.len(), 2);
+//     let deserialized = U16Discriminant::deserialize(&mut buf.as_slice()).unwrap();
+//     assert_eq!(deserialized, data);
+// }
+
+// #[test]
+// pub fn u32_discriminant() {
+//     use borsh::{BorshDeserialize, BorshSerialize};
+//     #[derive(BorshSerialize, BorshDeserialize, Debug, Eq, PartialEq)]
+//     #[borsh(use_discriminant = true)]
+//     #[repr(u32)]
+//     enum U32Discriminant {
+//         U8 { a: u16 } = 42u32,
+//         U32 { b: u32 } = u32::MAX,
+//     }
+//     let mut buf = vec![];
+//     let data = U32Discriminant::U32 { b: 1234567 };
+//     data.serialize(&mut buf).unwrap();
+//     assert_eq!(buf[0], 154);
+//     assert_eq!(buf[1], 2);
+//     let deserialized = U32Discriminant::deserialize(&mut buf.as_slice()).unwrap();
+//     assert_eq!(deserialized, data);
+// }
 
 
 #[test]
@@ -98,7 +98,6 @@ fn test_discriminant_serde_no_unit_type_no_use_discriminant() {
     }
 }
 
-//ASDF
 // minimal
 #[derive(BorshSerialize)]
 #[borsh(use_discriminant = true)]
@@ -106,7 +105,6 @@ enum MyDiscriminantEnum {
     A = 20,
 }
 
-//ASDF
 #[derive(BorshSerialize)]
 #[borsh(use_discriminant = false)]
 enum MyDiscriminantEnumFalse {
@@ -133,7 +131,6 @@ fn test_discriminant_minimal_false() {
     assert_eq!(to_vec(&MyDiscriminantEnumFalse::A).unwrap(), vec![0]);
 }
 
-//ASDF
 // sequence
 #[derive(BorshSerialize, BorshDeserialize, PartialEq, Eq, Clone, Copy, Debug)]
 #[borsh(use_discriminant = false)]