UsesDataDir = 1 << 1
 InlineData  = 1 << 2
)
```

The "Metadata" section contains a single version, encoded in similar fashion as each version in the `Versions` array
of the previous version.

## Inline Data

Inline data is optional. If no inline data is present, it is encoded as 0 bytes.

| Entry               | Encoding                    | Content

			t.Fatalf("Test %d: failed to create erasure: %v", i, err)
		}
		encoded, err := erasure.EncodeData(t.Context(), buffer)
		if err != nil {
			t.Fatalf("Test %d: failed to encode data: %v", i, err)
		}

		for j := range encoded[:test.missingData] {
			encoded[j] = nil
		}
		for j := test.dataBlocks; j < test.dataBlocks+test.missingParity; j++ {
			encoded[j] = nil
		}

		if test.reconstructParity {

	readParts := ReadPartCheckSums(serializedOut)
	expectedChecksums := []string{
		part1Checksum.Encoded,
		part2Checksum.Encoded,
		part3Checksum.Encoded,
	}
	for i, expected := range expectedChecksums {
		if got := readParts[i][ChecksumCRC32C.String()]; got != expected {
			t.Fatalf("want part%dChecksum.Encoded %s, got %s", i+1, expected, got)
		}
	}

				ok = false
				continue
			}
			// Delete first shard and reconstruct...
			first := encoded[0]
			encoded[0] = nil
			failOnErr(e.DecodeDataBlocks(encoded))
			if a, b := first, encoded[0]; !bytes.Equal(a, b) {
				fmt.Fprintf(os.Stderr, "%v: error on self-test [d:%d,p:%d]: want %#v, got %#v\n", algo, conf[0], conf[1], hex.EncodeToString(a), hex.EncodeToString(b))

)

// getDataBlockLen - get length of data blocks from encoded blocks.
func getDataBlockLen(enBlocks [][]byte, dataBlocks int) int {
	size := 0
	// Figure out the data block length.
	for _, block := range enBlocks[:dataBlocks] {
		size += len(block)
	}
	return size
}

// Writes all the data blocks from encoded blocks until requested
// outSize length. Provides a way to skip bytes until the offset.

		MountPath: "/tmp/drive1",
		ID:        "uuid",
		Error:     "",
	}

	var buf bytes.Buffer
	gob.NewEncoder(&buf).Encode(v)
	encoded := buf.Bytes()
	b.Log("Size:", buf.Len(), "bytes")
	b.SetBytes(1)
	b.ReportAllocs()

	for b.Loop() {
		dec := gob.NewDecoder(bytes.NewBuffer(encoded))
		err := dec.Decode(&v)
		if err != nil {
			b.Fatal(err)
		}
	}
}

	IV        []byte
	Nonce     []byte
	Bytes     []byte
}

// UnmarshalJSON parses the given text as JSON-encoded
// ciphertext.
//
// UnmarshalJSON provides backward-compatible unmarsahaling
// of existing ciphertext. In the past, ciphertexts were
// JSON-encoded. Now, ciphertexts are binary-encoded.
// Therefore, there is no MarshalJSON implementation.
func (c *ciphertext) UnmarshalJSON(text []byte) error {
	const (

	s.data = ndata
}

// append single byte to scratch buffer
func (s *scratch) add(c byte) {
	if s.fill+1 >= cap(s.data) {
		s.grow()
	}

	s.data[s.fill] = c
	s.fill++
}

// append encoded rune to scratch buffer
func (s *scratch) addRune(r rune) int {
	if s.fill+utf8.UTFMax >= cap(s.data) {
		s.grow()
	}

	n := utf8.EncodeRune(s.data[s.fill:], r)
	s.fill += n
	return n

		return fmt.Errorf("checksum type does not match got %s and %s", c.Type.String(), other.Type.String())
	}
	// If never set, just add first checksum.
	if len(c.Raw) == 0 {
		c.Raw = other.Raw
		c.Encoded = other.Encoded
		return nil
	}
	if !c.Valid() {
		return fmt.Errorf("invalid base checksum")
	}
	if !other.Valid() {
		return fmt.Errorf("invalid part checksum")
	}

	switch c.Type.Base() {

			// For metadata values like "ö", "ÄMÄZÕÑ S3", and "öha, das sollte eigentlich
			// funktionieren", tested against a real AWS S3 bucket, S3 may encode incorrectly. For
			// example, "ö" was encoded as =?UTF-8?B?w4PCtg==?=, producing invalid UTF-8 instead
			// of =?UTF-8?B?w7Y=?=. This mirrors errors like the ä½ in another string.
			//
			// S3 uses B-encoding (Base64) for non-ASCII-heavy metadata and Q-encoding