enum CStyleEnum {
    A = 1,
    B = 2,
    C,
    D = 5,
    E,
}


impl bincode::de::Decode for CStyleEnum {
    fn decode<D: bincode::de::Decoder>(
        mut decoder: D,
    ) -> Result<Self, bincode::error::DecodeError> {
        let variant_index = <u32 as bincode::de::Decode>::decode(&mut decoder)?;
        match variant_index {
            1 => Ok(Self::A {}),
            2 => Ok(Self::B {}),
            x if x == 2 + 1u32 => Ok(Self::C {}),
            5 => Ok(Self::D {}),
            x if x == 5 + 1u32 => Ok(Self::E {}),
            variant => Err(bincode::error::DecodeError::UnexpectedVariant {
                found: variant,
                type_name: "CStyleEnum",
                allowed: bincode::error::AllowedEnumVariants::Allowed(&[
                    1,
                    2,
                    2 + 1u32,
                    5,
                    5 + 1u32,
                ]),
            }),
        }
    }
}

impl bincode::enc::Encode for CStyleEnum {
    fn encode<E: bincode::enc::Encoder>(
        &self,
        mut encoder: E,
    ) -> core::result::Result<(), bincode::error::EncodeError> {
        match self {
            Self::A => {
                <u32 as bincode::enc::Encode>::encode(&(1), &mut encoder)?;
            }
            Self::B => {
                <u32 as bincode::enc::Encode>::encode(&(2), &mut encoder)?;
            }
            Self::C => {
                <u32 as bincode::enc::Encode>::encode(&(2 + 1u32), &mut encoder)?;
            }
            Self::D => {
                <u32 as bincode::enc::Encode>::encode(&(5), &mut encoder)?;
            }
            Self::E => {
                <u32 as bincode::enc::Encode>::encode(&(5 + 1u32), &mut encoder)?;
            }
        }
        Ok(())
    }
}