this.hashCode = computeHashcode(module, version, attributes, requestedCapabilities);
    }

    private int computeHashcode(ModuleIdentifier module, ImmutableVersionConstraint version, ImmutableAttributes attributes, ImmutableList<Capability> requestedCapabilities) {
        int hashCode = version.hashCode();
        hashCode = 31 * hashCode + module.hashCode();
        hashCode = 31 * hashCode + attributes.hashCode();

        int hashCode = rawType.hashCode();
        for (TypeWrapper actualTypeArgument : actualTypeArguments) {
            hashCode ^= actualTypeArgument.hashCode();
        }
        if (ownerType != null) {
            hashCode ^= ownerType.hashCode();
        }
        return hashCode;
    }

    public TypeWrapper getRawType() {
        return rawType;
    }

      assertErrorMessage(
          e,
          "the Object#hashCode ("
              + a.hashCode()
              + ") of "
              + a
              + " [group 1, item 1] must be equal to the Object#hashCode ("
              + b.hashCode()
              + ") of "
              + b);
      return;
    }
    fail("Should get invalid hashCode error");
  }

  public void testNullEqualityGroup() {

        return hashCode == that.hashCode &&
            isArtifactExclude == that.isArtifactExclude &&
            Objects.equal(moduleId, that.moduleId) &&
            Objects.equal(ivyArtifactName, that.ivyArtifactName) &&
            Objects.equal(matcher, that.matcher);
    }

    @Override
    public int hashCode() {
        return hashCode;
    }

    @Override

      dummy += Objects.hashCode(S0, S1, S2, S3);
    }
    return dummy;
  }

  @Benchmark
  int hashString_5(int reps) {
    int dummy = 0;
    for (int i = 0; i < reps; i++) {
      dummy += Objects.hashCode(S0, S1, S2, S3, S4);
    }
    return dummy;
  }

  @Benchmark
  int hashMixed_5(int reps) {
    int dummy = 0;
    for (int i = 0; i < reps; i++) {
      dummy += Objects.hashCode(I2, S1, D1, S2, I0);

        String className = type.getName();
        HashCode classLoaderHash = classLoaderHasher.getClassLoaderHash(type.getClassLoader());
        return of(className, classLoaderHash, isLambdaClass(type), null);
    }

    public static ImplementationSnapshot of(String className, @Nullable HashCode classLoaderHash) {
        return of(className, classLoaderHash, isLambdaClassName(className), null);
    }

            int hash = 17;
            hash = hash * 31 + groupId.hashCode();
            hash = hash * 31 + artifactId.hashCode();
            hash = hash * 31 + version.hashCode();
            hash = hash * 31 + hash(workspace);
            hash = hash * 31 + localRepo.hashCode();
            hash = hash * 31 + RepositoryUtils.repositoriesHashCode(repositories);
            this.hashCode = hash;
        }

        @Override

      for (int index = 0; index < size; index++) {
        sum += array[index].hashCode();
      }
    }
    return sum;
  }

  @Benchmark
  int arrayIndexedLength(int reps) {
    int sum = 0;
    for (int i = 0; i < reps; i++) {
      for (int index = 0; index < array.length; index++) {
        sum += array[index].hashCode();
      }
    }
    return sum;
  }

  @Benchmark

        return type == other.type && Objects.equal(value, other.value) && arguments.equals(other.arguments);
    }

    @Override
    public int hashCode() {
        return super.hashCode() ^ type.hashCode() ^ (value == null ? 0 : value.hashCode()) ^ arguments.hashCode();
    }

import org.gradle.caching.internal.origin.OriginMetadata;
import org.gradle.internal.hash.HashCode;

public class ImmutableWorkspaceMetadata {
    private final OriginMetadata originMetadata;
    private final ImmutableListMultimap<String, HashCode> outputPropertyHashes;

    public ImmutableWorkspaceMetadata(OriginMetadata originMetadata, ImmutableListMultimap<String, HashCode> outputPropertyHashes) {
        this.originMetadata = originMetadata;