anchor.diff:        }
       }
     }
  -  return result;
  +  return _Jenkins.finish(result);
   }
   
   /// Combine the hashCodes of an arbitrary number of values from an Iterable into
   /// one value. This function will return the same value if given "null" as if
   /// given an empty list.
   int hashList(Iterable<Object> args) {
  -  int result = 373;
  +  int result = 0;
     if (args != null) {
  -    for (Object arg in args) {
  -      assert(arg is! Iterable);
  -      result = 37 * result + arg.hashCode;
  -    }
  +    for (Object arg in args)
  +      result = _Jenkins.combine(result, arg);
     }
  -  return result;
  +  return _Jenkins.finish(result);
   }
  
positive.code:   Object arg13 = _hashEnd, Object arg14 = _hashEnd, Object arg15 = _hashEnd,
    Object arg16 = _hashEnd, Object arg17 = _hashEnd, Object arg18 = _hashEnd,
    Object arg19 = _hashEnd, Object arg20 = _hashEnd ]) {
    int result = 373;
    assert(arg01 is! Iterable);
    result = 37 * result + arg01.hashCode;
    assert(arg02 is! Iterable);
    result = 37 * result + arg02.hashCode;
    if (arg03 != _hashEnd) {
      assert(arg03 is! Iterable);
      result = 37 * result + arg03.hashCode;
      if (arg04 != _hashEnd) {
        assert(arg04 is! Iterable);
        result = 37 * result + arg04.hashCode;
        if (arg05 != _hashEnd) {
          assert(arg05 is! Iterable);
          result = 37 * result + arg05.hashCode;
          if (arg06 != _hashEnd) {
            assert(arg06 is! Iterable);
            result = 37 * result + arg06.hashCode;
            if (arg07 != _hashEnd) {
              assert(arg07 is! Iterable);
              result = 37 * result + arg07.hashCode;
              if (arg08 != _hashEnd) {
                assert(arg08 is! Iterable);
                result = 37 * result + arg08.hashCode;
                if (arg09 != _hashEnd) {
                  assert(arg09 is! Iterable);
                  result = 37 * result + arg09.hashCode;
                  if (arg10 != _hashEnd) {
                    assert(arg10 is! Iterable);
                    result = 37 * result + arg10.hashCode;
                    if (arg11 != _hashEnd) {
                      assert(arg11 is! Iterable);
                      result = 37 * result + arg11.hashCode;
                      if (arg12 != _hashEnd) {
                        assert(arg12 is! Iterable);
                        result = 37 * result + arg12.hashCode;
                        if (arg13 != _hashEnd) {
                          assert(arg13 is! Iterable);
                          result = 37 * result + arg13.hashCode;
                          if (arg14 != _hashEnd) {
                            assert(arg14 is! Iterable);
                            result = 37 * result + arg14.hashCode;
                            if (arg15 != _hashEnd) {
                              assert(arg15 is! Iterable);
                              result = 37 * result + arg15.hashCode;
                              if (arg16 != _hashEnd) {
                                assert(arg16 is! Iterable);
                                result = 37 * result + arg16.hashCode;
                                if (arg17 != _hashEnd) {
                                  assert(arg17 is! Iterable);
                                  result = 37 * result + arg17.hashCode;
                                  if (arg18 != _hashEnd) {
                                    assert(arg18 is! Iterable);
                                    result = 37 * result + arg18.hashCode;
                                    if (arg19 != _hashEnd) {
                                      assert(arg19 is! Iterable);
                                      result = 37 * result + arg19.hashCode;
                                      if (arg20 != _hashEnd) {
                                        assert(arg20 is! Iterable);
                                        result = 37 * result + arg20.hashCode;
                                        // I can see my house from here!
                                      }
                                    }
  
negative.code: 
  class _HashEnd { const _HashEnd(); }
  const _HashEnd _hashEnd = const _HashEnd();
  
  /// Jenkins hash function, optimized for small integers.
  ///
  /// Borrowed from the dart sdk: sdk/lib/math/jenkins_smi_hash.dart.
  class _Jenkins {
    static int combine(int hash, Object o) {
      assert(o is! Iterable);
      hash = 0x1fffffff & (hash + o.hashCode);
      hash = 0x1fffffff & (hash + ((0x0007ffff & hash) << 10));
      return hash ^ (hash >> 6);
    }
  
    static int finish(int hash) {
      hash = 0x1fffffff & (hash + ((0x03ffffff & hash) << 3));
      hash = hash ^ (hash >> 11);
      return 0x1fffffff & (hash + ((0x00003fff & hash) << 15));
    }
  }
  
  /// Combine up to twenty values' hashCodes into one value.
  ///
  