anchor.diff:      if (identical(this, other)) return true;
       if (runtimeType != other.runtimeType) return false;
       final Rect typedOther = other;
  -    for (int i = 0; i < _kDataSize; i += 1) {
  -      if (_value[i] != typedOther._value[i]) return false;
  -    }
  -    return true;
  -  }
  -
  -  @override
  -  int get hashCode => hashList(_value);
  +    return left == typedOther.left &&
  +        top == typedOther.top &&
  +        right == typedOther.right &&
  +        bottom == typedOther.bottom;
  +  }
  +
  +  @override
  +  int get hashCode => hashValues(left, top, right, bottom);
   
     @override
     String toString() =>
  
positive.code:   static Rect lerp(Rect a, Rect b, double t) {
      assert(t != null);
      if (a == null && b == null) return null;
      if (a == null) {
        return Rect.fromLTRB(b.left * t, b.top * t, b.right * t, b.bottom * t);
      }
      if (b == null) {
        final double k = 1.0 - t;
        return Rect.fromLTRB(a.left * k, a.top * k, a.right * k, a.bottom * k);
  
negative.code:   /// this rectangle.
    Size get size => Size(width, height);
  
    /// Whether any of the dimensions are `NaN`.
    bool get hasNaN => left.isNaN || top.isNaN || right.isNaN || bottom.isNaN;
  
    /// A rectangle with left, top, right, and bottom edges all at zero.
    static const Rect zero = Rect.fromLTRB(0.0, 0.0, 0.0, 0.0);
  
    static const double _giantScalar = 1.0E+9; // matches kGiantRect from layer.h
  
    /// A rectangle that covers the entire coordinate space.
    ///
    /// This covers the space from -1e9,-1e9 to 1e9,1e9.
    /// This is the space over which graphics operations are valid.
    static const Rect largest =
        Rect.fromLTRB(-_giantScalar, -_giantScalar, _giantScalar, _giantScalar);
  
    /// Whether any of the coordinates of this rectangle are equal to positive infinity.
  