void DnDebugger_DebugCallbackEvent(DnDebugger dbg, DebugCallbackEventArgs e) {
			if (e.Type == DebugCallbackType.CreateProcess) {
				dbg.DebugCallbackEvent -= DnDebugger_DebugCallbackEvent;
				var cpArgs = (CreateProcessDebugCallbackEventArgs)e;
				bool b = Initialize(cpArgs.CorProcess, dbg.DebuggeeVersion);
				Debug.Assert(b);
			}
		}

		void InstallDebuggerHooks(DnDebugger dbg) {
			dbg.OnModuleAdded += DnDebugger_OnModuleAdded;
			dbg.OnNameChanged += DnDebugger_OnNameChanged;
			var modules = GetAllModules(dbg).ToArray();
			Array.Sort(modules, (a, b) => a.ModuleOrder.CompareTo(b.ModuleOrder));
			foreach (var module in modules)
				Add(module);
		}

		public BreakProcessHelper(DnDebugger debugger, BreakProcessKind type, string filename) {
			if (debugger == null)
				throw new ArgumentNullException();
			this.debugger = debugger;
			this.type = type;
			this.filename = filename;
			AddStartupBreakpoint();
		}

 internal DnProcess(DnDebugger ownerDebugger, ICorDebugProcess process, int incrementedId)
 {
     this.ownerDebugger = ownerDebugger;
     this.appDomains = new DebuggerCollection<ICorDebugAppDomain, DnAppDomain>(CreateAppDomain);
     this.threads = new DebuggerCollection<ICorDebugThread, DnThread>(CreateThread);
     this.process = new CorProcess(process);
     this.incrementedId = incrementedId;
 }

		public void Initialize(DnDebugger dbg) {
			Debug.Assert(debugger.Dispatcher.CheckAccess());
			Debug.Assert(dbgBreakpoint == null);
			if (dbgBreakpoint != null)
				throw new InvalidOperationException();
			dbgBreakpoint = dbg.CreateBreakpoint(EventKind.ToDebugEventBreakpointKind(), HitHandler);
			dbgBreakpoint.IsEnabled = isEnabled;
			dbgBreakpoint.Tag = this;
		}

		void DnDebugger_DebugCallbackEvent(DnDebugger dbg, DebugCallbackEventArgs e) {
			if (nameErrorCounter != 0 && e.Type == DebugCallbackType.LoadClass) {
				var lcArgs = (LoadClassDebugCallbackEventArgs)e;
				var module = dbg.TryGetModule(lcArgs.CorAppDomain, lcArgs.CorClass);
				Debug.Assert(module != null);
				if (module != null && module.IsDynamic)
					pendingModules.Add(module.SerializedDnModule);
			}
		}

		static IEnumerable<DnModule> GetAllModules(DnDebugger dbg) {
			foreach (var process in dbg.Processes) {
				foreach (var appDomain in process.AppDomains) {
					foreach (var assembly in appDomain.Assemblies) {
						foreach (var module in assembly.Modules)
							yield return module;
					}
				}
			}
		}

        void DnDebugger_DebugCallbackEvent(DnDebugger dbg, DebugCallbackEventArgs e)
        {
            try {
                DebugCallbackEvent_counter++;

                if (DebugCallbackEvent_counter > 1)
                    return;
                if (e.Type == DebugCallbackType.Exception2) {
                    var ee = (Exception2DebugCallbackEventArgs)e;
                    if (ee.EventType == CorDebugExceptionCallbackType.DEBUG_EXCEPTION_UNHANDLED)
                        UnhandledException(ee);
                }
                else if (e.Type == DebugCallbackType.DebuggerError)
                    OnDebuggerError((DebuggerErrorDebugCallbackEventArgs)e);
            }
            finally {
                DebugCallbackEvent_counter--;
            }
        }

		public static void Initialize(DnDebugger debugger) {
			new DisableSystemDebuggerDetection(debugger);
		}

        void AddDebugger(DnDebugger newDebugger)
        {
            RemoveDebugger();

            debugger = newDebugger;
            DebugCallbackEvent_counter = 0;
            newDebugger.OnProcessStateChanged += DnDebugger_OnProcessStateChanged;
            newDebugger.DebugCallbackEvent += DnDebugger_DebugCallbackEvent;
        }

 void CallOnProcessStateChanged(DnDebugger dbg = null)
 {
     CallOnProcessStateChanged(dbg ?? debugger, DebuggerEventArgs.Empty);
 }

        void Debugger_DebugCallbackEvent(DnDebugger dbg, DebugCallbackEventArgs e)
        {
            var ee = e as EvalDebugCallbackEventArgs;
            if (ee == null)
                return;

            if (ee.Eval == eval.RawObject) {
                debugger.DebugCallbackEvent -= Debugger_DebugCallbackEvent;
                e.AddStopReason(DebuggerStopReason.Eval);
                debugMessageDispatcher.CancelDispatchQueue(ee.WasException);
                return;
            }
        }

        static MethodKey? CreateMethodKey(DnDebugger debugger, CorFrame frame)
        {
            var sma = frame.GetSerializedDnModuleWithAssembly();
            if (sma == null)
                return null;

            return MethodKey.Create(frame.Token, sma.Value.Module);
        }

 static DnDebugger CreateDnDebuggerCoreCLR(DebugProcessOptions options)
 {
     var clrType = (CoreCLRTypeDebugInfo)options.CLRTypeDebugInfo;
     var dbg2 = CoreCLRHelper.CreateDnDebugger(options, clrType, () => false, (cd, pid) => {
         var dbg = new DnDebugger(cd, options.DebugOptions, options.DebugMessageDispatcher, null);
         if (options.BreakProcessType != BreakProcessType.None)
             new BreakProcessHelper(dbg, options.BreakProcessType, options.Filename);
         ICorDebugProcess comProcess;
         cd.DebugActiveProcess((int)pid, 0, out comProcess);
         var dnProcess = dbg.TryAdd(comProcess);
         if (dnProcess != null)
             dnProcess.Initialize(false, options.Filename, options.CurrentDirectory, options.CommandLine);
         return dbg;
     });
     if (dbg2 == null)
         throw new Exception("Could not create a debugger instance");
     return dbg2;
 }

 void DnDebugger_DebugCallbackEvent(DnDebugger dbg, DebugCallbackEventArgs e)
 {
     if (e.Type == DebugCallbackType.Exception2)
         OnException((Exception2DebugCallbackEventArgs)e);
 }

		public AnyDebugEventBreakpointConditionContext(DnDebugger debugger, DnAnyDebugEventBreakpoint bp, DebugCallbackEventArgs e)
			: base(debugger) {
			AnyDebugEventBreakpoint = bp;
			EventArgs = e;
		}

		void UninstallDebuggerHooks(DnDebugger dbg) {
			dbg.OnModuleAdded -= DnDebugger_OnModuleAdded;
			dbg.OnNameChanged -= DnDebugger_OnNameChanged;
		}

		void AddDebugger(DnDebugger newDebugger) {
			RemoveDebugger();

			debugger = newDebugger;
			newDebugger.OnProcessStateChanged += DnDebugger_OnProcessStateChanged;
		}

		public void Initialize(DnDebugger newDebugger) {
			foreach (var l in loadBeforeDebugInsts) {
				var o = l.Value;
			}
			if (debuggerSettings.DisableManagedDebuggerDetection)
				DisableSystemDebuggerDetection.Initialize(newDebugger);
			AddDebugger(newDebugger);
			Debug.Assert(debugger == newDebugger);
			CallOnProcessStateChanged();
		}

 internal DnEval(DnDebugger debugger, IDebugMessageDispatcher debugMessageDispatcher)
 {
     this.debugger = debugger;
     this.debugMessageDispatcher = debugMessageDispatcher;
     this.suspendOtherThreads = true;
 }