System.arraycopy(src, 0, dest, bodyOffset, length);
    }

    static String getOEMEncoding() {
        return OEM_ENCODING;
    }

    /**
     * Returns the raw byte representation of this message.
     *
     * @return A <code>byte[]</code> containing the raw message material.
     */
    public abstract byte[] toByteArray();

          switch (mode) {
            case HALF_EVEN:
              // roundFloorAsDouble and roundCeilingAsDouble are neighbors, so precisely
              // one of them should have an even long representation
              return ((Double.doubleToRawLongBits(roundFloorAsDouble) & 1L) == 0)
                  ? roundFloorAsDouble
                  : roundCeilingAsDouble;
            case HALF_DOWN:

 *
 * Given an algorithm, for example:
 *
 * <pre>{@code
 * public <N> someGraphAlgorithm(N startNode, PredecessorsFunction<N> predecessorsFunction);
 * }</pre>
 *
 * you will invoke it depending on the graph representation you're using.
 *
 * <p>If you have an instance of one of the primary {@code common.graph} types ({@link Graph},
 * {@link ValueGraph}, and {@link Network}):
 *
 * <pre>{@code
 * someGraphAlgorithm(startNode, graph);

 *
 * Given an algorithm, for example:
 *
 * <pre>{@code
 * public <N> someGraphAlgorithm(N startNode, PredecessorsFunction<N> predecessorsFunction);
 * }</pre>
 *
 * you will invoke it depending on the graph representation you're using.
 *
 * <p>If you have an instance of one of the primary {@code common.graph} types ({@link Graph},
 * {@link ValueGraph}, and {@link Network}):
 *
 * <pre>{@code
 * someGraphAlgorithm(startNode, graph);

        }
        else if ( this.getClass().isAssignableFrom(type) ) {
            return (T) this;
        }
        return null;
    }


    /**
     * Return the a text representation of this address such as
     * <tt>MYCOMPUTER/192.168.1.15</tt>.
     */
    @Override
    public String toString () {
        return this.addr.toString();
    }

import java.util.Random;
import javax.annotation.CheckForNull;
import org.checkerframework.checker.nullness.qual.Nullable;
import sun.misc.Unsafe;

/**
 * A package-local class holding common representation and mechanics for classes supporting dynamic
 * striping on 64bit values. The class extends Number so that concrete subclasses must publicly do
 * so.
 */
@GwtIncompatible
@ElementTypesAreNonnullByDefault

	AccTime time.Time

	Legacy bool // indicates object on disk is in legacy data format

	// internal representation of version purge status
	VersionPurgeStatusInternal string
	VersionPurgeStatus         VersionPurgeStatusType

	replicationDecision string // internal representation of replication decision for use by DeleteObject handler
	// The total count of all versions of this object
	NumVersions int

		if err != nil {
			err = msgp.WrapError(err, "Values", za0001)
			return
		}
		dst[za0001] = za0002
	}
	*m = dst
	return bts, nil
}

// MarshalMsg appends the bytes representation of b to the provided byte slice.
func (m *MSS) MarshalMsg(bytes []byte) (o []byte, err error) {
	if m == nil || *m == nil {
		return msgp.AppendNil(bytes), nil
	}
	o = msgp.AppendMapHeader(bytes, uint32(len(*m)))

	And    And
	andSet bool

	Tag    Tag
	tagSet bool

	// Caching tags, only once
	cachedTags map[string]string
}

// MarshalXML - produces the xml representation of the Filter struct
// only one of Prefix, And and Tag should be present in the output.
func (f Filter) MarshalXML(e *xml.Encoder, start xml.StartElement) error {
	if !f.set {
		return nil
	}

   */
  @Override
  boolean equals(@CheckForNull Object o);

  /** Returns {@code asMapOfRanges().hashCode()}. */
  @Override
  int hashCode();

  /** Returns a readable string representation of this range map. */
  @Override
  String toString();