@Nonnull
    Map<ChecksumAlgorithm, String> calculate(@Nonnull byte[] data, @Nonnull Collection<ChecksumAlgorithm> algorithms);

    /**
     * Calculates checksums for specified data.
     *
     * @param data        The content for which to calculate checksums, must not be {@code null}.
     * @param algorithms  The checksum algorithms to use, must not be {@code null}.
     * @return The calculated checksums, indexed by algorithms, never {@code null}.

    /**
     * 
     * @param password
     * @return the calculated hash
     */
    public static byte[] nTOWFv1 ( String password ) {
        return getNTHash(password);
    }


    /**
     * 
     * @param passwordHash
     * @param serverChallenge
     * @param clientChallenge
     * @return the calculated response
     * @throws GeneralSecurityException
     */

	return "Bad sha256: Expected " + e.ExpectedSHA256 + " does not match calculated " + e.CalculatedSHA256
}

// BadDigest - Content-MD5 you specified did not match what we received.
type BadDigest struct {
	ExpectedMD5   string
	CalculatedMD5 string
}

func (e BadDigest) Error() string {
	return "Bad digest: Expected " + e.ExpectedMD5 + " does not match calculated " + e.CalculatedMD5
}

// SizeTooSmall reader size too small

     *
     * @return The base directory of the current project or {@code null} if none.
     */
    Path getProjectDirectory();

    /**
     * Gets current calculated project properties
     *
     * @return The project properties, never {@code null}.
     */
    Map<String, String> getProjectProperties();

    /**
     * Specifies a single quantile index to be calculated, i.e. the k in the kth q-quantile.
     *
     * @param index the quantile index, which must be in the inclusive range [0, q] for q-quantiles
     */
    public ScaleAndIndex index(int index) {
      return new ScaleAndIndex(scale, index);
    }

    /**
     * Specifies multiple quantile indexes to be calculated, each index being the k in the kth
     * q-quantile.

            c = b;
            b = a % b;
            a = c;
        }
        return u * v / a;
    }


    /**
     * @param type
     * @param keys
     * @return the calculated mac
     * @throws PACDecodingException
     */
    public static byte[] calculateMac ( int type, Map<Integer, KerberosKey> keys, byte[] data ) throws PACDecodingException {
        try {
            int usage = 17;

      return LinearTransformation.vertical(xStats.mean());
    }
  }

  /**
   * {@inheritDoc}
   *
   * <p><b>Note:</b> This tests exact equality of the calculated statistics, including the floating
   * point values. Two instances are guaranteed to be considered equal if one is copied from the
   * other using {@code second = new PairedStatsAccumulator().addAll(first).snapshot()}, if both

        }
        if ( len == 0 ) {
            return; /* CRITICAL */
        }
        this.digest.update(input, offset, len);
        this.updates++;
    }


    /**
     * @return calculated digest
     */
    public byte[] digest () {
        byte[] b;

        b = this.digest.digest();

        if ( log.isTraceEnabled() ) {
            log.trace("digest: ");

         */
        LIFECYCLE,
    }

    private Source source = Source.LIFECYCLE;

    /**
     * The phase may or may not have been bound to a phase but once the plan has been calculated we know what phase
     * this mojo execution is going to run in.
     */
    private String lifecyclePhase;

    /**

import org.apache.maven.api.services.ModelProblemCollector;

/**
 * Replaces expressions of the form <code>${token}</code> with their effective values. Effective values are basically
 * calculated from the elements of the model itself and the execution properties from the building request.
 *
 */
public interface ModelInterpolator {

    /**