void setProfiles(List<Profile> profiles);

    List<Profile> getProfiles();

    /**
     * Gets the start time of the build.
     *
     * @return The start time of the build or {@code null} if unknown.
     */
    @Deprecated
    Date getBuildStartTime();

    /**
     * Sets the start time of the build.
     *
     * @param buildStartTime The start time of the build, may be {@code null}.
     */

		switch binary.LittleEndian.Uint16(data[0:2]) {
		case healMRFMetaFormat:
		default:
			return fmt.Errorf("heal mrf: unknown format: %d", binary.LittleEndian.Uint16(data[0:2]))
		}
		switch binary.LittleEndian.Uint16(data[2:4]) {
		case healMRFMetaVersionV1:
		default:
			return fmt.Errorf("heal mrf: unknown version: %d", binary.LittleEndian.Uint16(data[2:4]))
		}

		mr := msgp.NewReader(rc)
		for {

		;;
	"wasmtime" | "")
		exec wasmtime run --dir=/ --env PWD="$PWD" --env PATH="$PATH" -W max-wasm-stack=8388608 ${GOWASIRUNTIMEARGS:-} "$1" "${@:2}"
		;;
	*)
		echo "Unknown Go WASI runtime specified: $GOWASIRUNTIME"
		exit 1
		;;

        if (i1 == -1 && i2 == -1) {
            // unknown phases, leave in existing order
            return 0;
        }
        if (i1 == -1) {
            // second one is known, so it comes first
            return 1;
        }
        if (i2 == -1) {
            // first one is known, so it comes first
            return -1;
        }
        int rv = Integer.compare(i1, i2);

          if (done) {
            println("completed")
          } else {
            if (firstUpdate) {
              firstUpdate = false
              if (contentLength == -1L) {
                println("content-length: unknown")
              } else {
                println("content-length: $contentLength")
              }
            }
            println(bytesWritten)
            if (contentLength != -1L) {

func getFSType(ftype uint32) string {
	fsTypeHex := strconv.FormatUint(uint64(ftype), 16)
	fsTypeString, ok := fsType2StringMap[fsTypeHex]
	if !ok {
		return "UNKNOWN"
	}
	return fsTypeString
}

// GetInfo returns total and free bytes available in a directory, e.g. `/`.
func GetInfo(path string, _ bool) (info Info, err error) {
	s := syscall.Statfs_t{}

            return acceptOrReject(member, Violation.error(member, SINCE_ERROR_MESSAGE + getCurrentVersion()));
        } else {
            throw new IllegalStateException("Unknown status: " + since);
        }
    }

    private boolean shouldSkipViolationCheckFor(JApiCompatibility member) {
        return !isClassFieldConstructorOrMethod(member) ||
            isInject(member) ||

     *
     * @param cause the cause which is saved for later retrieval by the {@link #getCause()} method.
     *              A {@code null} value is permitted, and indicates that the cause is nonexistent or unknown.
     */
    public MojoException(Throwable cause) {
        super(cause);
    }

    public String getLongMessage() {
        return longMessage;
    }

    public Object getSource() {

     * @return An Optional containing the repository from which the version was resolved,
     *         or empty Optional if the repository is unknown
     */
    @Nonnull
    Optional<Repository> getRepository(Version version);

                if (!warnings.contains(req.getMessage())) {
                    warnings.add(req.getMessage());
                }
                break;
            default:
                throw new IllegalArgumentException("Unknown severity: " + req.getSeverity());
        }
    }