pub mod System {
    use super::*;
    use crate::Exception_::try_catch;
    use crate::Global_::SR::Arg_ApplicationException;
    use crate::Global_::SR::Arg_ArgumentException;
    use crate::Global_::SR::Arg_ArgumentOutOfRangeException;
    use crate::Global_::SR::Arg_ArithmeticException;
    use crate::Global_::SR::Arg_DivideByZero;
    use crate::Global_::SR::Arg_FormatException;
    use crate::Global_::SR::Arg_IndexOutOfRangeException;
    use crate::Global_::SR::Arg_InvalidOperationException;
    use crate::Global_::SR::Arg_NotFiniteNumberException;
    use crate::Global_::SR::Arg_NotImplementedException;
    use crate::Global_::SR::Arg_NotSupportedException;
    use crate::Global_::SR::Arg_NullReferenceException;
    use crate::Global_::SR::Arg_OutOfMemoryException;
    use crate::Global_::SR::Arg_OverflowException;
    use crate::Global_::SR::Arg_ParamName_Name;
    use crate::Global_::SR::Arg_RankException;
    use crate::Global_::SR::Arg_StackOverflowException;
    use crate::Global_::SR::Arg_SystemException;
    use crate::Global_::SR::Arg_TimeoutException;
    use crate::Global_::SR::ArgumentNull_Generic;
    use crate::Native_::Any;
    use crate::Native_::Func0;
    use crate::Native_::LrcPtr;
    use crate::Native_::MutCell;
    use crate::String_::append;
    use crate::String_::isNullOrEmpty;
    use crate::String_::string;
    use crate::System::Collections::IEqualityComparer;
    use crate::System::Collections::IStructuralEquatable;
    use crate::System::Exception as Exception_1;
    #[derive(Clone, Debug)]
    pub struct Array {}
    impl Array {
        pub fn _ctor() -> LrcPtr<System::Array> {
            ();
            ();
            LrcPtr::new(System::Array {})
        }
    }
    impl core::fmt::Display for Array {
        fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
            write!(f, "{}", core::any::type_name::<Self>())
        }
    }
    impl core::cmp::PartialEq for Array {
        fn eq(&self, other: &Self) -> bool {
            core::ptr::eq(self, other)
        }
    }
    impl core::cmp::Eq for Array {}
    impl core::hash::Hash for Array {
        fn hash<H: core::hash::Hasher>(&self, state: &mut H) -> () {
            core::hash::Hash::hash(&(self as *const Self as usize), state)
        }
    }
    #[derive(Clone, Debug)]
    pub struct Attribute {}
    impl Attribute {
        pub fn _ctor() -> LrcPtr<System::Attribute> {
            ();
            ();
            LrcPtr::new(System::Attribute {})
        }
    }
    impl core::fmt::Display for Attribute {
        fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
            write!(f, "{}", core::any::type_name::<Self>())
        }
    }
    impl core::cmp::PartialEq for Attribute {
        fn eq(&self, other: &Self) -> bool {
            core::ptr::eq(self, other)
        }
    }
    impl core::cmp::Eq for Attribute {}
    impl core::hash::Hash for Attribute {
        fn hash<H: core::hash::Hasher>(&self, state: &mut H) -> () {
            core::hash::Hash::hash(&(self as *const Self as usize), state)
        }
    }
    #[derive(Clone, Debug)]
    pub struct Enum {}
    impl Enum {
        pub fn _ctor() -> LrcPtr<System::Enum> {
            ();
            ();
            LrcPtr::new(System::Enum {})
        }
    }
    impl core::fmt::Display for Enum {
        fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
            write!(f, "{}", core::any::type_name::<Self>())
        }
    }
    impl core::cmp::PartialEq for Enum {
        fn eq(&self, other: &Self) -> bool {
            core::ptr::eq(self, other)
        }
    }
    impl core::cmp::Eq for Enum {}
    impl core::hash::Hash for Enum {
        fn hash<H: core::hash::Hasher>(&self, state: &mut H) -> () {
            core::hash::Hash::hash(&(self as *const Self as usize), state)
        }
    }
    #[derive(Clone, Debug, Hash, PartialEq)]
    pub struct Exception {
        message: string,
    }
    impl Exception {
        pub fn _ctor__Z721C83C5(message: string) -> LrcPtr<System::Exception> {
            let message_1: string;
            ();
            message_1 = message;
            ();
            LrcPtr::new(System::Exception { message: message_1 })
        }
        pub fn _ctor() -> LrcPtr<System::Exception> {
            System::Exception::_ctor__Z721C83C5(string(""))
        }
        pub fn get_Message(&self) -> string {
            let __self__ = self;
            __self__.message.clone()
        }
        pub fn get_StackTrace(&self) -> string {
            let __self__ = self;
            string("")
        }
    }
    impl core::fmt::Display for Exception {
        fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
            write!(f, "{}", core::any::type_name::<Self>())
        }
    }
    impl IStructuralEquatable for Exception {
        fn Equals(&self, y: LrcPtr<dyn Any>, comparer: LrcPtr<dyn IEqualityComparer>) -> bool {
            let __self__ = self;
            false
        }
        fn GetHashCode(&self, comparer: LrcPtr<dyn IEqualityComparer>) -> i32 {
            let __self__ = self;
            0_i32
        }
    }
    #[derive(Clone, Debug, Hash, PartialEq)]
    pub struct SystemException {
        __base__: LrcPtr<System::Exception>,
    }
    impl core::ops::Deref for SystemException {
        type Target = LrcPtr<System::Exception>;
        #[inline]
        fn deref(&self) -> &Self::Target {
            &self.__base__
        }
    }
    impl SystemException {
        pub fn _ctor__Z721C83C5(message: string) -> LrcPtr<System::SystemException> {
            let __base__;
            __base__ = System::Exception::_ctor__Z721C83C5(message);
            ();
            LrcPtr::new(System::SystemException { __base__: __base__ })
        }
        pub fn _ctor() -> LrcPtr<System::SystemException> {
            System::SystemException::_ctor__Z721C83C5(Arg_SystemException())
        }
    }
    impl core::fmt::Display for SystemException {
        fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
            write!(f, "{}", core::any::type_name::<Self>())
        }
    }
    #[derive(Clone, Debug, Hash, PartialEq)]
    pub struct ApplicationException {
        __base__: LrcPtr<System::Exception>,
    }
    impl core::ops::Deref for ApplicationException {
        type Target = LrcPtr<System::Exception>;
        #[inline]
        fn deref(&self) -> &Self::Target {
            &self.__base__
        }
    }
    impl ApplicationException {
        pub fn _ctor__Z721C83C5(message: string) -> LrcPtr<System::ApplicationException> {
            let __base__;
            __base__ = System::Exception::_ctor__Z721C83C5(message);
            ();
            LrcPtr::new(System::ApplicationException { __base__: __base__ })
        }
        pub fn _ctor() -> LrcPtr<System::ApplicationException> {
            System::ApplicationException::_ctor__Z721C83C5(Arg_ApplicationException())
        }
    }
    impl core::fmt::Display for ApplicationException {
        fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
            write!(f, "{}", core::any::type_name::<Self>())
        }
    }
    #[derive(Clone, Debug, Hash, PartialEq)]
    pub struct ArithmeticException {
        __base__: LrcPtr<System::Exception>,
    }
    impl core::ops::Deref for ArithmeticException {
        type Target = LrcPtr<System::Exception>;
        #[inline]
        fn deref(&self) -> &Self::Target {
            &self.__base__
        }
    }
    impl ArithmeticException {
        pub fn _ctor__Z721C83C5(message: string) -> LrcPtr<System::ArithmeticException> {
            let __base__;
            __base__ = System::Exception::_ctor__Z721C83C5(message);
            ();
            LrcPtr::new(System::ArithmeticException { __base__: __base__ })
        }
        pub fn _ctor() -> LrcPtr<System::ArithmeticException> {
            System::ArithmeticException::_ctor__Z721C83C5(Arg_ArithmeticException())
        }
    }
    impl core::fmt::Display for ArithmeticException {
        fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
            write!(f, "{}", core::any::type_name::<Self>())
        }
    }
    #[derive(Clone, Debug, Hash, PartialEq)]
    pub struct DivideByZeroException {
        __base__: LrcPtr<System::Exception>,
    }
    impl core::ops::Deref for DivideByZeroException {
        type Target = LrcPtr<System::Exception>;
        #[inline]
        fn deref(&self) -> &Self::Target {
            &self.__base__
        }
    }
    impl DivideByZeroException {
        pub fn _ctor__Z721C83C5(message: string) -> LrcPtr<System::DivideByZeroException> {
            let __base__;
            __base__ = System::Exception::_ctor__Z721C83C5(message);
            ();
            LrcPtr::new(System::DivideByZeroException { __base__: __base__ })
        }
        pub fn _ctor() -> LrcPtr<System::DivideByZeroException> {
            System::DivideByZeroException::_ctor__Z721C83C5(Arg_DivideByZero())
        }
    }
    impl core::fmt::Display for DivideByZeroException {
        fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
            write!(f, "{}", core::any::type_name::<Self>())
        }
    }
    #[derive(Clone, Debug, Hash, PartialEq)]
    pub struct FormatException {
        __base__: LrcPtr<System::Exception>,
    }
    impl core::ops::Deref for FormatException {
        type Target = LrcPtr<System::Exception>;
        #[inline]
        fn deref(&self) -> &Self::Target {
            &self.__base__
        }
    }
    impl FormatException {
        pub fn _ctor__Z721C83C5(message: string) -> LrcPtr<System::FormatException> {
            let __base__;
            __base__ = System::Exception::_ctor__Z721C83C5(message);
            ();
            LrcPtr::new(System::FormatException { __base__: __base__ })
        }
        pub fn _ctor() -> LrcPtr<System::FormatException> {
            System::FormatException::_ctor__Z721C83C5(Arg_FormatException())
        }
    }
    impl core::fmt::Display for FormatException {
        fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
            write!(f, "{}", core::any::type_name::<Self>())
        }
    }
    #[derive(Clone, Debug, Hash, PartialEq)]
    pub struct IndexOutOfRangeException {
        __base__: LrcPtr<System::Exception>,
    }
    impl core::ops::Deref for IndexOutOfRangeException {
        type Target = LrcPtr<System::Exception>;
        #[inline]
        fn deref(&self) -> &Self::Target {
            &self.__base__
        }
    }
    impl IndexOutOfRangeException {
        pub fn _ctor__Z721C83C5(message: string) -> LrcPtr<System::IndexOutOfRangeException> {
            let __base__;
            __base__ = System::Exception::_ctor__Z721C83C5(message);
            ();
            LrcPtr::new(System::IndexOutOfRangeException { __base__: __base__ })
        }
        pub fn _ctor() -> LrcPtr<System::IndexOutOfRangeException> {
            System::IndexOutOfRangeException::_ctor__Z721C83C5(Arg_IndexOutOfRangeException())
        }
    }
    impl core::fmt::Display for IndexOutOfRangeException {
        fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
            write!(f, "{}", core::any::type_name::<Self>())
        }
    }
    #[derive(Clone, Debug, Hash, PartialEq)]
    pub struct InvalidOperationException {
        __base__: LrcPtr<System::Exception>,
    }
    impl core::ops::Deref for InvalidOperationException {
        type Target = LrcPtr<System::Exception>;
        #[inline]
        fn deref(&self) -> &Self::Target {
            &self.__base__
        }
    }
    impl InvalidOperationException {
        pub fn _ctor__Z721C83C5(message: string) -> LrcPtr<System::InvalidOperationException> {
            let __base__;
            __base__ = System::Exception::_ctor__Z721C83C5(message);
            ();
            LrcPtr::new(System::InvalidOperationException { __base__: __base__ })
        }
        pub fn _ctor() -> LrcPtr<System::InvalidOperationException> {
            System::InvalidOperationException::_ctor__Z721C83C5(Arg_InvalidOperationException())
        }
    }
    impl core::fmt::Display for InvalidOperationException {
        fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
            write!(f, "{}", core::any::type_name::<Self>())
        }
    }
    #[derive(Clone, Debug, Hash, PartialEq)]
    pub struct NotFiniteNumberException {
        __base__: LrcPtr<System::Exception>,
    }
    impl core::ops::Deref for NotFiniteNumberException {
        type Target = LrcPtr<System::Exception>;
        #[inline]
        fn deref(&self) -> &Self::Target {
            &self.__base__
        }
    }
    impl NotFiniteNumberException {
        pub fn _ctor__Z721C83C5(message: string) -> LrcPtr<System::NotFiniteNumberException> {
            let __base__;
            __base__ = System::Exception::_ctor__Z721C83C5(message);
            ();
            LrcPtr::new(System::NotFiniteNumberException { __base__: __base__ })
        }
        pub fn _ctor() -> LrcPtr<System::NotFiniteNumberException> {
            System::NotFiniteNumberException::_ctor__Z721C83C5(Arg_NotFiniteNumberException())
        }
    }
    impl core::fmt::Display for NotFiniteNumberException {
        fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
            write!(f, "{}", core::any::type_name::<Self>())
        }
    }
    #[derive(Clone, Debug, Hash, PartialEq)]
    pub struct NotImplementedException {
        __base__: LrcPtr<System::Exception>,
    }
    impl core::ops::Deref for NotImplementedException {
        type Target = LrcPtr<System::Exception>;
        #[inline]
        fn deref(&self) -> &Self::Target {
            &self.__base__
        }
    }
    impl NotImplementedException {
        pub fn _ctor__Z721C83C5(message: string) -> LrcPtr<System::NotImplementedException> {
            let __base__;
            __base__ = System::Exception::_ctor__Z721C83C5(message);
            ();
            LrcPtr::new(System::NotImplementedException { __base__: __base__ })
        }
        pub fn _ctor() -> LrcPtr<System::NotImplementedException> {
            System::NotImplementedException::_ctor__Z721C83C5(Arg_NotImplementedException())
        }
    }
    impl core::fmt::Display for NotImplementedException {
        fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
            write!(f, "{}", core::any::type_name::<Self>())
        }
    }
    #[derive(Clone, Debug, Hash, PartialEq)]
    pub struct NotSupportedException {
        __base__: LrcPtr<System::Exception>,
    }
    impl core::ops::Deref for NotSupportedException {
        type Target = LrcPtr<System::Exception>;
        #[inline]
        fn deref(&self) -> &Self::Target {
            &self.__base__
        }
    }
    impl NotSupportedException {
        pub fn _ctor__Z721C83C5(message: string) -> LrcPtr<System::NotSupportedException> {
            let __base__;
            __base__ = System::Exception::_ctor__Z721C83C5(message);
            ();
            LrcPtr::new(System::NotSupportedException { __base__: __base__ })
        }
        pub fn _ctor() -> LrcPtr<System::NotSupportedException> {
            System::NotSupportedException::_ctor__Z721C83C5(Arg_NotSupportedException())
        }
    }
    impl core::fmt::Display for NotSupportedException {
        fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
            write!(f, "{}", core::any::type_name::<Self>())
        }
    }
    #[derive(Clone, Debug, Hash, PartialEq)]
    pub struct NullReferenceException {
        __base__: LrcPtr<System::Exception>,
    }
    impl core::ops::Deref for NullReferenceException {
        type Target = LrcPtr<System::Exception>;
        #[inline]
        fn deref(&self) -> &Self::Target {
            &self.__base__
        }
    }
    impl NullReferenceException {
        pub fn _ctor__Z721C83C5(message: string) -> LrcPtr<System::NullReferenceException> {
            let __base__;
            __base__ = System::Exception::_ctor__Z721C83C5(message);
            ();
            LrcPtr::new(System::NullReferenceException { __base__: __base__ })
        }
        pub fn _ctor() -> LrcPtr<System::NullReferenceException> {
            System::NullReferenceException::_ctor__Z721C83C5(Arg_NullReferenceException())
        }
    }
    impl core::fmt::Display for NullReferenceException {
        fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
            write!(f, "{}", core::any::type_name::<Self>())
        }
    }
    #[derive(Clone, Debug, Hash, PartialEq)]
    pub struct OutOfMemoryException {
        __base__: LrcPtr<System::Exception>,
    }
    impl core::ops::Deref for OutOfMemoryException {
        type Target = LrcPtr<System::Exception>;
        #[inline]
        fn deref(&self) -> &Self::Target {
            &self.__base__
        }
    }
    impl OutOfMemoryException {
        pub fn _ctor__Z721C83C5(message: string) -> LrcPtr<System::OutOfMemoryException> {
            let __base__;
            __base__ = System::Exception::_ctor__Z721C83C5(message);
            ();
            LrcPtr::new(System::OutOfMemoryException { __base__: __base__ })
        }
        pub fn _ctor() -> LrcPtr<System::OutOfMemoryException> {
            System::OutOfMemoryException::_ctor__Z721C83C5(Arg_OutOfMemoryException())
        }
    }
    impl core::fmt::Display for OutOfMemoryException {
        fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
            write!(f, "{}", core::any::type_name::<Self>())
        }
    }
    #[derive(Clone, Debug, Hash, PartialEq)]
    pub struct OverflowException {
        __base__: LrcPtr<System::Exception>,
    }
    impl core::ops::Deref for OverflowException {
        type Target = LrcPtr<System::Exception>;
        #[inline]
        fn deref(&self) -> &Self::Target {
            &self.__base__
        }
    }
    impl OverflowException {
        pub fn _ctor__Z721C83C5(message: string) -> LrcPtr<System::OverflowException> {
            let __base__;
            __base__ = System::Exception::_ctor__Z721C83C5(message);
            ();
            LrcPtr::new(System::OverflowException { __base__: __base__ })
        }
        pub fn _ctor() -> LrcPtr<System::OverflowException> {
            System::OverflowException::_ctor__Z721C83C5(Arg_OverflowException())
        }
    }
    impl core::fmt::Display for OverflowException {
        fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
            write!(f, "{}", core::any::type_name::<Self>())
        }
    }
    #[derive(Clone, Debug, Hash, PartialEq)]
    pub struct RankException {
        __base__: LrcPtr<System::Exception>,
    }
    impl core::ops::Deref for RankException {
        type Target = LrcPtr<System::Exception>;
        #[inline]
        fn deref(&self) -> &Self::Target {
            &self.__base__
        }
    }
    impl RankException {
        pub fn _ctor__Z721C83C5(message: string) -> LrcPtr<System::RankException> {
            let __base__;
            __base__ = System::Exception::_ctor__Z721C83C5(message);
            ();
            LrcPtr::new(System::RankException { __base__: __base__ })
        }
        pub fn _ctor() -> LrcPtr<System::RankException> {
            System::RankException::_ctor__Z721C83C5(Arg_RankException())
        }
    }
    impl core::fmt::Display for RankException {
        fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
            write!(f, "{}", core::any::type_name::<Self>())
        }
    }
    #[derive(Clone, Debug, Hash, PartialEq)]
    pub struct StackOverflowException {
        __base__: LrcPtr<System::Exception>,
    }
    impl core::ops::Deref for StackOverflowException {
        type Target = LrcPtr<System::Exception>;
        #[inline]
        fn deref(&self) -> &Self::Target {
            &self.__base__
        }
    }
    impl StackOverflowException {
        pub fn _ctor__Z721C83C5(message: string) -> LrcPtr<System::StackOverflowException> {
            let __base__;
            __base__ = System::Exception::_ctor__Z721C83C5(message);
            ();
            LrcPtr::new(System::StackOverflowException { __base__: __base__ })
        }
        pub fn _ctor() -> LrcPtr<System::StackOverflowException> {
            System::StackOverflowException::_ctor__Z721C83C5(Arg_StackOverflowException())
        }
    }
    impl core::fmt::Display for StackOverflowException {
        fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
            write!(f, "{}", core::any::type_name::<Self>())
        }
    }
    #[derive(Clone, Debug, Hash, PartialEq)]
    pub struct TimeoutException {
        __base__: LrcPtr<System::Exception>,
    }
    impl core::ops::Deref for TimeoutException {
        type Target = LrcPtr<System::Exception>;
        #[inline]
        fn deref(&self) -> &Self::Target {
            &self.__base__
        }
    }
    impl TimeoutException {
        pub fn _ctor__Z721C83C5(message: string) -> LrcPtr<System::TimeoutException> {
            let __base__;
            __base__ = System::Exception::_ctor__Z721C83C5(message);
            ();
            LrcPtr::new(System::TimeoutException { __base__: __base__ })
        }
        pub fn _ctor() -> LrcPtr<System::TimeoutException> {
            System::TimeoutException::_ctor__Z721C83C5(Arg_TimeoutException())
        }
    }
    impl core::fmt::Display for TimeoutException {
        fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
            write!(f, "{}", core::any::type_name::<Self>())
        }
    }
    #[derive(Clone, Debug, Hash, PartialEq)]
    pub struct ArgumentException {
        __base__: LrcPtr<System::Exception>,
        paramName: string,
        message_1: string,
    }
    impl core::ops::Deref for ArgumentException {
        type Target = LrcPtr<System::Exception>;
        #[inline]
        fn deref(&self) -> &Self::Target {
            &self.__base__
        }
    }
    impl ArgumentException {
        pub fn _ctor__Z384F8060(
            message: string,
            paramName: string,
        ) -> LrcPtr<System::ArgumentException> {
            let __base__;
            let paramName_1: string;
            let message_1: string;
            __base__ = System::Exception::_ctor__Z721C83C5(message.clone());
            message_1 = message;
            paramName_1 = paramName;
            ();
            LrcPtr::new(System::ArgumentException {
                __base__: __base__,
                paramName: paramName_1,
                message_1: message_1,
            })
        }
        pub fn _ctor() -> LrcPtr<System::ArgumentException> {
            System::ArgumentException::_ctor__Z384F8060(Arg_ArgumentException(), string(""))
        }
        pub fn _ctor__Z721C83C5(message: string) -> LrcPtr<System::ArgumentException> {
            System::ArgumentException::_ctor__Z384F8060(message, string(""))
        }
        pub fn get_Message(&self) -> string {
            let __self__ = self;
            if isNullOrEmpty(__self__.paramName.clone()) {
                __self__.message_1.clone()
            } else {
                append(
                    (append(
                        (append((__self__.message_1.clone()), (Arg_ParamName_Name()))),
                        (__self__.paramName.clone()),
                    )),
                    string("\')"),
                )
            }
        }
        pub fn get_ParamName(&self) -> string {
            let __self__ = self;
            __self__.paramName.clone()
        }
    }
    impl core::fmt::Display for ArgumentException {
        fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
            write!(f, "{}", core::any::type_name::<Self>())
        }
    }
    #[derive(Clone, Debug, Hash, PartialEq)]
    pub struct ArgumentNullException {
        __base__: LrcPtr<System::ArgumentException>,
    }
    impl core::ops::Deref for ArgumentNullException {
        type Target = LrcPtr<System::ArgumentException>;
        #[inline]
        fn deref(&self) -> &Self::Target {
            &self.__base__
        }
    }
    impl ArgumentNullException {
        pub fn _ctor__Z384F8060(
            paramName: string,
            message: string,
        ) -> LrcPtr<System::ArgumentNullException> {
            let __base__: LrcPtr<System::ArgumentException>;
            __base__ = System::ArgumentException::_ctor__Z384F8060(message, paramName);
            ();
            LrcPtr::new(System::ArgumentNullException { __base__: __base__ })
        }
        pub fn _ctor__Z721C83C5(paramName: string) -> LrcPtr<System::ArgumentNullException> {
            System::ArgumentNullException::_ctor__Z384F8060(paramName, ArgumentNull_Generic())
        }
        pub fn _ctor() -> LrcPtr<System::ArgumentNullException> {
            System::ArgumentNullException::_ctor__Z721C83C5(string(""))
        }
    }
    impl core::fmt::Display for ArgumentNullException {
        fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
            write!(f, "{}", core::any::type_name::<Self>())
        }
    }
    #[derive(Clone, Debug, Hash, PartialEq)]
    pub struct ArgumentOutOfRangeException {
        __base__: LrcPtr<System::ArgumentException>,
    }
    impl core::ops::Deref for ArgumentOutOfRangeException {
        type Target = LrcPtr<System::ArgumentException>;
        #[inline]
        fn deref(&self) -> &Self::Target {
            &self.__base__
        }
    }
    impl ArgumentOutOfRangeException {
        pub fn _ctor__Z384F8060(
            paramName: string,
            message: string,
        ) -> LrcPtr<System::ArgumentOutOfRangeException> {
            let __base__: LrcPtr<System::ArgumentException>;
            __base__ = System::ArgumentException::_ctor__Z384F8060(message, paramName);
            ();
            LrcPtr::new(System::ArgumentOutOfRangeException { __base__: __base__ })
        }
        pub fn _ctor__Z721C83C5(paramName: string) -> LrcPtr<System::ArgumentOutOfRangeException> {
            System::ArgumentOutOfRangeException::_ctor__Z384F8060(
                paramName,
                Arg_ArgumentOutOfRangeException(),
            )
        }
        pub fn _ctor() -> LrcPtr<System::ArgumentOutOfRangeException> {
            System::ArgumentOutOfRangeException::_ctor__Z721C83C5(string(""))
        }
    }
    impl core::fmt::Display for ArgumentOutOfRangeException {
        fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
            write!(f, "{}", core::any::type_name::<Self>())
        }
    }
    #[derive(Clone)]
    pub enum LazyState_1<T: Clone + 'static> {
        Initial(Func0<T>),
        Success(T),
        Failure(LrcPtr<Exception_1>),
    }
    impl<T: Clone + 'static> core::fmt::Debug for LazyState_1<T> {
        fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
            write!(f, "{}", core::any::type_name::<Self>())
        }
    }
    impl<T: Clone + 'static> core::fmt::Display for LazyState_1<T> {
        fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
            write!(f, "{}", core::any::type_name::<Self>())
        }
    }
    #[derive(Clone)]
    pub struct Lazy_1<T: Clone + 'static> {
        lazyState: MutCell<LrcPtr<System::LazyState_1<T>>>,
    }
    impl<T: Clone + 'static> Lazy_1<T> {
        pub fn _ctor__Z62F44226(
            state: LrcPtr<System::LazyState_1<T>>,
            isThreadSafe: bool,
        ) -> LrcPtr<System::Lazy_1<T>> {
            let lazyState: LrcPtr<System::LazyState_1<T>>;
            ();
            lazyState = state;
            ();
            LrcPtr::new(System::Lazy_1::<T> {
                lazyState: MutCell::new(lazyState),
            })
        }
        pub fn _ctor__2B595(f: Func0<T>) -> LrcPtr<System::Lazy_1<T>> {
            System::Lazy_1::<T>::_ctor__Z62F44226(
                LrcPtr::new(System::LazyState_1::Initial::<T>(Func0::new({
                    let f = f.clone();
                    move || f()
                }))),
                true,
            )
        }
        pub fn _ctor__Z1FE5A521(f: Func0<T>, isThreadSafe: bool) -> LrcPtr<System::Lazy_1<T>> {
            System::Lazy_1::<T>::_ctor__Z62F44226(
                LrcPtr::new(System::LazyState_1::Initial::<T>(Func0::new({
                    let f = f.clone();
                    move || f()
                }))),
                isThreadSafe,
            )
        }
        pub fn get_IsValueCreated(&self) -> bool {
            let __self__ = self;
            if let System::LazyState_1::Success(_) = __self__.lazyState.get().clone().as_ref() {
                true
            } else {
                false
            }
        }
        pub fn Force(&self) -> T {
            let __self__ = self;
            let matchValue: LrcPtr<System::LazyState_1<T>> = __self__.lazyState.get().clone();
            match matchValue.as_ref() {
                System::LazyState_1::Failure(matchValue_2_0) => {
                    panic!("{}", matchValue_2_0.get_Message(),)
                }
                System::LazyState_1::Initial(matchValue_0_0) => try_catch(
                    || {
                        let v_1: T = (matchValue_0_0)();
                        __self__
                            .lazyState
                            .set(LrcPtr::new(System::LazyState_1::Success::<T>(v_1.clone())));
                        v_1
                    },
                    |e_1: LrcPtr<Exception_1>| {
                        __self__
                            .lazyState
                            .set(LrcPtr::new(System::LazyState_1::Failure::<T>(e_1.clone())));
                        ();
                        panic!("{}", e_1.get_Message(),)
                    },
                ),
                System::LazyState_1::Success(matchValue_1_0) => matchValue_1_0.clone(),
            }
        }
        pub fn get_Value(&self) -> T {
            let __self__ = self;
            __self__.Force()
        }
    }
    impl<T: Clone + 'static> core::fmt::Debug for Lazy_1<T> {
        fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
            write!(f, "{}", core::any::type_name::<Self>())
        }
    }
    impl<T: Clone + 'static> core::fmt::Display for Lazy_1<T> {
        fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
            write!(f, "{}", core::any::type_name::<Self>())
        }
    }
    impl<T: Clone + 'static> core::cmp::PartialEq for Lazy_1<T> {
        fn eq(&self, other: &Self) -> bool {
            core::ptr::eq(self, other)
        }
    }
    impl<T: Clone + 'static> core::cmp::Eq for Lazy_1<T> {}
    impl<T: Clone + 'static> core::hash::Hash for Lazy_1<T> {
        fn hash<H: core::hash::Hasher>(&self, state: &mut H) -> () {
            core::hash::Hash::hash(&(self as *const Self as usize), state)
        }
    }
}
