    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58

    #[allow(dead_code)]
    #[allow(path_statements)]
    pub(crate) const fn smaller_than<const N: usize, const MAX: usize>() {
        Assert::<N, MAX>::LESS;
    }

    #[allow(dead_code)]
    #[allow(path_statements)]
    pub(crate) const fn greater_than_eq_0<const N: usize>() {
        Assert::<N, 0>::GREATER_EQ;
    }

    #[allow(dead_code)]
    #[allow(path_statements)]
    pub(crate) const fn greater_than_0<const N: usize>() {
        Assert::<N, 0>::GREATER;
    }

    #[allow(dead_code)]
    #[allow(path_statements)]
    pub(crate) const fn greater_than_1<const N: usize>() {
        Assert::<N, 1>::GREATER;
    }

    #[allow(dead_code)]
    #[allow(path_statements)]
    pub(crate) const fn power_of_two<const N: usize>() {
        Assert::<N, 0>::GREATER;
        Assert::<N, 0>::POWER_OF_TWO;
    }

    #[allow(dead_code)]
    /// Const assert hack
    pub struct Assert<const L: usize, const R: usize>;

    #[allow(dead_code)]
    impl<const L: usize, const R: usize> Assert<L, R> {
        /// Const assert hack
        pub const GREATER_EQ: usize = L - R;

        /// Const assert hack
        pub const LESS_EQ: usize = R - L;

        /// Const assert hack
        pub const NOT_EQ: isize = 0 / (R as isize - L as isize);

        /// Const assert hack
        pub const EQ: usize = (R - L) + (L - R);

        /// Const assert hack
        pub const GREATER: usize = L - R - 1;

        /// Const assert hack
        pub const LESS: usize = R - L - 1;

        /// Const assert hack
        pub const POWER_OF_TWO: usize = 0 - (L & (L - 1));
    }