if err != nil {
		return
	}
	err = en.WriteInt64(z.Bytes)
	if err != nil {
		err = msgp.WrapError(err, "Bytes")
		return
	}
	return
}

// MarshalMsg implements msgp.Marshaler
func (z RStat) MarshalMsg(b []byte) (o []byte, err error) {
	o = msgp.Require(b, z.Msgsize())
	// map header, size 2
	// string "Count"
	o = append(o, 0x82, 0xa5, 0x43, 0x6f, 0x75, 0x6e, 0x74)

	if *u != nil {
		for key := range *u {
			delete(*u, key)
		}
		val := map[string][]string(*u)
		urlValuesPool.Put(val)
		*u = nil
	}
}

// MarshalMsg implements msgp.Marshaler
func (u URLValues) MarshalMsg(b []byte) (o []byte, err error) {
	o = msgp.Require(b, u.Msgsize())
	o = msgp.AppendMapHeader(o, uint32(len(u)))
	for zb0006, zb0007 := range u {
		o = msgp.AppendString(o, zb0006)

			if err != nil {
				t.Fatalf("did not expect encoding error but got: %v", err)
			}
			marshaled, err := yaml.Marshal(&encoded)
			if err != nil {
				t.Fatalf("did not expect yaml marshalling error but got: %v", err)
			}
			if !reflect.DeepEqual(string(marshaled), test) {
				t.Fatalf("expected:\n%v\nbut got:\n%v", test, string(marshaled))
			}
		})
	}
}

func TestBuildManagerIdentifier(t *testing.T) {

			return
		}
		err = en.WriteInt(za0002.NumObjects)
		if err != nil {
			err = msgp.WrapError(err, "Tiers", za0001, "NumObjects")
			return
		}
	}
	return
}

// MarshalMsg implements msgp.Marshaler
func (z *allTierStats) MarshalMsg(b []byte) (o []byte, err error) {
	o = msgp.Require(b, z.Msgsize())
	// map header, size 1
	// string "ts"
	o = append(o, 0x81, 0xa2, 0x74, 0x73)

func (m *Message) String() string {
	return fmt.Sprintf("%v [%v]%s %s",
		m.Type.Level(), m.Type.Code(), m.Origin(),
		fmt.Sprintf(m.Type.Template(), m.Parameters...))
}

// MarshalJSON satisfies the Marshaler interface
func (m *Message) MarshalJSON() ([]byte, error) {
	return json.Marshal(m.Unstructured(true))
}

// NewMessageType returns a new MessageType instance.

package fnv

import (
	"bytes"
	"encoding"
	"encoding/binary"
	"hash"
	"io"
	"testing"
)

type golden struct {
	out       []byte
	in        string
	halfState string // marshaled hash state after first half of in written, used by TestGoldenMarshal
}

var golden32 = []golden{
	{[]byte{0x81, 0x1c, 0x9d, 0xc5}, "", "fnv\x01\x81\x1c\x9d\xc5"},

	for za0001 := range z.Rules {
		err = z.Rules[za0001].EncodeMsg(en)
		if err != nil {
			err = msgp.WrapError(err, "Rules", za0001)
			return
		}
	}
	return
}

// MarshalMsg implements msgp.Marshaler
func (z *BatchJobExpire) MarshalMsg(b []byte) (o []byte, err error) {
	o = msgp.Require(b, z.Msgsize())
	// map header, size 6
	// string "APIVersion"

	ErrorString string
}

// parseErrorToString converts the error from parsing the file into a string
// representation. A nil error is converted to an empty string, and all other
// errors are converted to a JSON-marshaled parseError struct, with ErrorList
// set for errors of type scanner.ErrorList, and ErrorString set to the error's
// string representation for all other errors.
func parseErrorToString(err error) string {
	if err == nil {

	"k8s.io/apimachinery/pkg/runtime"
	"k8s.io/apimachinery/pkg/runtime/schema"
	"k8s.io/apimachinery/pkg/util/errors"
	"k8s.io/apimachinery/pkg/util/sets"
)

var (
	marshalerType   = reflect.TypeOf((*json.Marshaler)(nil)).Elem()
	unmarshalerType = reflect.TypeOf((*json.Unmarshaler)(nil)).Elem()
)

// VerifyGroupNames ensures that all groups in the scheme ends with the k8s.io suffix.

// of the output, SetEscapeHTML(false) disables this behavior.
func (enc *Encoder) SetEscapeHTML(on bool) {
	enc.escapeHTML = on
}

// RawMessage is a raw encoded JSON value.
// It implements [Marshaler] and [Unmarshaler] and can
// be used to delay JSON decoding or precompute a JSON encoding.
type RawMessage []byte

// MarshalJSON returns m as the JSON encoding of m.
func (m RawMessage) MarshalJSON() ([]byte, error) {