public static void Run(CompressedStack compressedStack, ContextCallback callback, object state)
        {
            if (compressedStack == null)
            {
                throw new ArgumentNullException(nameof(compressedStack));
            }

            // The original code was not checking for a null callback and would throw NullReferenceException
            callback(state);
        }

		public void Undo ()
		{
			if ((_cs != null) && (_t != null)) {
				lock (_cs) {
					if ((_cs != null) && (_t != null)) {
						_t.SetCompressedStack (_cs);
					}
					_t = null;
					_cs = null;
				}
			}
		}

		static CompressedStack Capture ()
		{
			CompressedStack cs = new CompressedStack (0);
			cs._list = SecurityFrame.GetStack (1);

			// include any current CompressedStack inside the new Capture
			CompressedStack currentCs = Thread.CurrentThread.GetCompressedStack ();
			if (currentCs != null) {
				for (int i=0; i < currentCs._list.Count; i++)
					cs._list.Add (currentCs._list [i]);
			}
			return cs;
		}

 internal void CompleteConstruction(CompressedStack innerCS)
 {
     if (this.PLS == null)
     {
         PermissionListSet set = PermissionListSet.CreateCompressedState(this, innerCS);
         lock (this)
         {
             if (this.PLS == null)
             {
                 this.m_pls = set;
             }
         }
     }
 }

 public void Undo()
 {
     if ((this.curr_CS != null) || (this.prev_CS != null))
     {
         if (this.prev_ADStack != IntPtr.Zero)
         {
             CompressedStack.RestoreAppDomainStack(this.prev_ADStack);
         }
         CompressedStack.SetCompressedStackThread(this.prev_CS);
         this.prev_CS = null;
         this.curr_CS = null;
         this.prev_ADStack = IntPtr.Zero;
     }
 }

		public static CompressedStack Capture ()
		{
#if !FEATURE_COMPRESSEDSTACK
			throw new NotSupportedException ();
#else
			CompressedStack cs = new CompressedStack (0);
			cs._list = new ArrayList ();

			// include any current CompressedStack inside the new Capture
			CompressedStack currentCs = Thread.CurrentThread.ExecutionContext.SecurityContext.CompressedStack;
			if (currentCs != null) {
				for (int i=0; i < currentCs._list.Count; i++)
					cs._list.Add (currentCs._list [i]);
			}
			return cs;
#endif
		}

 [System.Security.SecurityCritical]  // auto-generated
 internal static void CheckHelper(CompressedStack cs,
                                 PermissionSet grantedSet,
                                 PermissionSet refusedSet,
                                 CodeAccessPermission demand, 
                                 PermissionToken permToken,
                                 RuntimeMethodHandleInternal rmh,
                                 RuntimeAssembly asm,
                                 SecurityAction action)
 {
     if (cs != null)
         cs.CheckDemand(demand, permToken, rmh);
     else
         CheckHelper(grantedSet, refusedSet, demand, permToken, rmh, (Object)asm, action, true);
 }

 [System.Security.SecurityCritical]  // auto-generated
 internal static void CheckSetHelper(CompressedStack cs,
                                    PermissionSet grants,
                                    PermissionSet refused,
                                    PermissionSet demands,
                                    RuntimeMethodHandleInternal rmh,
                                    RuntimeAssembly asm,
                                    SecurityAction action)
 {
     if (cs != null)
         cs.CheckSetDemand(demands, rmh);
     else
         CheckSetHelper(grants, refused, demands, rmh, (Object)asm, action, true);
 }

        public XmlTextReaderImpl( string url, XmlNameTable nt ): this( nt ) {
            if ( url == null ) {
                throw new ArgumentNullException( "url" );
            }
            if ( url.Length == 0 ) {
                throw new ArgumentException( Res.GetString( Res.Xml_EmptyUrl ), "url" );
            }
            namespaceManager = new XmlNamespaceManager( nt );

            compressedStack = CompressedStack.Capture();

            this.url = url;

            ps.baseUri = xmlResolver.ResolveUri( null, url );
            ps.baseUriStr = ps.baseUri.ToString();
            reportedBaseUri = ps.baseUriStr;

            parsingFunction = ParsingFunction.OpenUrl;
        }

		public void SetCompressedStack (CompressedStack stack)
		{
#if MOBILE
			throw new NotSupportedException ();
#else
			ExecutionContext.SecurityContext.CompressedStack = stack;
#endif
		}

		internal CompressedStack (CompressedStack cs)
		{
			if ((cs != null) && (cs._list != null))
				_list = (ArrayList) cs._list.Clone ();
		}

 internal extern static bool IsImmediateCompletionCandidate(SafeCompressedStackHandle compressedStack, out CompressedStack innerCS);

 public static void Run(CompressedStack compressedStack, ContextCallback callback, Object state)
 {
 }

 public void SetCompressedStack(CompressedStack stack)
 {
   Contract.Ensures(false);
 }

        [System.Security.SecurityCritical]  // auto-generated
        private unsafe void Init(String name, 
                                 MethodAttributes attributes, 
                                 CallingConventions callingConvention, 
                                 Type returnType, 
                                 Type[] signature, 
                                 Type owner, 
                                 Module m, 
                                 bool skipVisibility,
                                 bool transparentMethod,
                                 ref StackCrawlMark stackMark)
        {
            DynamicMethod.CheckConsistency(attributes, callingConvention);

            // check and store the signature
            if (signature != null) {
                m_parameterTypes = new RuntimeType[signature.Length];
                for (int i = 0; i < signature.Length; i++) {
                    if (signature[i] == null) 
                        throw new ArgumentException(Environment.GetResourceString("Arg_InvalidTypeInSignature"));
                    m_parameterTypes[i] = signature[i].UnderlyingSystemType as RuntimeType;
                    if ( m_parameterTypes[i] == null || !(m_parameterTypes[i] is RuntimeType) || m_parameterTypes[i] == (RuntimeType)typeof(void) ) 
                        throw new ArgumentException(Environment.GetResourceString("Arg_InvalidTypeInSignature"));
                }
            }
            else {
                m_parameterTypes = Array.Empty<RuntimeType>();
            }
            
            // check and store the return value
            m_returnType = (returnType == null) ? (RuntimeType)typeof(void) : returnType.UnderlyingSystemType as RuntimeType;
            if ( (m_returnType == null) || !(m_returnType is RuntimeType) || m_returnType.IsByRef ) 
                throw new NotSupportedException(Environment.GetResourceString("Arg_InvalidTypeInRetType"));

            if (transparentMethod)
            {
                Contract.Assert(owner == null && m == null, "owner and m cannot be set for transparent methods");
                m_module = GetDynamicMethodsModule();
                if (skipVisibility)
                {
                    m_restrictedSkipVisibility = true;
                }

#if FEATURE_COMPRESSEDSTACK
                m_creationContext = CompressedStack.Capture();
#endif // FEATURE_COMPRESSEDSTACK
            }
            else
            {
                Contract.Assert(m != null || owner != null, "PerformSecurityCheck should ensure that either m or owner is set");
                Contract.Assert(m == null || !m.Equals(s_anonymouslyHostedDynamicMethodsModule), "The user cannot explicitly use this assembly");
                Contract.Assert(m == null || owner == null, "m and owner cannot both be set");

                if (m != null)
                    m_module = m.ModuleHandle.GetRuntimeModule(); // this returns the underlying module for all RuntimeModule and ModuleBuilder objects.
                else
                {
                    RuntimeType rtOwner = null;
                    if (owner != null)
                        rtOwner = owner.UnderlyingSystemType as RuntimeType;

                    if (rtOwner != null)
                    {
                        if (rtOwner.HasElementType || rtOwner.ContainsGenericParameters
                            || rtOwner.IsGenericParameter || rtOwner.IsInterface)
                            throw new ArgumentException(Environment.GetResourceString("Argument_InvalidTypeForDynamicMethod"));

                        m_typeOwner = rtOwner;
                        m_module = rtOwner.GetRuntimeModule();
                    }
                }

                m_skipVisibility = skipVisibility;
            }

            // initialize remaining fields
            m_ilGenerator = null;
            m_fInitLocals = true;
            m_methodHandle = null;

            if (name == null) 
                throw new ArgumentNullException("name");

#if FEATURE_APPX
            if (AppDomain.ProfileAPICheck)
            {
                if (m_creatorAssembly == null)
                    m_creatorAssembly = RuntimeAssembly.GetExecutingAssembly(ref stackMark);

                if (m_creatorAssembly != null && !m_creatorAssembly.IsFrameworkAssembly())
                    m_profileAPICheck = true;
            }
#endif // FEATURE_APPX

            m_dynMethod = new RTDynamicMethod(this, name, attributes, callingConvention);
        }

		// internal stuff

		internal bool Equals (CompressedStack cs)
		{
			if (IsEmpty ())
				return cs.IsEmpty ();
			if (cs.IsEmpty ())
				return false;
			if (_list.Count != cs._list.Count)
				return false;

			for (int i=0; i < _list.Count; i++) {
				SecurityFrame sf1 = (SecurityFrame) _list [i];
				SecurityFrame sf2 = (SecurityFrame) cs._list [i];
				if (!sf1.Equals (sf2))
					return false;
			}
			return true;
		}

		static public void Run (CompressedStack compressedStack, ContextCallback callback, object state)
		{
			if (compressedStack == null)
				throw new ArgumentException ("compressedStack");

			Thread t = Thread.CurrentThread;
			CompressedStack original = null;
			try {
				original = t.GetCompressedStack (); 
				t.SetCompressedStack (compressedStack);
				callback (state);
			}
			finally {
				if (original != null)
					t.SetCompressedStack (original);
			}
		}

 public void SetCompressedStack(CompressedStack stack)
 {
     throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_ThreadAPIsNotSupported"));
 }

        [System.Security.SecurityCritical]  // auto-generated
        private static void ReflectionTargetDemandHelper(int permission,
                                                         PermissionSet targetGrant,
                                                         CompressedStack securityContext)
        {
            Contract.Assert(securityContext != null, "securityContext != null");

            // We need to remove all identity permissions from the grant set of the target, otherwise the
            // disjunctive demand will fail unless we're reflecting on the same assembly.
            PermissionSet demandSet = null;
            if (targetGrant == null)
            {
                demandSet = new PermissionSet(PermissionState.Unrestricted);
            }
            else
            {
                demandSet = targetGrant.CopyWithNoIdentityPermissions();
                demandSet.AddPermission(new ReflectionPermission(ReflectionPermissionFlag.RestrictedMemberAccess));
            }

            securityContext.DemandFlagsOrGrantSet((1 << (int)permission), demandSet);
        }

        public void Undo()
        {
            if (curr_CS == null && prev_CS == null)
                return;
            if (prev_ADStack != (IntPtr)0)
                CompressedStack.RestoreAppDomainStack(prev_ADStack);
            CompressedStack.SetCompressedStackThread(prev_CS);

            prev_CS = null;
            curr_CS = null;
            prev_ADStack = (IntPtr)0;
        }