internal _IOCompletionCallback(IOCompletionCallback ioCompletionCallback, ref StackCrawlMark stackMark)
 {
     _ioCompletionCallback = ioCompletionCallback;
     // clone the exection context
     _executionContext = ExecutionContext.Capture(ref stackMark);
     ExecutionContext.ClearSyncContext(_executionContext);
 }

 public ResourceSet GrovelForResourceSet(CultureInfo culture, Dictionary<string, ResourceSet> localResourceSets, bool tryParents, bool createIfNotExists, ref StackCrawlMark stackMark)
 {
     string file = null;
     ResourceSet set = null;
     ResourceSet set2;
     try
     {
         new FileIOPermission(PermissionState.Unrestricted).Assert();
         string resourceFileName = this._mediator.GetResourceFileName(culture);
         file = this.FindResourceFile(culture, resourceFileName);
         if (file == null)
         {
             if (tryParents && culture.HasInvariantCultureName)
             {
                 throw new MissingManifestResourceException(Environment.GetResourceString("MissingManifestResource_NoNeutralDisk") + Environment.NewLine + "baseName: " + this._mediator.BaseNameField + "  locationInfo: " + ((this._mediator.LocationInfo == null) ? "<null>" : this._mediator.LocationInfo.FullName) + "  fileName: " + this._mediator.GetResourceFileName(culture));
             }
         }
         else
         {
             set = this.CreateResourceSet(file);
         }
         set2 = set;
     }
     finally
     {
         CodeAccessPermission.RevertAssert();
     }
     return set2;
 }

        internal static Type GetType(
            string typeName,
            Func<AssemblyName, Assembly> assemblyResolver,
            Func<Assembly, string, bool, Type> typeResolver,
            bool throwOnError,
            bool ignoreCase,
            ref StackCrawlMark stackMark)
        {
            if (typeName == null)
                throw new ArgumentNullException("typeName");
            if (typeName.Length > 0 && typeName[0] == '\0')
                throw new ArgumentException(Environment.GetResourceString("Format_StringZeroLength"));
            Contract.EndContractBlock();

            Type ret = null;

            SafeTypeNameParserHandle handle = CreateTypeNameParser(typeName, throwOnError);

            if (handle != null)
            {
                // If we get here the typeName must have been successfully parsed.
                // Let's construct the Type object.
                using (TypeNameParser parser = new TypeNameParser(handle))
                {
                    ret = parser.ConstructType(assemblyResolver, typeResolver, throwOnError, ignoreCase, ref stackMark);
                }
            }

            return ret;
        }

 internal static ExecutionContext Capture(ref StackCrawlMark stackMark)
 {
     if (IsFlowSuppressed())
     {
         return null;
     }
     ExecutionContext executionContextNoCreate = System.Threading.Thread.CurrentThread.GetExecutionContextNoCreate();
     ExecutionContext context2 = new ExecutionContext {
         isNewCapture = true,
         SecurityContext = System.Security.SecurityContext.Capture(executionContextNoCreate, ref stackMark)
     };
     if (context2.SecurityContext != null)
     {
         context2.SecurityContext.ExecutionContext = context2;
     }
     context2._hostExecutionContext = HostExecutionContextManager.CaptureHostExecutionContext();
     if (executionContextNoCreate != null)
     {
         context2._syncContext = (executionContextNoCreate._syncContext == null) ? null : executionContextNoCreate._syncContext.CreateCopy();
         if (executionContextNoCreate._logicalCallContext != null)
         {
             System.Runtime.Remoting.Messaging.LogicalCallContext logicalCallContext = executionContextNoCreate.LogicalCallContext;
             context2.LogicalCallContext = (System.Runtime.Remoting.Messaging.LogicalCallContext) logicalCallContext.Clone();
         }
     }
     return context2;
 }

 internal _IOCompletionCallback(IOCompletionCallback ioCompletionCallback, ref StackCrawlMark stackMark)
 {
     _ioCompletionCallback = ioCompletionCallback;
     // clone the exection context
     _executionContext = ExecutionContext.Capture(
         ref stackMark, 
         ExecutionContext.CaptureOptions.IgnoreSyncCtx | ExecutionContext.CaptureOptions.OptimizeDefaultCase);
 }

 private unsafe Type ConstructType(Func<AssemblyName, Assembly> assemblyResolver, Func<Assembly, string, bool, Type> typeResolver, bool throwOnError, bool ignoreCase, ref StackCrawlMark stackMark)
 {
     Assembly assembly = null;
     int[] numArray2;
     string assemblyName = this.GetAssemblyName();
     if (assemblyName.Length > 0)
     {
         assembly = ResolveAssembly(assemblyName, assemblyResolver, throwOnError, ref stackMark);
         if (assembly == null)
         {
             return null;
         }
     }
     string[] names = this.GetNames();
     if (names == null)
     {
         if (throwOnError)
         {
             throw new TypeLoadException(Environment.GetResourceString("Arg_TypeLoadNullStr"));
         }
         return null;
     }
     Type typeStart = ResolveType(assembly, names, typeResolver, throwOnError, ignoreCase, ref stackMark);
     if (typeStart == null)
     {
         return null;
     }
     SafeTypeNameParserHandle[] typeArguments = this.GetTypeArguments();
     Type[] genericArgs = null;
     if (typeArguments != null)
     {
         genericArgs = new Type[typeArguments.Length];
         for (int i = 0; i < typeArguments.Length; i++)
         {
             using (TypeNameParser parser = new TypeNameParser(typeArguments[i]))
             {
                 genericArgs[i] = parser.ConstructType(assemblyResolver, typeResolver, throwOnError, ignoreCase, ref stackMark);
             }
             if (genericArgs[i] == null)
             {
                 return null;
             }
         }
     }
     int[] modifiers = this.GetModifiers();
     if (((numArray2 = modifiers) == null) || (numArray2.Length == 0))
     {
         numRef = null;
         goto Label_00EE;
     }
     fixed (int* numRef = numArray2)
     {
         IntPtr ptr;
     Label_00EE:
         ptr = new IntPtr((void*) numRef);
         return RuntimeTypeHandle.GetTypeHelper(typeStart, genericArgs, ptr, (modifiers == null) ? 0 : modifiers.Length);
     }
 }

 internal _TimerCallback(TimerCallback timerCallback, object state, ref StackCrawlMark stackMark)
 {
     this._timerCallback = timerCallback;
     this._state = state;
     if (!ExecutionContext.IsFlowSuppressed())
     {
         this._executionContext = ExecutionContext.Capture(ref stackMark, ExecutionContext.CaptureOptions.OptimizeDefaultCase | ExecutionContext.CaptureOptions.IgnoreSyncCtx);
     }
 }

 internal _ThreadPoolWaitCallback(WaitCallback waitCallback, object state, bool compressStack, ref StackCrawlMark stackMark)
 {
     this._waitCallback = waitCallback;
     this._state = state;
     if (compressStack && !ExecutionContext.IsFlowSuppressed())
     {
         this._executionContext = ExecutionContext.Capture(ref stackMark, ExecutionContext.CaptureOptions.OptimizeDefaultCase | ExecutionContext.CaptureOptions.IgnoreSyncCtx);
     }
 }

 internal QueueUserWorkItemCallback(WaitCallback waitCallback, object stateObj, bool compressStack, ref StackCrawlMark stackMark)
 {
     this.callback = waitCallback;
     this.state = stateObj;
     if (compressStack && !ExecutionContext.IsFlowSuppressed())
     {
         this.context = ExecutionContext.Capture(ref stackMark, ExecutionContext.CaptureOptions.OptimizeDefaultCase | ExecutionContext.CaptureOptions.IgnoreSyncCtx);
     }
 }

 internal _ThreadPoolWaitOrTimerCallback(WaitOrTimerCallback waitOrTimerCallback, object state, bool compressStack, ref StackCrawlMark stackMark)
 {
     this._waitOrTimerCallback = waitOrTimerCallback;
     this._state = state;
     if (compressStack && !ExecutionContext.IsFlowSuppressed())
     {
         this._executionContext = ExecutionContext.Capture(ref stackMark);
         ExecutionContext.ClearSyncContext(this._executionContext);
     }
 }

 internal _TimerCallback(TimerCallback timerCallback, Object state, ref StackCrawlMark stackMark)
 {
     _timerCallback = timerCallback;
     _state = state;
     if (!ExecutionContext.IsFlowSuppressed())
     {
         _executionContext = ExecutionContext.Capture(ref stackMark);
         ExecutionContext.ClearSyncContext(_executionContext);
     }
 }

		internal static Type GetType(
            string typeName,
            Func<AssemblyName, Assembly> assemblyResolver,
            Func<Assembly, string, bool, Type> typeResolver,
            bool throwOnError,
            bool ignoreCase,
            ref StackCrawlMark stackMark)
		{
			TypeSpec spec = TypeSpec.Parse (typeName);
			return spec.Resolve (assemblyResolver, typeResolver, throwOnError, ignoreCase);
		}

 internal void AddTimer(TimerCallback callback, object state, uint dueTime, uint period, ref StackCrawlMark stackMark)
 {
     if (callback == null)
     {
         throw new ArgumentNullException("TimerCallback");
     }
     _TimerCallback callback2 = new _TimerCallback(callback, state, ref stackMark);
     state = callback2;
     this.AddTimerNative(state, dueTime, period, ref stackMark);
     this.timerDeleted = 0;
 }

		private unsafe Type ConstructType(Func<AssemblyName, Assembly> assemblyResolver, Func<Assembly, string, bool, Type> typeResolver, bool throwOnError, bool ignoreCase, ref StackCrawlMark stackMark)
		{
			Assembly assembly = null;
			string assemblyName = this.GetAssemblyName();
			if (assemblyName.Length > 0)
			{
				assembly = TypeNameParser.ResolveAssembly(assemblyName, assemblyResolver, throwOnError, ref stackMark);
				if (assembly == null)
				{
					return null;
				}
			}
			string[] names = this.GetNames();
			if (names == null)
			{
				if (throwOnError)
				{
					throw new TypeLoadException(Environment.GetResourceString("Arg_TypeLoadNullStr"));
				}
				return null;
			}
			else
			{
				Type type = TypeNameParser.ResolveType(assembly, names, typeResolver, throwOnError, ignoreCase, ref stackMark);
				if (type == null)
				{
					return null;
				}
				SafeTypeNameParserHandle[] typeArguments = this.GetTypeArguments();
				Type[] array = null;
				if (typeArguments != null)
				{
					array = new Type[typeArguments.Length];
					for (int i = 0; i < typeArguments.Length; i++)
					{
						using (TypeNameParser typeNameParser = new TypeNameParser(typeArguments[i]))
						{
							array[i] = typeNameParser.ConstructType(assemblyResolver, typeResolver, throwOnError, ignoreCase, ref stackMark);
						}
						if (array[i] == null)
						{
							return null;
						}
					}
				}
				int[] modifiers = this.GetModifiers();
				fixed (int* ptr = modifiers)
				{
					IntPtr pModifiers = new IntPtr((void*)ptr);
					return RuntimeTypeHandle.GetTypeHelper(type, array, pModifiers, (modifiers == null) ? 0 : modifiers.Length);
				}
			}
		}

		internal Object CreateInstanceSlow(bool publicOnly, bool skipCheckThis, bool fillCache, ref StackCrawlMark stackMark)
		{
			bool bNeedSecurityCheck = true;
			bool bCanBeCached = false;
			bool bSecurityCheckOff = false;

			if (!skipCheckThis)
				CreateInstanceCheckThis();

			if (!fillCache)
				bSecurityCheckOff = true;

			return CreateInstanceMono (!publicOnly);
		}

        internal ModuleBuilder DefineDynamicModuleInternal(
            String      name,
            bool        emitSymbolInfo,         // specify if emit symbol info or not
            ref StackCrawlMark stackMark)
        {
            BCLDebug.Log("DYNIL","## DYNIL LOGGING: AssemblyBuilder.DefineDynamicModule( " + name + " )");
            
            BCLDebug.Assert(m_assemblyData != null, "m_assemblyData is null in DefineDynamicModuleInternal");

            if (name == null)
                throw new ArgumentNullException("name");
            if (name.Length == 0)
                throw new ArgumentException(Environment.GetResourceString("Argument_EmptyName"), "name");
           if (name[0] == '\0')
                throw new ArgumentException(Environment.GetResourceString("Argument_InvalidName"), "name");
             
            m_assemblyData.CheckNameConflict(name);
    
            // create the dynamic module
            ModuleBuilder   dynModule = nDefineDynamicModule(this, emitSymbolInfo, name, ref stackMark);
            ISymbolWriter   writer = null;

            if (emitSymbolInfo)
            {
                // create the default SymWriter
                Assembly assem = LoadISymWrapper();
                Type symWriter = assem.GetType("System.Diagnostics.SymbolStore.SymWriter", true, false);
                if (symWriter != null && !symWriter.IsVisible) 
                    symWriter = null;

                if (symWriter == null)
                {
                    // cannot find SymWriter
                    throw new ExecutionEngineException(String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString(ResId.MissingType), "SymWriter")); 
                }
                try {
                    (new PermissionSet(PermissionState.Unrestricted)).Assert();
                    writer = (ISymbolWriter) Activator.CreateInstance(symWriter);
                }
                finally {
                    CodeAccessPermission.RevertAssert();
                }
            }

            dynModule.Init(name, null, writer);
            m_assemblyData.AddModule(dynModule);
            return dynModule;
        }

 internal static void Assert(PermissionSet permSet, ref StackCrawlMark stackMark)
 {
     FrameSecurityDescriptor descriptor = CodeAccessSecurityEngine.CheckNReturnSO(CodeAccessSecurityEngine.AssertPermissionToken, CodeAccessSecurityEngine.AssertPermission, ref stackMark, 1);
     if (descriptor == null)
     {
         Environment.FailFast(Environment.GetResourceString("ExecutionEngine_MissingSecurityDescriptor"));
     }
     else
     {
         if (descriptor.HasImperativeAsserts())
         {
             throw new SecurityException(Environment.GetResourceString("Security_MustRevertOverride"));
         }
         descriptor.SetAssert(permSet);
     }
 }

 internal static void AssertAllPossible(ref StackCrawlMark stackMark)
 {
     FrameSecurityDescriptor securityObjectForFrame = GetSecurityObjectForFrame(ref stackMark, true);
     if (securityObjectForFrame == null)
     {
         Environment.FailFast(Environment.GetResourceString("ExecutionEngine_MissingSecurityDescriptor"));
     }
     else
     {
         if (securityObjectForFrame.GetAssertAllPossible())
         {
             throw new SecurityException(Environment.GetResourceString("Security_MustRevertOverride"));
         }
         securityObjectForFrame.SetAssertAllPossible();
     }
 }

        [System.Security.SecuritySafeCritical]  // auto-generated
        public ResourceSet GrovelForResourceSet(CultureInfo culture, Dictionary<String, ResourceSet> localResourceSets, bool tryParents, bool createIfNotExists, ref StackCrawlMark stackMark) 
        {
            Contract.Assert(culture != null, "culture shouldn't be null; check caller");

            String fileName = null;
            ResourceSet rs = null;

            // Don't use Assembly manifest, but grovel on disk for a file.
            try
            {
#if !DISABLE_CAS_USE
                new System.Security.Permissions.FileIOPermission(System.Security.Permissions.PermissionState.Unrestricted).Assert();
#endif

                // Create new ResourceSet, if a file exists on disk for it.
                String tempFileName = _mediator.GetResourceFileName(culture);
                fileName = FindResourceFile(culture, tempFileName);
                if (fileName == null)
                {
                    if (tryParents)
                    {
                        // If we've hit top of the Culture tree, return.
                        if (culture.HasInvariantCultureName)
                        {
                            // We really don't think this should happen - we always
                            // expect the neutral locale's resources to be present.
                            throw new MissingManifestResourceException(Environment.GetResourceString("MissingManifestResource_NoNeutralDisk") + Environment.NewLine + "baseName: " + _mediator.BaseNameField + "  locationInfo: " + (_mediator.LocationInfo == null ? "<null>" : _mediator.LocationInfo.FullName) + "  fileName: " + _mediator.GetResourceFileName(culture));
                        }
                    }
                }
                else
                {
                    rs = CreateResourceSet(fileName);
                }
                return rs;
            }
            finally
            {
#if !DISABLE_CAS_USE
                System.Security.CodeAccessPermission.RevertAssert();
#endif
            }
        }

 internal static void Deny(PermissionSet permSet, ref StackCrawlMark stackMark)
 {
     if (!AppDomain.CurrentDomain.IsLegacyCasPolicyEnabled)
     {
         throw new NotSupportedException(Environment.GetResourceString("NotSupported_CasDeny"));
     }
     FrameSecurityDescriptor securityObjectForFrame = GetSecurityObjectForFrame(ref stackMark, true);
     if (securityObjectForFrame == null)
     {
         Environment.FailFast(Environment.GetResourceString("ExecutionEngine_MissingSecurityDescriptor"));
     }
     else
     {
         if (securityObjectForFrame.HasImperativeDenials())
         {
             throw new SecurityException(Environment.GetResourceString("Security_MustRevertOverride"));
         }
         securityObjectForFrame.SetDeny(permSet);
     }
 }