anchor.diff:    }
   
     ZoneCallback registerCallback(Zone zone, f()) {
  -    _CustomizedZone parent = _degelationTarget;
  +    _BaseZone parent = _degelationTarget;
       while (parent._specification.registerCallback == null) {
         parent = parent.parent;
       }
  
positive.code:     } else {
        return (arg1, arg2) => this.runBinary(registered, arg1, arg2);
      }
    }
  
    operator [](Symbol key) {
  
negative.code:   return new _CustomizedZone(zone, specification, copiedMap);
  }
  
  class _RootZoneSpecification implements ZoneSpecification {
    const _RootZoneSpecification();
  
    HandleUncaughtErrorHandler get handleUncaughtError =>
        _rootHandleUncaughtError;
    RunHandler get run => _rootRun;
    RunUnaryHandler get runUnary => _rootRunUnary;
    RunBinaryHandler get runBinary => _rootRunBinary;
    RegisterCallbackHandler get registerCallback => _rootRegisterCallback;
    RegisterUnaryCallbackHandler get registerUnaryCallback =>
        _rootRegisterUnaryCallback;
    RegisterBinaryCallbackHandler get registerBinaryCallback =>
        _rootRegisterBinaryCallback;
    ScheduleMicrotaskHandler get scheduleMicrotask => _rootScheduleMicrotask;
    @deprecated
    RunAsyncHandler get runAsync => null;
    CreateTimerHandler get createTimer => _rootCreateTimer;
    CreatePeriodicTimerHandler get createPeriodicTimer =>
        _rootCreatePeriodicTimer;
    ForkHandler get fork => _rootFork;
  }
  
  class _RootZone extends _BaseZone {
    const _RootZone();
  
    Zone get parent => null;
    ZoneSpecification get _specification => const _RootZoneSpecification();
    Zone get _errorZone => this;
  
    bool inSameErrorZone(Zone otherZone) => otherZone._errorZone == this;
  
    operator [](Symbol key) => null;
  
    // Methods that can be customized by the zone specification.
  
    dynamic handleUncaughtError(error, StackTrace stackTrace) =>
        _rootHandleUncaughtError(this, null, this, error, stackTrace);
  
    Zone fork({ZoneSpecification specification, Map zoneValues}) =>
        _rootFork(this, null, this, specification, zoneValues);
  
    dynamic run(f()) => _rootRun(this, null, this, f);
  
    dynamic runUnary(f(arg), arg) => _rootRunUnary(this, null, this, f, arg);
  
    dynamic runBinary(f(arg1, arg2), arg1, arg2) =>
        _rootRunBinary(this, null, this, f, arg1, arg2);
  
    ZoneCallback registerCallback(f()) =>
        _rootRegisterCallback(this, null, this, f);
  
    ZoneUnaryCallback registerUnaryCallback(f(arg)) =>
        _rootRegisterUnaryCallback(this, null, this, f);
  
    ZoneBinaryCallback registerBinaryCallback(f(arg1, arg2)) =>
        _rootRegisterBinaryCallback(this, null, this, f);
  
    void scheduleMicrotask(void f()) {
      _rootScheduleMicrotask(this, null, this, f);
    }
  
    @deprecated
    void runAsync(void f()) {
      scheduleMicrotask(f);
    }
  
    Timer createTimer(Duration duration, void f()) =>
        _rootCreateTimer(this, null, this, duration, f);
  
    Timer createPeriodicTimer(Duration duration, void f(Timer timer)) =>
        _rootCreatePeriodicTimer(this, null, this, duration, f);
  }
  
  const _ROOT_ZONE = const _RootZone();
  
  
  /**
  