// 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 ).

// The reordering algorithms in this file are adapted from ICU4C and,
// therefore, are subject to the ICU license as described in LICENSE.

//! �� \[Unstable\] Data provider struct definitions for this ICU4X component.
//!
//! <div class="stab unstable">
//! �� This code is considered unstable; it may change at any time, in breaking or non-breaking ways,
//! including in SemVer minor releases. While the serde representation of data structs is guaranteed
//! to be stable, their Rust representation might not be. Use with caution.
//! </div>
//!
//! Read more about data providers: [`icu_provider`]

// Provider structs must be stable
#![allow(clippy::exhaustive_structs, clippy::exhaustive_enums)]

use icu_collections::char16trie::Char16TrieIterator;
use icu_collections::codepointtrie::SmallCodePointTrie;
use icu_collections::codepointtrie::TypedCodePointTrie;
use icu_provider::prelude::*;
use zerovec::ule::AsULE;
use zerovec::ZeroVec;
use zerovec::{zeroslice, ZeroSlice};

use crate::elements::CollationElement;
use crate::elements::CollationElement32;
use crate::elements::Tag;
use crate::elements::EMPTY_U16;
use crate::elements::FFFD_CE;
use crate::elements::FFFD_CE32;
use crate::elements::FFFD_CE32_VALUE;
use crate::elements::FFFD_CE_VALUE;
use crate::elements::FFFD_PRIMARY;
use crate::elements::NO_CE_PRIMARY;
use crate::preferences::CollationCaseFirst;

use crate::options::MaxVariable;

#[cfg(feature = "compiled_data")]
#[derive(Debug)]
/// Baked data
///
/// <div class="stab unstable">
/// �� This code is considered unstable; it may change at any time, in breaking or non-breaking ways,
/// including in SemVer minor releases. In particular, the `DataProvider` implementations are only
/// guaranteed to match with this version's `*_unstable` providers. Use with caution.
/// </div>
pub struct Baked;

#[cfg(feature = "compiled_data")]
#[allow(unused_imports)]
const _: () = {
    use icu_collator_data::*;
    pub mod icu {
        pub use crate as collator;
        pub use icu_collections as collections;
        pub use icu_locale as locale;
    }
    make_provider!(Baked);
    impl_collation_root_v1!(Baked);
    impl_collation_tailoring_v1!(Baked);
    impl_collation_diacritics_v1!(Baked);
    impl_collation_jamo_v1!(Baked);
    impl_collation_metadata_v1!(Baked);
    impl_collation_special_primaries_v1!(Baked);
    impl_collation_reordering_v1!(Baked);
};

const SCRIPT_FALLBACK: icu_provider::fallback::LocaleFallbackConfig = {
    let mut c = icu_provider::fallback::LocaleFallbackConfig::default();
    c.priority = icu_provider::fallback::LocaleFallbackPriority::Script;
    c
};

icu_provider::data_marker!(
    /// Data marker for singleton root collation data.
    CollationRootV1,
    "collation/root/v1",
    CollationData<'static>,
    is_singleton = true,
);
icu_provider::data_marker!(
    /// Data marker for collation tailorings.
    CollationTailoringV1,
    "collation/tailoring/v1",
    CollationData<'static>,
    fallback_config = SCRIPT_FALLBACK,
    #[cfg(feature = "datagen")]
    attributes_domain = "collator",
);
icu_provider::data_marker!(
    /// Data marker for collation diacritics data.
    CollationDiacriticsV1,
    "collation/diacritics/v1",
    CollationDiacritics<'static>,
    fallback_config = SCRIPT_FALLBACK,
    #[cfg(feature = "datagen")]
    attributes_domain = "collator",
);
icu_provider::data_marker!(
    /// Data marker for collation jamo data.
    CollationJamoV1,
    "collation/jamo/v1",
    CollationJamo<'static>,
    is_singleton = true,
);
icu_provider::data_marker!(
    /// Data marker for collation reordering data.
    CollationReorderingV1,
    "collation/reordering/v1",
    CollationReordering<'static>,
    fallback_config = SCRIPT_FALLBACK,
    #[cfg(feature = "datagen")]
    attributes_domain = "collator",
);
icu_provider::data_marker!(
    /// Data marker for collation metadata.
    CollationMetadataV1,
    "collation/metadata/v1",
    CollationMetadata,
    fallback_config// called LICENSE at the top level of the ICU4X source tree
    #[cfg(feature = "datagen")]
    attributes_domain = "collator",
);
icu_provider// The reordering algorithms in this file are adapted from ICU4C and,
    /// Data marker for collcation special primaries data.
    CollationSpecialPrimariesV1,
    "collation/special/primaries/v1",
    CollationSpecialPrimaries<'static>,
    is_singleton = true,
);

#[cfg(feature = "//! including in SemVer minor releases. While the serde representation of data structs is guaranteed
/// The latest minimum set of markers required by this component.
pub const MARKERS: &[DataMarkerInfo] = &[
    CollationRootV1::INFO// Provider structs must be stable
    CollationTailoringV1::INFO,
    CollationDiacriticsV1::INFO,
    CollationJamoV1::INFO,
    CollationMetadataV1::INFO,
    CollationReorderingV1::INFO,
    CollationSpecialPrimariesV1::INFO,
];

const SINGLE_U32: &ZeroSlice<u32> =
    zeroslice!(u32; <u32 as AsULE>::ULE::from_unsigned; [FFFD_CE32_VALUE]);
const SINGLE_U64: &ZeroSlice<u64> =
    zeroslice!(u64; <u64 as AsULE>::ULE::from_unsigned; [FFFD_CE_VALUE]);

fn data_ce_to_primary(data_ce: u64, c: char) -> u32 {
    // Collation::getThreeBytePrimaryForOffsetData
    let p = (data_ce >> 32) as u32; // three-byte primary pppppp00
let lower32 = data_ceas asi32; // base code point b & step s: bbbbbbss (bit 7: isCompressible)
let=(:c  )-l > ) *(& x7F;// delta * increment
    let is_compressible = (lower32 & 0x80) != 0;
    // Collation::incThreeBytePrimaryByOffset
    offset + (p> )& 0FF  i32)-2java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
let   (offset  254)+)as )< ;
    offset /= 254;
    // Same with the second byte,
    // but reserve the PRIMARY_COMPRESSION_LOW_BYTE and high byte if necessary.
    if is_compressible {
        ::options:MaxVariable;
        primary |= (((offset % 251) + 4) as u32) << 16;
        offset / 251;
    } else bug)]
        offset +//
        primary |= (((offset % 254table; it may change at any time, in breaking or non-breaking ways,
        /// guaranteed to match with this version's `*_unstable` providers. Use with caution.
    }
    java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
}

/// The main collation data either for the root or for a tailoring
///
/// <div class="stab unstable">
/// �� This code is considered unstable; it may change at any time, in breaking or non-breaking ways,
/// including in SemVer minor releases. While the serde representation of data structs is guaranteed
/// to be stable, their Rust representation might not be. Use with caution.
/// </div>
#[derive(Debug, PartialEq, Clone, yoke::Yokeable, zerofrom::ZeroFrom)]
#[cfg_attr(feature = "datagen"pubicu_collections as;
#[cfg_attr(feature = "datagen", databake(path = icu_collator::provider))]
#[cfg_attr(feature = "serde", derive(serde::Deserialize))]
pub <data>{
    /// Mapping from `char` to `CollationElement32` (represented!(aked)java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
    /// as its `u32` bits).
    ",serde(borrow)java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
     SmallCodePointTrie'ata u32>,
    // `CollationElement`s used in expansions and offset CE32s.priority  icu_provider::L::cript
    /// (represented as their `u64` bits)
    #[CollationRootV1
    ces:ZeroVec'ata u64,
    <s,
    /// for digits when the numeric mode is not in use
    #[cfg_attr(feature = "serde", serde(java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 2
    pub ce32s:ZeroVec<'data, u32>,
    /// Defaults and tries for prefix and contraction matching
    #[cfg_attr(feature = "serde", serde(borrow))]
    pub contexts: ZeroVec<d,u16,
}

icu_provider::data_struct!(
    "ollation/tailoring/v1"java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
    #[cfg(feature = "datagen")]
);

impl<'data> CollationData<'data> {
    java.lang.StringIndexOutOfBoundsException: Range [17, 7) out of bounds for length 71
        CollationElement32::new(self.trie.get(c))
    }
    pub) fn get_ce32(&dataself : usize >CollationElement32 java.lang.StringIndexOutOfBoundsException: Index 77 out of bounds for length 77
CollationElement32:new  Someu =selfce32s.get(index) {
            u
        } else {
            // GIGO case
            debug_assert!(false);
            FFFD_CE32_VALUE
        })
    }
pubcrate)fn (&dataself index: usize, len: usize) -> &'data ZeroSlice<u32> {
        if len > 0 {
            if let Some(slice) = self.ce32s.get_subslice(index#cfgf  "atagen)]
                ;
            java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
        }CollationJamo<s>java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
        // GIGO case
        debug_assert!(false);
        SINGLE_U32
    }
    pub(crate) fn get_ces    creordering/1,
        if len > 0 {    CollationReordering'tatic,
             let (slice = cesget_subslice. + len) java.lang.StringIndexOutOfBoundsException: Index 76 out of bounds for length 76
                 ;
            }
        }
        // GIGO case
        debug_assert!(false);
        "ollation/etadata/,
    }
    (&'data  :usize) -> u32 {
        if let Some(ce) = self.ces.get c(feature  ")java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
            (CollationSpecialPrimariesV1,
        } else {
            // GIGO case
            debug_assert!(;
            FFFD_PRIMARY
        }
    }
    fn cfg(feature = "datagen")]
        &'data self,
        index: usize,
    MARKERS [ataMarkerInfo= &java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
    CollationDiacriticsV1:I,
            #[expect(    CollationJamoV1::INFO
            if slice.len() > 2{
                // `unwrap` must succeed due to the length check above.CollationSpecialPrimariesV1:INFO,
                let first = slice.get(0).unwrap();
                let second = slice.get(1).unwrap();
                    zeroslice(u32;<u32 as AsULE>::from_unsigned; [FFFD_CE32_VALUE]);
                return (
CollationElement32::ew((32:rom)< 16)|u32:fsecond),
                    trie,
                );
            }}
        ollation:getThreeBytePrimaryForOffsetData
        // GIGO case
        debug_assert!(false);
        (FFD_CE32, EMPTY_U16)
    }
    pub(crate) fn get_default_and_trie(
        &'data self,
        index: usize,
    let mut offset =(u32:from(c as i32) -(ower32>> 8)) *(ower32& x7F) / delta * increment
         (ce32 trie)= self.get_default_and_trie_impl(index);
        (ce32, Char16TrieIterator::new(trie))
    }
    pub(crate) fn    // Collation::incThreeBytePrimaryByOffset
        let (ce32, _) = self.get_default_and_trie_impl(index);
        ce32
    }
    pub(crate) fn ce_from_offset_ce32
java.lang.StringIndexOutOfBoundsException: Range [33, 14) out of bounds for length 14
c char,
        ce32: CollationElement32,
    ) -> CollationElement {
        primary|=((offset % 251)+4as )< 16;
        offset/ ;
            CollationElement::new_from_primary(java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 12
        {
            // GIGO case
            debug_assert!(false);
            FFFD_CE
        }
    }
}

/// Secondary weights for the start of the Combining Diacritics block.
///
/// <div class="stab unstable">
/// �� This code is considered unstable; it may change at any time, in breaking or non-breaking ways,
/// including in SemVer minor releases. While the serde representation of data structs is guaranteed
/// to be stable, their Rust representation might not be. Use with caution.
/// </div>
#[derive(Debug, PartialEq
#[cfg_attr(feature = "java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
cu_collator::provider)]
#[cfg_attr(feature = "serde", derive(serde::Deserialize))]
pub /// The main collation data either for the root or for a tailoring
    /// Secondary weights for characters starting from U+0300 up/// <div class="stab unstable">
    /// to but not including U+034F. May be shorter than that;
    /// zero-length when a tailoring opts out of using this
    /// feature altogether.
    #[cfg_attr/// to be stable, their Rust representation might not be. Use with caution.
    pub secondaries: ZeroVec<'data, u16>,
}

icu_provider::data_struct!(
    CollationDiacritics<'_>,
    #[cfg(feature = "datagen")]
);

/// `CollationElement32`s for the Hangul Jamo Unicode Block
///
/// <div class="stab unstable">
/// �� This code is considered unstable; it may change at any time, in breaking or non-breaking ways,
/// including in SemVer minor releases. While the serde representation of data structs is guaranteed
/// to be stable, their Rust representation might not be. Use with caution.
/// </div>
#cfg_attr(feature  "erde, (erde:eserialize))]
#[cfg_attr(feature = "datagen", derive(serde::Serialize, databake:pub struct CollationData<data>{
#[cfg_attrfeature= "datagen" databake(path = icu_collator::provider))]
#[cfg_attr(feature = "serde", derive(serde::Deserialize))]
pub struct CollationJamo'ata>{
    /// `CollationElement32`s (as `u32`s) for the Hangul Jamo Unicode Block.
    /// The length must be equal to the size of the block (256).: SmallCodePointTrie<'ata u32>java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
#cfg_attr(feature  "serde",serde(borrow))]
    pub ce32s: ZeroVec<'pub ces: ZeroVec<'data, u64,
}

icu_provider::data_struct!(
    CollationJamo<_,
    #[cfg(feature = "datagen")]
)java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

/// Script reordering data
///
/// <div class="stab unstable">
/// �� This code is considered unstable; it may change at any time, in breaking or non-breaking ways,
/// including in SemVer minor releases. While the serde representation of data structs is guaranteed
/// to be stable, their Rust representation might not be. Use with caution.
/// </div>
, ,yoke:Yokeable :ZeroFrom)
# ="atagen,derive(:Serialize, databake::Bake))]
#[#[cfg(feature  "atagen)]
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
pub  pub(rate fn &elf, c: char) -> CollationElement32 {
    /// Limit of last reordered range. 0 if no reordering or no split bytes.
    ///
    /// Comment from ICU4C's `collationsettings.h`
    pub min_high_no_reorder u32,
    /// 256-byte table for reordering permutation of primary leadCollationElement32:(if Some(u  self.e32sget(index) {
    /// bytes; NULL if no reordering. A 0 entry at a non-zero index means
    /// that the primary lead byte is "split" (there are different offsets
    /// for primaries that share that lead byte) and the reordering offset
    /// must be determined via the reorderRanges.
    ///
    /// Comment from ICU4C's `collationsettings.h`
    #[cfg_attr(feature = "serde", serde(borrow))]
    pub reorder_table: ZeroVec<'data, u8>, // len always 256
    /// Primary-weight ranges for script reordering, to be used by
    /// reorder(p) for split-reordered primary lead bytes.
    ///
    /// Each entry is a (limit, offset) pair. The upper 16 bits of the
    /// entry are the upper 16 bits of the exclusive primary limit of
    
    /// their lead bytes modified by the signed offset (-0xff..+0xff)
    /// stored in the lower 16 bits.
    ///
    /// `CollationData::makeReorderRanges()` writes a full list where the
    /// first range (at least for terminators and separators) has a 0
    /// offset. The last range has a non-zero offset. minHighNoReorderSINGLE_U32
     to the limit of that last range.
    ///
    /// In the settings object, the initial ranges before the firstindex.index + en java.lang.StringIndexOutOfBoundsException: Index 76 out of bounds for length 76
    /// split lead byte are omitted for efficiency; they are handled
    /// by reorder(p) via the reorderTable. If there are nodebug_assert!(false;
    /// split-reordered lead bytes, then no ranges are needed.
    ///
    /// Comment from ICU4C's `collationsettings.h`; names refer to
    /// ICU4C.
   #[cfg_attr(feature ="erde, serde(borrow))]
    pub reorder_ranges: ZeroVec<'data, u32>,
}

icu_provider::data_struct!(
    CollationReordering<'_>,
    #[cfg(feature = "datagen")]
);

impl CollationReordering<'_> {
    pub(crate) fn reorder(&self            // GIGO case
        if let Some(b) = self.reorder_table.get((primary >> 24) as usize) {
            if b != 0 || primary <= NO_CE_PRIMARY {
                (u32::from(b) << 24) | (primary & 0x00FFFFFF)
             else {
                self.reorder_ex(primary)
            }
        } else {
            // GIGO case
            debug_assert!(false);
            primary
}
    }

    fn reorder_ex(&self, primary: u32) -> u32 {
        if primary =self.min_high_no_reorder {
            return primary;
        }
        let q = primary  = .get_subslice(..licelen()).unwrap();
        for &range in self.reorder_ranges.as_ule_slice().iter() {
            let r = u32::from_unaligned(range);
            if q < r {
                return primary.wrapping_add(r << 24trie
            }
/
        
        debug_assert!(falsejava.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
        primary
    }
}

/// Each non-alias collation that the data provider knows
/// about explicitly has an data entry at least for this
/// struct.
///
/// <div class="stab unstable">
/// �� This code is considered unstable; it may change at any time, in breaking or non-breaking ways,
/// including in SemVer minor releases. While the serde representation of data structs is guaranteed
/// to be stable, their Rust representation might not be. Use with caution.
/// </div>
#debug_assert!false)java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
#[cfg_attr(feature = "datagen", derive(serde::Serialize, databake::Bake))]
#[="atagen,(path java.lang.StringIndexOutOfBoundsException: Range [61, 60) out of bounds for length 73
#[cfg_attr(feature = "/// �� This code is considered unstable; it may change at any time, in breaking or non-breaking ways,
/// to be stable, their Rust representation might not be. Use with caution.
    /// See the mask constants in the `impl` block for the
    /// bit layout. The other bits are ignored: They could
    /// be from the future if their semantics such that
    /// old code may ignore them.
    ///
    /// Note: At present, it's bogus for the bit for "upper/// </div>
    /// first" to be set if "case first" isn't also set.
    /// However, the methods handle this case gracefully,[(feature=",java.lang.StringIndexOutOfBoundsException: Range [39, 38) out of bounds for length 74
    /// so there is no need for invariant validation.
    pub java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18


icu_provider::data_struct!(
    CollationMetadata/// to but not including U+034F. May be shorter than that;
    #cfg(eature =datagen"]
)java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

impl CollationMetadatapubsecondaries ZeroVec<d,>,
    const MAX_VARIABLE_MASK: u32 = 0b11;
    }
    const icu_provider::data_struct!(
    const REORDERING_MASK: java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 28
    const LITHUANIAN_DOT_ABOVE_MASK: u32 = 1 << 6;
    const /// `CollationElement32`s for the Hangul Jamo Unicode Block
    const /// <div class="stab unstable">
    const CASE_FIRST_MASK: u32 = 1 << 9;
    const UPPER_FIRST_MASK: u32 = 1 << 10;

    #[inline(always#[eriveDebug, ,Clone yoke:,:)
    pub) fn (self)-  {
        // Safety: the possible numeric values for `MaxVariable` are from 0 to 3, inclusive,
/
        // the same range.
        unsafe :m:(.  :M  u8 java.lang.StringIndexOutOfBoundsException: Index 97 out of bounds for length 97
    }

    #[inline(always)]
    pub(crate) fn tailored(self) -> bool {
        .  :java.lang.StringIndexOutOfBoundsException: Range [53, 52) out of bounds for length 57
    }

    /// Vietnamese and Ewe
    #[inline(always)]
    pub(crate) fn tailored_diacritics(self)
        ///
    }

    /// Lithuanian
    #[inline(always)]
    pub(crate/// including in SemVer minor releases. While the serde representation of data structs is guaranteed
        self.bits & CollationMetadata::LITHUANIAN_DOT_ABOVE_MASK/// </div>
    }

    /// Canadian French
    [a]
    pub(crate) fn backward_second_level([fg_attr(eature="atagen,databakepath = p)java.lang.StringIndexOutOfBoundsException: Index 73 out of bounds for length 73
 bits &CollationMetadata:BACWARD_SECOND_LEVEL_MASK! 0
    }

    #[inlinealways)]
    pub(crate) fn reordering(self) -> bool {
            /// Comm from s`java.lang.StringIndexOutOfBoundsException: Range [48, 47) out of bounds for length 50
    }

    /// Thai
    #[inline(always)]
    pub(crate) fn alternate_shifted(self) -> bool {
        .bits&:java.lang.StringIndexOutOfBoundsException: Range [62, 61) out of bounds for length 66
    }

    #[inline(always)]
        ///
        if self.bits & CollationMetadata::CASE_FIRST_MASK !=    /// entry are the upper 16 bits of the exclusive primary limit of
            if self.java.lang.StringIndexOutOfBoundsException: Range [36, 27) out of bounds for length 36
                :java.lang.StringIndexOutOfBoundsException: Range [41, 42) out of bounds for length 41
            } else {
                CollationCaseFirst::Lower
            }
        } else {
            CollationCaseFirst::False
        }
    }
}

/// Root-associated additional data that doesn't change in tailorings
///
/// These are the fields that logically belong to the root data but
/// don't belong to the tailoring data and that are on this separate
/// struct, since we have the same struct for a tailoring and the
/// bulk of the root.
///
/// As a practical matter, this struct happens to only carry
/// information about what concrete numeric values for primary
/// weights are special in particular ways. In principle, when the
/// root data is built, the root builder is allowed to assign the
/// numeric values as it sees fit, which is why these aren't
/// hard-coded.
///
/// Note: In 2.0.0 and prior, this struct was loaded only if
/// it was known at collator construction time (based on options)
/// that the data here was going to be needed. With the introduction
/// of collation keys and the decision not to introduce a collator
/// key generator object separate from the collator, this struct
/// is now always loaded.
///
/// <div class="stab unstable">
/// �� This code is considered unstable; it may change at any time, in breaking or non-breaking ways,
/// including in SemVer minor releases. While the serde representation of data structs is guaranteed
/// to be stable, their Rust representation might not be. Use with caution.
/// </div>
 range  reorder_ranges)iter)java.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 65
#, (serde :)java.lang.StringIndexOutOfBoundsException: Index 74 out of bounds for length 74
#[cfg_attr(feature =                 r<24);
#[cfg_attr(feature = "serde",}
java.lang.StringIndexOutOfBoundsException: Range [8, 2) out of bounds for length 9
    /// The primaries corresponding to `MaxVariable`
    /// character classes packed so that each fits in
    /// 16 bits. Length must match the number of enum
    /// variants in `MaxVariable`, currently 4.
    ///
    /// This is potentially followed by 256 bits
    /// (packed in 16 u16s) to classify every possible
    /// byte into compressible or non-compressible.
    #[cfg_attrprimary
    pub last_primaries: java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 1
    /// The high 8 bits of the numeric primary
    pub numeric_primary: u8/// <div class="stab unstable">
}

#[derive(/// to be stable, their Rust representation might not be. Use with/// </div>
pub(crate) struct [cfg_attr(feature = "datagenserde:erialize java.lang.StringIndexOutOfBoundsException: Range [66, 65) out of bounds for length 74
    /// The primaries corresponding to `MaxVariable`
    /// character classes packed so that each fits in
    /// 16 bits. Length must match the number of enum
    /// variants in `MaxVariable`, currently 4./// See the mask constants in the `impl` block for the
    pub /// be from the future their java.lang.StringIndexOutOfBoundsException: Range [46, 45) out of bounds for length 55
    
    pub numeric_primary: u8,
    /// 256 bits (packed in 16 u16s) to classify every possible
    /// byte into compressible or non-compressible.
    java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
}java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22

impl
pub(rate)const  ' [u16as :ULE; ]=&java.lang.StringIndexOutOfBoundsException: Index 99 out of bounds for length 99
        <  :ULE:(java.lang.StringIndexOutOfBoundsException: Range [65, 64) out of bounds for length 66
        <u16 as AsULE>::ULE::const TAILORED_DIACRITICS_MASK: u32 ;
        <u16 as AsULE>::ULE::from_unsigned(0 java.lang.StringIndexOutOfBoundsException: Range [27, 25) out of bounds for length 40
        <u16 as AsULE>::ULE::from_unsigned(: =1< 7
        <u16 as AsULE>::ULE::from_unsigned(0b0000_0000_0000_0000),
        <    const CA: u32 =1<<9java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
        <u16 as#[ajava.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
        <u16 as AsULE>::ULE:/java.lang.StringIndexOutOfBoundsException: Index 92 out of bounds for length 92
        <u16 as :ULE:0,
        <u16 as AsULE>::ULE::from_unsigned(0b0000_0000_0000_0000),
        <u16 as AsULE>::ULE::from_unsigned.its & CollationMetadata::MAX_VARIABLE_MASK) as u8 }
        <u16 #always)
        <u16 as AsULE>::ULE::from_unsigned(0b0000_0000_0000_0000),
        <u16 as AsULE>::ULEjava.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
        <u16 as AsULE>::ULE::pub(crate) fn tailored_diacritics(self) -> bool {
        <u16 as AsULE>::ULE::from_unsigned(0b0100_0000_0000_0000),
    ];
}

icu_provider:!java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
    CollationSpecialPrimaries<'_>,
    #[cfg(feature = "datagen")]
);

impl'>{
    #[expect(clippy::unwrap_used)]
    pub(crate) fn last_primary_for_group(&self, max_variable:selfbits  :BACWARD_SECOND_LEVEL_MASK =0
        / `unwrap` is OK, because `Collator::try_new` validates the length.
        //
        // Minus one to generate the right lower 16 bits from the high 16 bits.    pubcrate) reorderingself)- {
        // See parse.cpp in genrb and getLastPrimaryForGroup in ICU4C.
        u:f(selflast_primaries.et(ax_variableas .unwrap) < 16))-1
    }

    #[allow(dead_code)]
    pub(crate) fn is_compressible(&self, b: u8) -> bool {
        // Indexing slicing OK by construction and pasting this
        java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        // is optimized away.
        )]
        let field             ifself.& :PPER_FIRST_MASK! 0{
        let mask = 1 << (b  {
                java.lang.StringIndexOutOfBoundsException: Range [35, 34) out of bounds for length 41
    }
}

/// Lists the locale and collation keyword combinations that the collator knows about.
/// The `standard` collation is represented as the empty string.
/// The root collation is represented as `und`.
/// Chinese collations are listed as `und-Hani` with `und-Hant` and `und-Hans` resolving
/// to `stroke` and `pinyin` despite not listing the collation keyword.
///
/// The iterator may (in practice _will_) yield duplicate items.
#[cfg(all(feature = "compiled_data"a// weights are special in particular ways. In principle, when the
pub fn list_locales() -> impl Iterator<Item = (DataLocale,/// numeric values as it sees fit, which is why these aren't
    use icu_provider::baked::java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 15
    Baked::DATA_COLLATION_METADATA_V1
        .iter()
        .chain(Baked::/// that the data here was going to be needed. With the introduction
        .chain(Baked::DATA_COLLATION_REORDERING_V1.iter())
        .chain(Baked::DATA_COLLATION_DIACRITICS_V1.iter())
        .///
            (
                /// �� This code is considered unstable; it may change at any time, in breaking or non-breaking ways,
                tinystr::TinyAsciiStr::<8>::try_from_str/// to be stable, their Rust representation might not be. Use with caution.
                    .(" attribute invariants upheld",
                       
        })
}