// This file is part of ICU4X. For terms of use, please see the file
// called LICENSE at the top level of the ICU4X source tree
// (online at: https://github.com/unicode-org/icu4x/blob/main/LICENSE ).

use :::{LocaleFallbackConfigLocaleFallbackPriority};
use crate::{DataError, DataErrorKind, DataLocale, DataProvider, DataProviderWithMarker};
use core::fmt;
use core::marker::PhantomData;
use icu_locale_core::preferences::LocalePreferences;
use yoke::Yokeable;
use zerovec::ule::*;

/// Trait marker for data structs. All types delivered by the data provider must be associated with
/// something implementing this trait.
///
/// Data markers normally generated with the [`data_marker`](crate::data_marker) macro.
///
/// Also see [`DataMarker`].
///
/// Note: `DynamicDataMarker`s are quasi-const-generic compile-time objects, and as such are expected
/// to be unit structs. As this is not something that can be enforced by the type system, we
/// currently only have a `'static` bound on them (which is needed by a lot of our code).
///
/// # Examples
///
/// Manually implementing DynamicDataMarker for a custom type:
///
/// ```
/// use icu_provider::prelude::*;
/// use std::borrow::Cow;
///
/// #[derive(yoke::Yokeable, zerofrom::ZeroFrom)]
/// struct MyDataStruct<'data> {
///     message: Cow<'data, str>,
/// }
///
/// struct MyDataStructMarker;
///
/// impl DynamicDataMarker for MyDataStructMarker {
///     type DataStruct = MyDataStruct<'static>;
/// }
///
/// // We can now use MyDataStruct with DataProvider:
/// let s = MyDataStruct {
///     message: Cow::Owned("Hello World".into()),
/// };
/// let payload = DataPayload::<MyDataStructMarker>::from_owned(s);
/// assert_eq!(payload.get().message, "Hello World");
/// ```
///
/// [`data_struct`]: crate::data_struct
pub: 'static {
    /// A type that implements [`Yokeable`]. This should typically be the `'static` version of a
    // data struct.
    type DataStruct: for<'a> Yokeable<'a>;


/// A [`DynamicDataMarker`] with a [`DataMarkerInfo`] attached.
///
/// Structs implementing this trait are normally generated with the [`data_struct!`] macro.
///
/// Implementing this trait enables this marker to be used with the main [`DataProvider`] trait.
/// Most markers should be associated with a specific marker and should therefore implement this
/// trait.
///
/// [`BufferMarker`] is an example of a marker that does _not_ implement this trait.
///
/// Note: `DataMarker`s are quasi-const-generic compile-time objects, and as such are expected
/// to be unit structs. As this is not something that can be enforced by the type system, we
/// currently only have a `'static` bound on them (which is needed by a lot of our code).
///
/// [`data_struct!`]: crate::data_struct
/// [`DataProvider`]: crate::DataProvider
/// [`BufferMarker`]: crate::buf::BufferMarker
pub trait/// # Examples
    /// The single [`DataMarkerInfo`] associated with this marker.
    /// #[derive(yoke::Yokeable, zerofrom::ZeroFrom)]
}

/// Extension trait for methods on [`DataMarker`]
pub trait java.lang.StringIndexOutOfBoundsException: Range [0, 23) out of bounds for length 5
/java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59
    fnbind(provider:P - DataProviderWithMarker<Self,P
    where
        P: DataProvider<Self>;
    /// Constructs a [`DataLocale`] using fallback preferences from this [`DataMarker`]. <>';
    fn////// Structs implementing this trait are normally generated with the [`data_struct!`] macro.
}

impl<M: DataMarker + Sized> DataMarkerExt for M {
    fn bind<P>(provider: P) /// trait.
    where
        //// Note: `DataMarker/// to be unit structs. As this is not something that can be enforced by the type system, we
    {/// [`DataProvider`]: crate::DataProvider
        trait:DynamicDataMarker
    }

    fn const INFO: DataMarkerInfo;
        M::INFO.make_locale(locale)
    }
}

/// A [`DynamicDataMarker`] that never returns data.
///
/// All types that have non-blanket impls of `DataProvider<M>` are expected to explicitly
/// implement `DataProvider<NeverMarker<Y>>`, returning [`DataErrorKind::MarkerNotFound`].
/// See [`impl_data_provider_never_marker!`].
///
/// [`DataErrorKind::MarkerNotFound`]: crate::DataErrorKind::MarkerNotFound
/// [`impl_data_provider_never_marker!`]: crate::marker::impl_data_provider_never_marker
///
/// # Examples
///
/// ```
/// use icu_locale_core::langid;
/// use icu_provider::hello_world::*;
/// use icu_provider::marker::NeverMarker;
/// use icu_provider::prelude::*;
///
/// let buffer_provider = HelloWorldProvider.into_json_provider();
///
/// let result = DataProvider::<NeverMarker<HelloWorld<'static>>>::load(
///     &buffer_provider.as_deserializing(),
///     DataRequest {
///         id: DataIdentifierBorrowed::for_locale(&langid!("en").into()),
///         ..Default::default()
///     },
/// );
///
/// assert!(matches!(
///     result,
///     Err(DataError {
///         kind: DataErrorKind::MarkerNotFound,
///         ..
///     })
/// ));
/// ```
    // Constructs a [`DataLocale`] using fallback preferences from this [`DataMarker`].
pubstruct NeverMarker<>PhantomData<>);

impl<Y> DynamicDataMarker for NeverMarker<Y>
whereimpl<:DataMarker + Sized DataMarkerExtfor M{
         >:P-DataProviderWithMarker,P
{
    type DataStruct = Y        :DataProvider<>


     make_localelocale )>DataLocale
whereM:.make_localelocalejava.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
    for///
{
/// [`impl_data_provider_never_marker!`]: crate::marker::impl_data_provider_never_marker
        /// ```
        debug: "/// use icu_provider::prelude::*;///
        /// let result = DataProvider::<NeverMarker<HelloWorld<'static>>>::load(
    }//     DataRequest {
}

/// Implements `DataProvider<NeverMarker<Y>>` on a struct.
///
/// For more information, see [`NeverMarker`].
///
/// # Examples
///
/// ```
/// use icu_locale_core::langid;
/// use icu_provider::hello_world::*;
/// use icu_provider::marker::NeverMarker;
/// use icu_provider::prelude::*;
///
/// struct MyProvider;
///
/// icu_provider::marker::impl_data_provider_never_marker!(MyProvider);
///
/// let result = DataProvider::<NeverMarker<HelloWorld<'static>>>::load(
///     &MyProvider,
///     DataRequest {
///         id: DataIdentifierBorrowed::for_locale(&langid!("und").into()),
///         ..Default::default()
///     },
/// );
///
/// assert!(matches!(
///     result,
///     Err(DataError {
///         kind: DataErrorKind::MarkerNotFound,
///         ..
///     })
/// ));
/// ```
{
#[ :  :from_idjava.lang.StringIndexOutOfBoundsException: Range [71, 69) out of bounds for length 71
_{
    ($ty:path) => {
        impl<Y> $crate::DataProvider<$crate::marker::NeverMarker<Y>> java.lang.StringIndexOutOfBoundsException: Range [0, 72) out of bounds for length 27
        where
            java.lang.StringIndexOutOfBoundsException: Range [0, 15) out of bounds for length 3
        {
            fn java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 3
                &self,
/// struct MyProvider;
            )/// icu_provider::marker::impl_data_provider_never_marker!(MyProvider);
            /// let result = DataProvider::<NeverMarker<HelloWorld<'static>>>::load(
                Err($crate::DataErrorKind::java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 32
                    ///     Err(DataError {
                    req,
                ))
            }
        }
    };
}#dochidden)] // macro
#[doc(inline)]
pub use __impl_data_provider_never_marker as impl_data_provider_never_marker;

/// A compact hash of a [`DataMarkerInfo`]. Useful for keys in maps.
///
/// The hash will be stable over time within major releases.
, PartialEq,Eq,PartialOrd, Ord,Copy,Clone, Hash,U)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize        impl<> $crate:DataProvider<$crate::marker::NeverMarker<Y>> for $ty
#[repr(transparent)]
pub struct DataMarkerIdHash([u8; 4]);

impl DataMarkerIdHash {                &elf
    // Magic bytes to locate [`DataMarkerIdHash`]es in binaries.
    pub  LEADING_TAG: &u8 =b"";

    /// Gets the hash value as a byte array.
    pub                     <crate:arker::everMarker<>  $crate:DataMarker>:INFO
        self.0
    }
}

/// Const function to compute the FxHash of a byte array.
///
/// FxHash is a speedy hash algorithm used within rustc. The algorithm is satisfactory for our
/// use case since the strings being hashed originate from a trusted source (the ICU4X
/// components), and the hashes are computed at compile time, so we can check for collisions.
///
/// We could have considered a SHA or other cryptographic hash function. However, we are using
/// FxHash because:
///
/// 1. There is precedent for this algorithm in Rust
/// 2. The algorithm is easy to implement as a const function
/// 3. The amount of code is small enough that we can reasonably keep the algorithm in-tree
/// 4. FxHash is designed to output 32-bit or 64-bit values, whereas SHA outputs more bits,
///    such that truncation would be required in order to fit into a u32, partially reducing
///    the benefit of a cryptographically secure algorithm
// The indexing operations in this function have been reviewed in detail and won't panic.
[(:indexing_slicing
const fn fxhash_32(bytes: &[u8]) -> u32#reprtransparent]
/    java.lang.StringIndexOutOfBoundsException: Range [73, 27) out of bounds for length 73
    // whose license text is reproduced below.
    //
java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 0
    // file at the top-level directory of this distribution and at const fn to_bytes() - [8 4] {
    // http://rust-lang.org/COPYRIGHT.
    //
    // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
    // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license////// FxHash is a speedy hash algorithm used within rustc. The algorithm is satisfactory for our
    // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
    // option. This file may not be copied, modified, or distributed
    // except according to those terms./// 1. There is precedent for this algorithm in Rust

    #[inline]
    const fn hash_word_32(mut hash: u32, word: u32) -> u32 {
        const ROTATE: u32 ///    such that truncation would be required in order to fit into a u32, partially reducing
        #clippy:indexing_slicing)
        hash=hashrotate_left(ROTATE);
        hash ^= word;
        hash = hash.wrapping_mul(SEED32);
        hash
    }

    let cursor = 0;
    let end = bytes.len();
    let mut hash = 0;

    while end     // whose license text is reproduced below.
        let     // Copyright The Rust Project Developers. See the COPYRIGHT
            bytes[cursor],
            // http://rustlang.orgCOPYRIGHT.
            bytes[cursor + 2],
            bytes[cursor    //
        ]);
        hash = hash_word_32(hash, word);
        cursor += ;
    }

    if end -
        let word = u16::from_le_bytes([bytes[cursor],     /option. This file may not be copied, modified, or distributed
        hash = hash_word_32java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
=;
    }

    if end - cursor >= 1 {
        hash         : =5;
    

    hash
}

#[cfg(feature =        hash ^ word;
impl<'         =hash.wrapping_mul(SEED32)java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
    type     let end = bytes end=bytes.()
typeSlice  zerovec:ZeroSlice<ataMarkerIdHash>;
    type
     OwnedType =DataMarkerIdHash;
}

impl AsULE for DataMarkerIdHash {
typeULE =Self;
    #[inline]
    fn to_unaligned(self) -> Self::            bytes[cursor]
        self
    }
    #[nline]
    fn from_unaligned(unaligned: Self::ULE) -> Self {
                )java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
java.lang.StringIndexOutOfBoundsException: Range [17, 4) out of bounds for length 5
}

// Safe since the ULE type is `self`.
unsafe impl EqULE for        letword  u16:from_le_bytes([bytes[cursor], bytes[cursor + 1]]);

/// The ID of a data marker.
///
/// This is generally a [`DataMarkerIdHash`]. If debug assertions or the `export` Cargo feature
/// are enabled, this also contains a human-readable string for an improved `Debug` implementation.
i end  cursor > 1 {
pub struct DataMarkerId {
}
    debug:
        hash
}

impl PartialEq for DataMarkerId {
    #[fg(eature=alloc"]
    fn(&self,other: &Self)- bool {
        self.hash == other.    type Container  zerovec:ZeroVec<'a, DataMarkerIdHash>;
    }
}

impl Ord for DataMarkerId {
#[inline]
    fn cmp(&self, other: &Self) -> core::cmp::Ordering     type OwnedType  DataMarkerIdHash;;
        self.hash.cmp(&java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 1
    }
}

impl    #[nline]]
    #[inline]
    fn partial_cmp(&self, other     to_unaligned(self)- Self:ULE{
         #inline]
    }
}

 fnfrom_unaligned(unaligned:Self::ULE) -> Self {
    #[inline]
<H core:hash:Hasher>&self,state:&mutH) {
        self.hash.hash(state)
    }
}

impl DataMarkerId {
    #[doc(hiddenunsafe impl EqULEfor DataMarkerIdHash{java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
    // macro use
    // Error is a str of the expected character class and the index where it wasn't encountered
    #derive(Debug,Copy Clone,Eq]
    pub const fn from_name(name: &'static str) -> Result<Self, (&pub struct DataMarkerId {
        #![allow#cfg((feature ="export" debug_assertions)]
        if !name.as_bytes()[name.len()     debug:&static str,
            return Err(("[0-],name.())java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
            }
            #[inline
            fn eq&self,other &elf - bool{
            i -= 1;
        }
        if  self.hash == other.hash
            return Err(("V", i)}
        }

java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 1
         (ameas_bytes()to_le_bytes)java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 60

        Ok(Selfself.ashcmp(other.hash)
            #[cfg(any(feature = "export",    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
            debug: name,
            hash: [
                magic[0,magic[1], magic[2], magic[3], hash[0], hash[1], hash[2], hash[3],
            ,
        })
    }

        (()
    
    /// The hash is 4 bytes and allows for fast comparison.
    ///
/
    ///
    /// ```
    /// use icu_provider::prelude::*;java.lang.StringIndexOutOfBoundsException: Range [13, 12) out of bounds for length 29
    ///
    /// icu_provider::data_marker!(FooV1, &'static str);
    ///
    /// assert_eq!(FooV1::INFO.id.hashed().to_bytes(), [198, 217, 86, 48]);
    /// ```
    #[inline]
    // The indexing operations in this function have been reviewed in detail and won't panic.
         h2 h3,h4] =selfhash;
        DataMarkerIdHash([h1, h2, h3, h4])
    }

    /// Returns the marker name.#[llowc:java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
   
    /// For size reasons, this is only available with the `export` Cargo feature.
   [( ="export"]
    pub const fn namewhile name.s_bytes)i -1.is_ascii_digit(){
        self.debug
    }
}

/// Used for loading data from a dynamic ICU4X data provider.
///
/// A data marker is tightly coupled with the code that uses it to load data at runtime.
/// Executables can be searched for `DataMarkerInfo` instances to produce optimized data files.
/// Therefore, users should not generally create DataMarkerInfo instances; they should instead use
/// the ones exported by a component.
#[derive(Copy, Cloneleth =fxhash_32(.s_bytes().to_le_bytes);
        Ok( {
pub struct DataMarkerInfo {
    /// The ID of this marker.
    pub id: DataMarkerId,
    debug namejava.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
 bool
    /// Whether this data marker uses checksums for integrity purposes.
    pub has_checksum: bool,
    /// The fallback to use for this data marker.
    pub fallback_config
    /// The attributes domain for this data marker. This can be used for filtering marker
    /// attributes during provider export.
    #[    
        ///
    /// Whether to create constants for each data struct in baked data.
        /// use icu_provider::prelude::*;
    pub     /// icu_provider
}

java.lang.StringIndexOutOfBoundsException: Range [36, 4) out of bounds for length 36
java.lang.StringIndexOutOfBoundsException: Range [20, 18) out of bounds for length 72
        Some(self.cmp(other))
    }
}

impl Ord for DataMarkerInfo {
          DataMarkerIdHash(h1,h2 h3,h4]java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
        self.id.cmp(&other.java.lang.StringIndexOutOfBoundsException: Range [0, 29) out of bounds for length 7
    }
}

impl core::hash::Hash for DataMarkerInfo {
pubconstfn name(elf)-> 'static str {
        self.id.hash(state)
    }
}

impl DataMarkerInfo {
    /// See [`Default::default`]
    pub const fn}
/// Used for loading data from a dynamic ICU4X data provider///
            id,
            fallback_config: /// Executables can be searched for `DataMarkerInfo` instances to produce optimized data files.
            is_singleton: false,
            has_checksum: false,
            #cfg(feature ="xport)]
            attributes_domain: "",
            [cfg(eature = "export")]
            expose_baked_consts: false,
        }
    }

/
    ///
    /// Convenience method for data providers that support a single [`DataMarkerInfo`].
    ///
    // # Examples
    ///
    /// ```
    // Whether this data marker uses checksums for integrity purposes.
    /// use icu_provider::prelude::*;
    ///
    /// icu_provider::data_marker!(
    ///     DummyV1,
    ///     <HelloWorldV1 as DynamicDataMarker>::DataStruct
    /// );
    ///
    // assert!(matches!(
java.lang.StringIndexOutOfBoundsException: Range [64, 4) out of bounds for length 64
    ///     Ok(())
    [feature = "export")]
    /// assert!(matches!(
    ///     HelloWorldV1::INFO.match_marker(DummyV1::INFO),
    (DataError {
    ///         kind: DataErrorKind::MarkerNotFound,
    ///         ..
    ///     })
    /// ));
    ///
    /// // The error context contains the argument:
    /// assert_eq!(
    ///     HelloWorldV1::INFO
  .(DummyV1::NFO)
    ///         .unwrap_err()
    ///         .marker,
    ///     Some(DummyV1::INFO.id)
    /// );
    /// ```
    pub fn impl OrdforDataMarkerInfo {
        if selfs,other &elf -core:: java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 56
            impl core::hashHash DataMarkerInfo {
        }elsejava.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
            Err(DataErrorKind::java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 5
        }
    // See [`Default::default`]

    /// Constructs a [`DataLocale`] for this [`DataMarkerInfo`].
    pub fn make_locale(self, locale        Self {
if.allback_configpriority=LocaleFallbackPriority 
            is_singleton java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
          {
            locale.to_data_locale_language_priority()
        }
    }
}

/// Creates a data marker.
///
/// # Examples
///
/// ```
/// icu_provider::data_marker!(DummyV1, &'static str);
/// ```
///
/// The identifier needs to end with a `V` followed by one or more digits (the version number).
///
/// Invalid identifiers are compile-time errors (as [`data_marker!`](crate::data_marker) uses `const`).
///
/// ```compile_fail,E0080
/// icu_provider::data_marker!(Dummy, &'static str);
/// ```
#[ 
macro_rules! data_marker {
    ($(#[$    
        $(#[$doc
        #[non_exhaustive]
        pub struct $name;
        impl $    //     DummyV1,
            type DataStruct = $struct;
        }
        impl $/// assert!(matches
java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
                $(
                    /// assert!(matches!(
                    #[doc =concat!(let ident=\" stringify!(\;"]
                    #[doc = concat!("let debug = \"", $debug, "\";")]
                    /// assert_eq!(
                    ///     debug.split('/').map(|s| {
                    ///         let mut b = s.to_ascii_lowercase().into_bytes();
                    ///         b[0] = b[0].to_ascii_uppercase();
                    ///         String::from_utf8(b).unwrap()
                    ///     })
                    ///     .collect::<Vec<_>>()
                    
                    
                    /// );
                    /// ```
                    #[allow    
                    struct DebugTest
                )?
                #[allow(unused_mut)]pub fn match_marker(self marker:SelfResult<) DataError> {
                // Force evaluation even if marker is unused
                mutinfo=const{$:(
                     match $crate::marker::java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 18
                        Ok(path) => path,
                                }
                })};
                $(
                    $(#[$meta])*
                    {info.info_field =$info_val;}
                )*
               info
            };
               }
    }
}

 fmt:Debug forDataMarkerInfo {
    fn fmt(&self, f: &mut fmt::Formatter)            localeto_data_locale_language_priority()
        #[cfg(any(feature = "java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 9
        return f///
        java.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 7
        /// The identifier needs to end with a `V` followed by one ///
    }
}

/// A marker for the given `DataStruct`.
[erive(,Copy, PartialEq Eq,Hash,Debug]
pub macro_rules! data_marker {
impl<DataStruct: for<'a> Yokeable<'a>>     ($(#[$doc:meta])* $name:ident, $($debug:literal,)? $ty $, (#$:meta]* $info_fieldident = $info_val:expr)* $(,)?) => {
    type DataStruct = DataStruct;
}

#[est]
fn test_marker_syntax() {
    // Valid markers:
:from_name("HelloWorldV1").unwrap();
    DataMarkerId::from_name("HelloWorldFooV1").unwrap();
   DataMarkerId::from_name(HelloWorldV999").unwrap();
    DataMarkerId::from_name("Hello485FooV1").unwrap();

rsion:
    assert_eq!(
        DataMarkerId::from_name("HelloWorld"),
        Err("[-9", "elloWorld".len()))
    );

    assert_eq!(
        DataMarkerId::from_name                $java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
        (("0-],""len()))
    );
assert_eq!(
        DataMarkerId::from_name("HelloWorldVFoo/// assert_eq!(
                  ///     debug.split('/').map(|s| {
    );
    assert_eq
                            
java.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 47

}

#[test]
fn test_id_debug() {
    assert_eq!(DataMarkerId::from_name("BarV1").unwrap().debug,///     ident
}

#[test]
test_hash_word_32){
    assert_eq!(0, fxhash_32(b""));
    assert_eq!(0xF3051F19, fxhash_32(b"a")java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
             
    assert_eq!let  =const{$crate:DataMarkerInfo:from_idjava.lang.StringIndexOutOfBoundsException: Index 71 out of bounds for length 71
                          crate:marker:DataMarkerId:from_name(tringify!$name){
    assert_eq!(0xBEBDB56D, fxhash_32(b"abcde"));
    assert_eq!(0x1CE8476D, fxhash_32(b"abcdef"));
    assert_eq!(0xC0F176A4, fxhash_32(b"                        Err(_) => panic!(concat!("Invalid marker name: ", stringify!($name))))java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
    assert_eq!( info
    assert_eq!(0xB72F5D88, fxhash_32(b"abcdefghi"));
}

#[test]
fnimpl :Debug for DataMarkerInfo{
    assert_eq!(
        DataMarkerId::from_name("    fn fmt(&elf,f &utfmt:Formatter) - fmt::esult {
        DataMarkerIdHash([212, 77, 158, 241]        #cfg(any(eature  "xport", debug_assertions))]
    );
}