anchor.diff:    // - week day of first day.
     // Leap seconds are ignored.
     // Adapted from V8's date implementation. See ECMA 262 - 15.9.1.9.
  -  static equivalentYear_(int year) {
  +  static _equivalentYear(int year) {
       // Returns 1 if in leap year. 0 otherwise.
       bool inLeapYear(year) {
         return (year.remainder(4) == 0) &&
  
positive.code:     // We exclude the year 1970 when the time is not UTC, since the epoch
      // value could then be negative.
      if (years < (isUtc ? 1970 : 1971) || years > 2035) {
        equivalentYear = equivalentYear_(years);
        int offsetInDays = (dayFromYear_(years) - dayFromYear_(equivalentYear));
        // Leap seconds are ignored.
        offsetInSeconds = offsetInDays * Duration.SECONDS_PER_DAY;
      } else {
  
negative.code:   }
  
    // Given [secondsSinceEpoch] returns seconds such that they are at the same
    // time in an equivalent year (see [_equivalentYear]).
    // Leap seconds are ignored.
    static int _equivalentSeconds(int secondsSinceEpoch) {
      if (secondsSinceEpoch >= 0 && secondsSinceEpoch < _SECONDS_YEAR_2035) {
        return secondsSinceEpoch;
      }
      int year = _yearsFromSecondsSinceEpoch(secondsSinceEpoch);
      int days = _dayFromYear(year);
      int equivalentYear = _equivalentYear(year);
      int equivalentDays = _dayFromYear(equivalentYear);
      int diffDays = equivalentDays - days;
      return secondsSinceEpoch + diffDays * Duration.SECONDS_PER_DAY;
    }
  
    // Returns the days since 1970 for the start of the given [year].
    // [year] may be before epoch.
    static int _dayFromYear(int year) {
      int flooredDivision(int a, int b) {
        return (a - (a < 0 ? b - 1 : 0)) ~/ b;
      }
  