pub mod Global_ {
    use super::*;
    pub mod SR {
        use super::*;
        use crate::Native_::OnceInit;
        use crate::String_::string;
        pub fn arrayWasEmpty() -> string {
            static arrayWasEmpty: OnceInit<string> = OnceInit::new();
            arrayWasEmpty
                .get_or_init(|| string("The input array was empty."))
                .clone()
        }
        pub fn arrayIndexOutOfBounds() -> string {
            static arrayIndexOutOfBounds: OnceInit<string> = OnceInit::new();
            arrayIndexOutOfBounds
                .get_or_init(|| string("The index was outside the range of elements in the array."))
                .clone()
        }
        pub fn arraysHadDifferentLengths() -> string {
            static arraysHadDifferentLengths: OnceInit<string> = OnceInit::new();
            arraysHadDifferentLengths
                .get_or_init(|| string("The arrays have different lengths."))
                .clone()
        }
        pub fn enumerationAlreadyFinished() -> string {
            static enumerationAlreadyFinished: OnceInit<string> = OnceInit::new();
            enumerationAlreadyFinished
                .get_or_init(|| string("Enumeration already finished."))
                .clone()
        }
        pub fn enumerationNotStarted() -> string {
            static enumerationNotStarted: OnceInit<string> = OnceInit::new();
            enumerationNotStarted
                .get_or_init(|| string("Enumeration has not started. Call MoveNext."))
                .clone()
        }
        pub fn indexOutOfBounds() -> string {
            static indexOutOfBounds: OnceInit<string> = OnceInit::new();
            indexOutOfBounds
                .get_or_init(|| string("The index was outside the range of elements in the list."))
                .clone()
        }
        pub fn inputListWasEmpty() -> string {
            static inputListWasEmpty: OnceInit<string> = OnceInit::new();
            inputListWasEmpty
                .get_or_init(|| string("The input list was empty."))
                .clone()
        }
        pub fn inputMustBeNonNegative() -> string {
            static inputMustBeNonNegative: OnceInit<string> = OnceInit::new();
            inputMustBeNonNegative
                .get_or_init(|| string("The input must be non-negative."))
                .clone()
        }
        pub fn inputMustBePositive() -> string {
            static inputMustBePositive: OnceInit<string> = OnceInit::new();
            inputMustBePositive
                .get_or_init(|| string("The input must be positive."))
                .clone()
        }
        pub fn inputSequenceEmpty() -> string {
            static inputSequenceEmpty: OnceInit<string> = OnceInit::new();
            inputSequenceEmpty
                .get_or_init(|| string("The input sequence was empty."))
                .clone()
        }
        pub fn inputSequenceTooLong() -> string {
            static inputSequenceTooLong: OnceInit<string> = OnceInit::new();
            inputSequenceTooLong
                .get_or_init(|| string("The input sequence contains more than one element."))
                .clone()
        }
        pub fn keyNotFound() -> string {
            static keyNotFound: OnceInit<string> = OnceInit::new();
            keyNotFound
                .get_or_init(|| string("The item, key, or index was not found in the collection."))
                .clone()
        }
        pub fn keyNotFoundAlt() -> string {
            static keyNotFoundAlt: OnceInit<string> = OnceInit::new();
            keyNotFoundAlt
                .get_or_init(|| {
                    string("An index satisfying the predicate was not found in the collection.")
                })
                .clone()
        }
        pub fn listsHadDifferentLengths() -> string {
            static listsHadDifferentLengths: OnceInit<string> = OnceInit::new();
            listsHadDifferentLengths
                .get_or_init(|| string("The lists had different lengths."))
                .clone()
        }
        pub fn mapCannotBeMutated() -> string {
            static mapCannotBeMutated: OnceInit<string> = OnceInit::new();
            mapCannotBeMutated
                .get_or_init(|| string("Map values cannot be mutated."))
                .clone()
        }
        pub fn notAPermutation() -> string {
            static notAPermutation: OnceInit<string> = OnceInit::new();
            notAPermutation
                .get_or_init(|| string("The function did not compute a permutation."))
                .clone()
        }
        pub fn notEnoughElements() -> string {
            static notEnoughElements: OnceInit<string> = OnceInit::new();
            notEnoughElements
                .get_or_init(|| {
                    string("The input sequence has an insufficient number of elements.")
                })
                .clone()
        }
        pub fn outOfRange() -> string {
            static outOfRange: OnceInit<string> = OnceInit::new();
            outOfRange
                .get_or_init(|| string("The index is outside the legal range."))
                .clone()
        }
        pub fn resetNotSupported() -> string {
            static resetNotSupported: OnceInit<string> = OnceInit::new();
            resetNotSupported
                .get_or_init(|| string("Reset is not supported on this enumerator."))
                .clone()
        }
        pub fn setContainsNoElements() -> string {
            static setContainsNoElements: OnceInit<string> = OnceInit::new();
            setContainsNoElements
                .get_or_init(|| string("Set contains no elements."))
                .clone()
        }
        pub fn Arg_ApplicationException() -> string {
            static Arg_ApplicationException: OnceInit<string> = OnceInit::new();
            Arg_ApplicationException
                .get_or_init(|| string("Error in the application."))
                .clone()
        }
        pub fn Arg_ArgumentException() -> string {
            static Arg_ArgumentException: OnceInit<string> = OnceInit::new();
            Arg_ArgumentException
                .get_or_init(|| string("Value does not fall within the expected range."))
                .clone()
        }
        pub fn Arg_ArgumentOutOfRangeException() -> string {
            static Arg_ArgumentOutOfRangeException: OnceInit<string> = OnceInit::new();
            Arg_ArgumentOutOfRangeException
                .get_or_init(|| string("Specified argument was out of the range of valid values."))
                .clone()
        }
        pub fn ArgumentNull_Generic() -> string {
            static ArgumentNull_Generic: OnceInit<string> = OnceInit::new();
            ArgumentNull_Generic
                .get_or_init(|| string("Value cannot be null."))
                .clone()
        }
        pub fn Arg_ParamName_Name() -> string {
            static Arg_ParamName_Name: OnceInit<string> = OnceInit::new();
            Arg_ParamName_Name
                .get_or_init(|| string(" (Parameter \'"))
                .clone()
        }
        pub fn Arg_ArithmeticException() -> string {
            static Arg_ArithmeticException: OnceInit<string> = OnceInit::new();
            Arg_ArithmeticException
                .get_or_init(|| string("Overflow or underflow in the arithmetic operation."))
                .clone()
        }
        pub fn Arg_DivideByZero() -> string {
            static Arg_DivideByZero: OnceInit<string> = OnceInit::new();
            Arg_DivideByZero
                .get_or_init(|| string("Attempted to divide by zero."))
                .clone()
        }
        pub fn Arg_FormatException() -> string {
            static Arg_FormatException: OnceInit<string> = OnceInit::new();
            Arg_FormatException
                .get_or_init(|| string("One of the identified items was in an invalid format."))
                .clone()
        }
        pub fn Arg_IndexOutOfRangeException() -> string {
            static Arg_IndexOutOfRangeException: OnceInit<string> = OnceInit::new();
            Arg_IndexOutOfRangeException
                .get_or_init(|| string("Index was outside the bounds of the array."))
                .clone()
        }
        pub fn Arg_InvalidOperationException() -> string {
            static Arg_InvalidOperationException: OnceInit<string> = OnceInit::new();
            Arg_InvalidOperationException
                .get_or_init(|| {
                    string("Operation is not valid due to the current state of the object.")
                })
                .clone()
        }
        pub fn Arg_KeyNotFound() -> string {
            static Arg_KeyNotFound: OnceInit<string> = OnceInit::new();
            Arg_KeyNotFound
                .get_or_init(|| string("The given key was not present in the dictionary."))
                .clone()
        }
        pub fn Arg_NotFiniteNumberException() -> string {
            static Arg_NotFiniteNumberException: OnceInit<string> = OnceInit::new();
            Arg_NotFiniteNumberException
                .get_or_init(|| string("Number encountered was not a finite quantity."))
                .clone()
        }
        pub fn Arg_NotImplementedException() -> string {
            static Arg_NotImplementedException: OnceInit<string> = OnceInit::new();
            Arg_NotImplementedException
                .get_or_init(|| string("The method or operation is not implemented."))
                .clone()
        }
        pub fn Arg_NotSupportedException() -> string {
            static Arg_NotSupportedException: OnceInit<string> = OnceInit::new();
            Arg_NotSupportedException
                .get_or_init(|| string("Specified method is not supported."))
                .clone()
        }
        pub fn Arg_NullReferenceException() -> string {
            static Arg_NullReferenceException: OnceInit<string> = OnceInit::new();
            Arg_NullReferenceException
                .get_or_init(|| string("Object reference not set to an instance of an object."))
                .clone()
        }
        pub fn Arg_OutOfMemoryException() -> string {
            static Arg_OutOfMemoryException: OnceInit<string> = OnceInit::new();
            Arg_OutOfMemoryException
                .get_or_init(|| {
                    string("Insufficient memory to continue the execution of the program.")
                })
                .clone()
        }
        pub fn Arg_OverflowException() -> string {
            static Arg_OverflowException: OnceInit<string> = OnceInit::new();
            Arg_OverflowException
                .get_or_init(|| string("Arithmetic operation resulted in an overflow."))
                .clone()
        }
        pub fn Arg_RankException() -> string {
            static Arg_RankException: OnceInit<string> = OnceInit::new();
            Arg_RankException
                .get_or_init(|| {
                    string(
                        "Attempted to operate on an array with the incorrect number of dimensions.",
                    )
                })
                .clone()
        }
        pub fn Arg_StackOverflowException() -> string {
            static Arg_StackOverflowException: OnceInit<string> = OnceInit::new();
            Arg_StackOverflowException
                .get_or_init(|| string("Operation caused a stack overflow."))
                .clone()
        }
        pub fn Arg_SystemException() -> string {
            static Arg_SystemException: OnceInit<string> = OnceInit::new();
            Arg_SystemException
                .get_or_init(|| string("System error."))
                .clone()
        }
        pub fn Arg_TimeoutException() -> string {
            static Arg_TimeoutException: OnceInit<string> = OnceInit::new();
            Arg_TimeoutException
                .get_or_init(|| string("The operation has timed out."))
                .clone()
        }
    }
}
