anchor.diff:  
     int get hashCode => _duration.hashCode;
   
  +  /**
  +   * Compares this Duration to [other],
  +   * returning zero if the values are equal.
  +   *
  +   * This function returns a negative integer
  +   * if this Duration is smaller than [other],
  +   * or a positive integer if it is greater.
  +   */
     int compareTo(Duration other) => _duration.compareTo(other._duration);
   
     String toString() {
  
positive.code: 
    static const Duration ZERO = const Duration(seconds: 0);
  
    /**
     * This [Duration] in microseconds.
     */
    final int _duration;
  
    /**
     * The duration is the sum of all individual parts. This means that individual
     * parts don't need to be less than the next-bigger unit. For example [hours]
     * is allowed to have a value greater than 23.
     *
     * All individual parts are allowed to be negative.
     * All arguments are by default 0.
     */
    const Duration({int days: 0,
                    int hours: 0,
  
negative.code:                     microseconds;
  
    /**
     * Adds this Duration and [other] and
     * returns the sum as a new Duration object.
     */
    Duration operator +(Duration other) {
      return new Duration(microseconds: _duration + other._duration);
    }
  
    /**
     * Subtracts [other] from this Duration and
     * returns the difference as a new Duration object.
     */
    Duration operator -(Duration other) {
      return new Duration(microseconds: _duration - other._duration);
    }
  
    /**
     * Multiplies this Duration by the given [factor] and returns the result
     * as a new Duration object.
     *
     * Note that when [factor] is a double, and the duration is greater than
     * 53 bits, precision is lost because of double-precision arithmetic.
  