// Copyright 2016 The Vanadium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// This file was auto-generated by the vanadium vdl tool.
// Package: internal

package internal

import (
	"fmt"
	"v.io/v23/vdl"
	"v.io/v23/vom"
)

var _ = __VDLInit() // Must be first; see __VDLInit comments for details.

//////////////////////////////////////////////////
// Type definitions

type VNumber int32

func (VNumber) __VDLReflect(struct {
	Name string `vdl:"v.io/v23/vom/internal.VNumber"`
}) {
}

func (x VNumber) VDLIsZero() bool {
	return x == 0
}

func (x VNumber) VDLWrite(enc vdl.Encoder) error {
	if err := enc.WriteValueInt(__VDLType_int32_1, int64(x)); err != nil {
		return err
	}
	return nil
}

func (x *VNumber) VDLRead(dec vdl.Decoder) error {
	switch value, err := dec.ReadValueInt(32); {
	case err != nil:
		return err
	default:
		*x = VNumber(value)
	}
	return nil
}

type VString string

func (VString) __VDLReflect(struct {
	Name string `vdl:"v.io/v23/vom/internal.VString"`
}) {
}

func (x VString) VDLIsZero() bool {
	return x == ""
}

func (x VString) VDLWrite(enc vdl.Encoder) error {
	if err := enc.WriteValueString(__VDLType_string_2, string(x)); err != nil {
		return err
	}
	return nil
}

func (x *VString) VDLRead(dec vdl.Decoder) error {
	switch value, err := dec.ReadValueString(); {
	case err != nil:
		return err
	default:
		*x = VString(value)
	}
	return nil
}

type VEnum int

const (
	VEnumA VEnum = iota
	VEnumB
	VEnumC
)

// VEnumAll holds all labels for VEnum.
var VEnumAll = [...]VEnum{VEnumA, VEnumB, VEnumC}

// VEnumFromString creates a VEnum from a string label.
func VEnumFromString(label string) (x VEnum, err error) {
	err = x.Set(label)
	return
}

// Set assigns label to x.
func (x *VEnum) Set(label string) error {
	switch label {
	case "A", "a":
		*x = VEnumA
		return nil
	case "B", "b":
		*x = VEnumB
		return nil
	case "C", "c":
		*x = VEnumC
		return nil
	}
	*x = -1
	return fmt.Errorf("unknown label %q in internal.VEnum", label)
}

// String returns the string label of x.
func (x VEnum) String() string {
	switch x {
	case VEnumA:
		return "A"
	case VEnumB:
		return "B"
	case VEnumC:
		return "C"
	}
	return ""
}

func (VEnum) __VDLReflect(struct {
	Name string `vdl:"v.io/v23/vom/internal.VEnum"`
	Enum struct{ A, B, C string }
}) {
}

func (x VEnum) VDLIsZero() bool {
	return x == VEnumA
}

func (x VEnum) VDLWrite(enc vdl.Encoder) error {
	if err := enc.WriteValueString(__VDLType_enum_3, x.String()); err != nil {
		return err
	}
	return nil
}

func (x *VEnum) VDLRead(dec vdl.Decoder) error {
	switch value, err := dec.ReadValueString(); {
	case err != nil:
		return err
	default:
		if err := x.Set(value); err != nil {
			return err
		}
	}
	return nil
}

type VByteList []byte

func (VByteList) __VDLReflect(struct {
	Name string `vdl:"v.io/v23/vom/internal.VByteList"`
}) {
}

func (x VByteList) VDLIsZero() bool {
	return len(x) == 0
}

func (x VByteList) VDLWrite(enc vdl.Encoder) error {
	if err := enc.WriteValueBytes(__VDLType_list_4, []byte(x)); err != nil {
		return err
	}
	return nil
}

func (x *VByteList) VDLRead(dec vdl.Decoder) error {
	var bytes []byte
	if err := dec.ReadValueBytes(-1, &bytes); err != nil {
		return err
	}
	*x = bytes
	return nil
}

type VByteArray [3]byte

func (VByteArray) __VDLReflect(struct {
	Name string `vdl:"v.io/v23/vom/internal.VByteArray"`
}) {
}

func (x VByteArray) VDLIsZero() bool {
	return x == VByteArray{}
}

func (x VByteArray) VDLWrite(enc vdl.Encoder) error {
	if err := enc.WriteValueBytes(__VDLType_array_5, x[:]); err != nil {
		return err
	}
	return nil
}

func (x *VByteArray) VDLRead(dec vdl.Decoder) error {
	bytes := x[:]
	if err := dec.ReadValueBytes(3, &bytes); err != nil {
		return err
	}
	return nil
}

type VArray [3]int32

func (VArray) __VDLReflect(struct {
	Name string `vdl:"v.io/v23/vom/internal.VArray"`
}) {
}

func (x VArray) VDLIsZero() bool {
	return x == VArray{}
}

func (x VArray) VDLWrite(enc vdl.Encoder) error {
	if err := enc.StartValue(__VDLType_array_6); err != nil {
		return err
	}
	for _, elem := range x {
		if err := enc.NextEntryValueInt(vdl.Int32Type, int64(elem)); err != nil {
			return err
		}
	}
	if err := enc.NextEntry(true); err != nil {
		return err
	}
	return enc.FinishValue()
}

func (x *VArray) VDLRead(dec vdl.Decoder) error {
	if err := dec.StartValue(__VDLType_array_6); err != nil {
		return err
	}
	for index := 0; index < 3; index++ {
		switch done, elem, err := dec.NextEntryValueInt(32); {
		case err != nil:
			return err
		case done:
			return fmt.Errorf("short array, got len %d < 3 %T)", index, *x)
		default:
			x[index] = int32(elem)
		}
	}
	switch done, err := dec.NextEntry(); {
	case err != nil:
		return err
	case !done:
		return fmt.Errorf("long array, got len > 3 %T", *x)
	}
	return dec.FinishValue()
}

type VList []int32

func (VList) __VDLReflect(struct {
	Name string `vdl:"v.io/v23/vom/internal.VList"`
}) {
}

func (x VList) VDLIsZero() bool {
	return len(x) == 0
}

func (x VList) VDLWrite(enc vdl.Encoder) error {
	if err := enc.StartValue(__VDLType_list_7); err != nil {
		return err
	}
	if err := enc.SetLenHint(len(x)); err != nil {
		return err
	}
	for _, elem := range x {
		if err := enc.NextEntryValueInt(vdl.Int32Type, int64(elem)); err != nil {
			return err
		}
	}
	if err := enc.NextEntry(true); err != nil {
		return err
	}
	return enc.FinishValue()
}

func (x *VList) VDLRead(dec vdl.Decoder) error {
	if err := dec.StartValue(__VDLType_list_7); err != nil {
		return err
	}
	if len := dec.LenHint(); len > 0 {
		*x = make(VList, 0, len)
	} else {
		*x = nil
	}
	for {
		switch done, elem, err := dec.NextEntryValueInt(32); {
		case err != nil:
			return err
		case done:
			return dec.FinishValue()
		default:
			*x = append(*x, int32(elem))
		}
	}
}

type VListAny []*vom.RawBytes

func (VListAny) __VDLReflect(struct {
	Name string `vdl:"v.io/v23/vom/internal.VListAny"`
}) {
}

func (x VListAny) VDLIsZero() bool {
	return len(x) == 0
}

func (x VListAny) VDLWrite(enc vdl.Encoder) error {
	if err := enc.StartValue(__VDLType_list_8); err != nil {
		return err
	}
	if err := enc.SetLenHint(len(x)); err != nil {
		return err
	}
	for _, elem := range x {
		if err := enc.NextEntry(false); err != nil {
			return err
		}
		if elem == nil {
			if err := enc.NilValue(vdl.AnyType); err != nil {
				return err
			}
		} else {
			if err := elem.VDLWrite(enc); err != nil {
				return err
			}
		}
	}
	if err := enc.NextEntry(true); err != nil {
		return err
	}
	return enc.FinishValue()
}

func (x *VListAny) VDLRead(dec vdl.Decoder) error {
	if err := dec.StartValue(__VDLType_list_8); err != nil {
		return err
	}
	if len := dec.LenHint(); len > 0 {
		*x = make(VListAny, 0, len)
	} else {
		*x = nil
	}
	for {
		switch done, err := dec.NextEntry(); {
		case err != nil:
			return err
		case done:
			return dec.FinishValue()
		default:
			var elem *vom.RawBytes
			elem = new(vom.RawBytes)
			if err := elem.VDLRead(dec); err != nil {
				return err
			}
			*x = append(*x, elem)
		}
	}
}

type VSet map[string]struct{}

func (VSet) __VDLReflect(struct {
	Name string `vdl:"v.io/v23/vom/internal.VSet"`
}) {
}

func (x VSet) VDLIsZero() bool {
	return len(x) == 0
}

func (x VSet) VDLWrite(enc vdl.Encoder) error {
	if err := enc.StartValue(__VDLType_set_9); err != nil {
		return err
	}
	if err := enc.SetLenHint(len(x)); err != nil {
		return err
	}
	for key := range x {
		if err := enc.NextEntryValueString(vdl.StringType, key); err != nil {
			return err
		}
	}
	if err := enc.NextEntry(true); err != nil {
		return err
	}
	return enc.FinishValue()
}

func (x *VSet) VDLRead(dec vdl.Decoder) error {
	if err := dec.StartValue(__VDLType_set_9); err != nil {
		return err
	}
	var tmpMap VSet
	if len := dec.LenHint(); len > 0 {
		tmpMap = make(VSet, len)
	}
	for {
		switch done, key, err := dec.NextEntryValueString(); {
		case err != nil:
			return err
		case done:
			*x = tmpMap
			return dec.FinishValue()
		default:
			if tmpMap == nil {
				tmpMap = make(VSet)
			}
			tmpMap[key] = struct{}{}
		}
	}
}

type VMap map[string]bool

func (VMap) __VDLReflect(struct {
	Name string `vdl:"v.io/v23/vom/internal.VMap"`
}) {
}

func (x VMap) VDLIsZero() bool {
	return len(x) == 0
}

func (x VMap) VDLWrite(enc vdl.Encoder) error {
	if err := enc.StartValue(__VDLType_map_10); err != nil {
		return err
	}
	if err := enc.SetLenHint(len(x)); err != nil {
		return err
	}
	for key, elem := range x {
		if err := enc.NextEntryValueString(vdl.StringType, key); err != nil {
			return err
		}
		if err := enc.WriteValueBool(vdl.BoolType, elem); err != nil {
			return err
		}
	}
	if err := enc.NextEntry(true); err != nil {
		return err
	}
	return enc.FinishValue()
}

func (x *VMap) VDLRead(dec vdl.Decoder) error {
	if err := dec.StartValue(__VDLType_map_10); err != nil {
		return err
	}
	var tmpMap VMap
	if len := dec.LenHint(); len > 0 {
		tmpMap = make(VMap, len)
	}
	for {
		switch done, key, err := dec.NextEntryValueString(); {
		case err != nil:
			return err
		case done:
			*x = tmpMap
			return dec.FinishValue()
		default:
			var elem bool
			switch value, err := dec.ReadValueBool(); {
			case err != nil:
				return err
			default:
				elem = value
			}
			if tmpMap == nil {
				tmpMap = make(VMap)
			}
			tmpMap[key] = elem
		}
	}
}

type VSmallStruct struct {
	A int32
	B string
	C bool
}

func (VSmallStruct) __VDLReflect(struct {
	Name string `vdl:"v.io/v23/vom/internal.VSmallStruct"`
}) {
}

func (x VSmallStruct) VDLIsZero() bool {
	return x == VSmallStruct{}
}

func (x VSmallStruct) VDLWrite(enc vdl.Encoder) error {
	if err := enc.StartValue(__VDLType_struct_11); err != nil {
		return err
	}
	if x.A != 0 {
		if err := enc.NextFieldValueInt("A", vdl.Int32Type, int64(x.A)); err != nil {
			return err
		}
	}
	if x.B != "" {
		if err := enc.NextFieldValueString("B", vdl.StringType, x.B); err != nil {
			return err
		}
	}
	if x.C {
		if err := enc.NextFieldValueBool("C", vdl.BoolType, x.C); err != nil {
			return err
		}
	}
	if err := enc.NextField(""); err != nil {
		return err
	}
	return enc.FinishValue()
}

func (x *VSmallStruct) VDLRead(dec vdl.Decoder) error {
	*x = VSmallStruct{}
	if err := dec.StartValue(__VDLType_struct_11); err != nil {
		return err
	}
	for {
		f, err := dec.NextField()
		if err != nil {
			return err
		}
		switch f {
		case "":
			return dec.FinishValue()
		case "A":
			switch value, err := dec.ReadValueInt(32); {
			case err != nil:
				return err
			default:
				x.A = int32(value)
			}
		case "B":
			switch value, err := dec.ReadValueString(); {
			case err != nil:
				return err
			default:
				x.B = value
			}
		case "C":
			switch value, err := dec.ReadValueBool(); {
			case err != nil:
				return err
			default:
				x.C = value
			}
		default:
			if err := dec.SkipValue(); err != nil {
				return err
			}
		}
	}
}

type VLargeStruct struct {
	F1  int32
	F2  int32
	F3  int32
	F4  int32
	F5  int32
	F6  int32
	F7  int32
	F8  int32
	F9  int32
	F10 int32
	F11 int32
	F12 int32
	F13 int32
	F14 int32
	F15 int32
	F16 int32
	F17 int32
	F18 int32
	F19 int32
	F20 int32
	F21 int32
	F22 int32
	F23 int32
	F24 int32
	F25 int32
	F26 int32
	F27 int32
	F28 int32
	F29 int32
	F30 int32
	F31 int32
	F32 int32
	F33 int32
	F34 int32
	F35 int32
	F36 int32
	F37 int32
	F38 int32
	F39 int32
	F40 int32
	F41 int32
	F42 int32
	F43 int32
	F44 int32
	F45 int32
	F46 int32
	F47 int32
	F48 int32
	F49 int32
	F50 int32
}

func (VLargeStruct) __VDLReflect(struct {
	Name string `vdl:"v.io/v23/vom/internal.VLargeStruct"`
}) {
}

func (x VLargeStruct) VDLIsZero() bool {
	return x == VLargeStruct{}
}

func (x VLargeStruct) VDLWrite(enc vdl.Encoder) error {
	if err := enc.StartValue(__VDLType_struct_12); err != nil {
		return err
	}
	if x.F1 != 0 {
		if err := enc.NextFieldValueInt("F1", vdl.Int32Type, int64(x.F1)); err != nil {
			return err
		}
	}
	if x.F2 != 0 {
		if err := enc.NextFieldValueInt("F2", vdl.Int32Type, int64(x.F2)); err != nil {
			return err
		}
	}
	if x.F3 != 0 {
		if err := enc.NextFieldValueInt("F3", vdl.Int32Type, int64(x.F3)); err != nil {
			return err
		}
	}
	if x.F4 != 0 {
		if err := enc.NextFieldValueInt("F4", vdl.Int32Type, int64(x.F4)); err != nil {
			return err
		}
	}
	if x.F5 != 0 {
		if err := enc.NextFieldValueInt("F5", vdl.Int32Type, int64(x.F5)); err != nil {
			return err
		}
	}
	if x.F6 != 0 {
		if err := enc.NextFieldValueInt("F6", vdl.Int32Type, int64(x.F6)); err != nil {
			return err
		}
	}
	if x.F7 != 0 {
		if err := enc.NextFieldValueInt("F7", vdl.Int32Type, int64(x.F7)); err != nil {
			return err
		}
	}
	if x.F8 != 0 {
		if err := enc.NextFieldValueInt("F8", vdl.Int32Type, int64(x.F8)); err != nil {
			return err
		}
	}
	if x.F9 != 0 {
		if err := enc.NextFieldValueInt("F9", vdl.Int32Type, int64(x.F9)); err != nil {
			return err
		}
	}
	if x.F10 != 0 {
		if err := enc.NextFieldValueInt("F10", vdl.Int32Type, int64(x.F10)); err != nil {
			return err
		}
	}
	if x.F11 != 0 {
		if err := enc.NextFieldValueInt("F11", vdl.Int32Type, int64(x.F11)); err != nil {
			return err
		}
	}
	if x.F12 != 0 {
		if err := enc.NextFieldValueInt("F12", vdl.Int32Type, int64(x.F12)); err != nil {
			return err
		}
	}
	if x.F13 != 0 {
		if err := enc.NextFieldValueInt("F13", vdl.Int32Type, int64(x.F13)); err != nil {
			return err
		}
	}
	if x.F14 != 0 {
		if err := enc.NextFieldValueInt("F14", vdl.Int32Type, int64(x.F14)); err != nil {
			return err
		}
	}
	if x.F15 != 0 {
		if err := enc.NextFieldValueInt("F15", vdl.Int32Type, int64(x.F15)); err != nil {
			return err
		}
	}
	if x.F16 != 0 {
		if err := enc.NextFieldValueInt("F16", vdl.Int32Type, int64(x.F16)); err != nil {
			return err
		}
	}
	if x.F17 != 0 {
		if err := enc.NextFieldValueInt("F17", vdl.Int32Type, int64(x.F17)); err != nil {
			return err
		}
	}
	if x.F18 != 0 {
		if err := enc.NextFieldValueInt("F18", vdl.Int32Type, int64(x.F18)); err != nil {
			return err
		}
	}
	if x.F19 != 0 {
		if err := enc.NextFieldValueInt("F19", vdl.Int32Type, int64(x.F19)); err != nil {
			return err
		}
	}
	if x.F20 != 0 {
		if err := enc.NextFieldValueInt("F20", vdl.Int32Type, int64(x.F20)); err != nil {
			return err
		}
	}
	if x.F21 != 0 {
		if err := enc.NextFieldValueInt("F21", vdl.Int32Type, int64(x.F21)); err != nil {
			return err
		}
	}
	if x.F22 != 0 {
		if err := enc.NextFieldValueInt("F22", vdl.Int32Type, int64(x.F22)); err != nil {
			return err
		}
	}
	if x.F23 != 0 {
		if err := enc.NextFieldValueInt("F23", vdl.Int32Type, int64(x.F23)); err != nil {
			return err
		}
	}
	if x.F24 != 0 {
		if err := enc.NextFieldValueInt("F24", vdl.Int32Type, int64(x.F24)); err != nil {
			return err
		}
	}
	if x.F25 != 0 {
		if err := enc.NextFieldValueInt("F25", vdl.Int32Type, int64(x.F25)); err != nil {
			return err
		}
	}
	if x.F26 != 0 {
		if err := enc.NextFieldValueInt("F26", vdl.Int32Type, int64(x.F26)); err != nil {
			return err
		}
	}
	if x.F27 != 0 {
		if err := enc.NextFieldValueInt("F27", vdl.Int32Type, int64(x.F27)); err != nil {
			return err
		}
	}
	if x.F28 != 0 {
		if err := enc.NextFieldValueInt("F28", vdl.Int32Type, int64(x.F28)); err != nil {
			return err
		}
	}
	if x.F29 != 0 {
		if err := enc.NextFieldValueInt("F29", vdl.Int32Type, int64(x.F29)); err != nil {
			return err
		}
	}
	if x.F30 != 0 {
		if err := enc.NextFieldValueInt("F30", vdl.Int32Type, int64(x.F30)); err != nil {
			return err
		}
	}
	if x.F31 != 0 {
		if err := enc.NextFieldValueInt("F31", vdl.Int32Type, int64(x.F31)); err != nil {
			return err
		}
	}
	if x.F32 != 0 {
		if err := enc.NextFieldValueInt("F32", vdl.Int32Type, int64(x.F32)); err != nil {
			return err
		}
	}
	if x.F33 != 0 {
		if err := enc.NextFieldValueInt("F33", vdl.Int32Type, int64(x.F33)); err != nil {
			return err
		}
	}
	if x.F34 != 0 {
		if err := enc.NextFieldValueInt("F34", vdl.Int32Type, int64(x.F34)); err != nil {
			return err
		}
	}
	if x.F35 != 0 {
		if err := enc.NextFieldValueInt("F35", vdl.Int32Type, int64(x.F35)); err != nil {
			return err
		}
	}
	if x.F36 != 0 {
		if err := enc.NextFieldValueInt("F36", vdl.Int32Type, int64(x.F36)); err != nil {
			return err
		}
	}
	if x.F37 != 0 {
		if err := enc.NextFieldValueInt("F37", vdl.Int32Type, int64(x.F37)); err != nil {
			return err
		}
	}
	if x.F38 != 0 {
		if err := enc.NextFieldValueInt("F38", vdl.Int32Type, int64(x.F38)); err != nil {
			return err
		}
	}
	if x.F39 != 0 {
		if err := enc.NextFieldValueInt("F39", vdl.Int32Type, int64(x.F39)); err != nil {
			return err
		}
	}
	if x.F40 != 0 {
		if err := enc.NextFieldValueInt("F40", vdl.Int32Type, int64(x.F40)); err != nil {
			return err
		}
	}
	if x.F41 != 0 {
		if err := enc.NextFieldValueInt("F41", vdl.Int32Type, int64(x.F41)); err != nil {
			return err
		}
	}
	if x.F42 != 0 {
		if err := enc.NextFieldValueInt("F42", vdl.Int32Type, int64(x.F42)); err != nil {
			return err
		}
	}
	if x.F43 != 0 {
		if err := enc.NextFieldValueInt("F43", vdl.Int32Type, int64(x.F43)); err != nil {
			return err
		}
	}
	if x.F44 != 0 {
		if err := enc.NextFieldValueInt("F44", vdl.Int32Type, int64(x.F44)); err != nil {
			return err
		}
	}
	if x.F45 != 0 {
		if err := enc.NextFieldValueInt("F45", vdl.Int32Type, int64(x.F45)); err != nil {
			return err
		}
	}
	if x.F46 != 0 {
		if err := enc.NextFieldValueInt("F46", vdl.Int32Type, int64(x.F46)); err != nil {
			return err
		}
	}
	if x.F47 != 0 {
		if err := enc.NextFieldValueInt("F47", vdl.Int32Type, int64(x.F47)); err != nil {
			return err
		}
	}
	if x.F48 != 0 {
		if err := enc.NextFieldValueInt("F48", vdl.Int32Type, int64(x.F48)); err != nil {
			return err
		}
	}
	if x.F49 != 0 {
		if err := enc.NextFieldValueInt("F49", vdl.Int32Type, int64(x.F49)); err != nil {
			return err
		}
	}
	if x.F50 != 0 {
		if err := enc.NextFieldValueInt("F50", vdl.Int32Type, int64(x.F50)); err != nil {
			return err
		}
	}
	if err := enc.NextField(""); err != nil {
		return err
	}
	return enc.FinishValue()
}

func (x *VLargeStruct) VDLRead(dec vdl.Decoder) error {
	*x = VLargeStruct{}
	if err := dec.StartValue(__VDLType_struct_12); err != nil {
		return err
	}
	for {
		f, err := dec.NextField()
		if err != nil {
			return err
		}
		switch f {
		case "":
			return dec.FinishValue()
		case "F1":
			switch value, err := dec.ReadValueInt(32); {
			case err != nil:
				return err
			default:
				x.F1 = int32(value)
			}
		case "F2":
			switch value, err := dec.ReadValueInt(32); {
			case err != nil:
				return err
			default:
				x.F2 = int32(value)
			}
		case "F3":
			switch value, err := dec.ReadValueInt(32); {
			case err != nil:
				return err
			default:
				x.F3 = int32(value)
			}
		case "F4":
			switch value, err := dec.ReadValueInt(32); {
			case err != nil:
				return err
			default:
				x.F4 = int32(value)
			}
		case "F5":
			switch value, err := dec.ReadValueInt(32); {
			case err != nil:
				return err
			default:
				x.F5 = int32(value)
			}
		case "F6":
			switch value, err := dec.ReadValueInt(32); {
			case err != nil:
				return err
			default:
				x.F6 = int32(value)
			}
		case "F7":
			switch value, err := dec.ReadValueInt(32); {
			case err != nil:
				return err
			default:
				x.F7 = int32(value)
			}
		case "F8":
			switch value, err := dec.ReadValueInt(32); {
			case err != nil:
				return err
			default:
				x.F8 = int32(value)
			}
		case "F9":
			switch value, err := dec.ReadValueInt(32); {
			case err != nil:
				return err
			default:
				x.F9 = int32(value)
			}
		case "F10":
			switch value, err := dec.ReadValueInt(32); {
			case err != nil:
				return err
			default:
				x.F10 = int32(value)
			}
		case "F11":
			switch value, err := dec.ReadValueInt(32); {
			case err != nil:
				return err
			default:
				x.F11 = int32(value)
			}
		case "F12":
			switch value, err := dec.ReadValueInt(32); {
			case err != nil:
				return err
			default:
				x.F12 = int32(value)
			}
		case "F13":
			switch value, err := dec.ReadValueInt(32); {
			case err != nil:
				return err
			default:
				x.F13 = int32(value)
			}
		case "F14":
			switch value, err := dec.ReadValueInt(32); {
			case err != nil:
				return err
			default:
				x.F14 = int32(value)
			}
		case "F15":
			switch value, err := dec.ReadValueInt(32); {
			case err != nil:
				return err
			default:
				x.F15 = int32(value)
			}
		case "F16":
			switch value, err := dec.ReadValueInt(32); {
			case err != nil:
				return err
			default:
				x.F16 = int32(value)
			}
		case "F17":
			switch value, err := dec.ReadValueInt(32); {
			case err != nil:
				return err
			default:
				x.F17 = int32(value)
			}
		case "F18":
			switch value, err := dec.ReadValueInt(32); {
			case err != nil:
				return err
			default:
				x.F18 = int32(value)
			}
		case "F19":
			switch value, err := dec.ReadValueInt(32); {
			case err != nil:
				return err
			default:
				x.F19 = int32(value)
			}
		case "F20":
			switch value, err := dec.ReadValueInt(32); {
			case err != nil:
				return err
			default:
				x.F20 = int32(value)
			}
		case "F21":
			switch value, err := dec.ReadValueInt(32); {
			case err != nil:
				return err
			default:
				x.F21 = int32(value)
			}
		case "F22":
			switch value, err := dec.ReadValueInt(32); {
			case err != nil:
				return err
			default:
				x.F22 = int32(value)
			}
		case "F23":
			switch value, err := dec.ReadValueInt(32); {
			case err != nil:
				return err
			default:
				x.F23 = int32(value)
			}
		case "F24":
			switch value, err := dec.ReadValueInt(32); {
			case err != nil:
				return err
			default:
				x.F24 = int32(value)
			}
		case "F25":
			switch value, err := dec.ReadValueInt(32); {
			case err != nil:
				return err
			default:
				x.F25 = int32(value)
			}
		case "F26":
			switch value, err := dec.ReadValueInt(32); {
			case err != nil:
				return err
			default:
				x.F26 = int32(value)
			}
		case "F27":
			switch value, err := dec.ReadValueInt(32); {
			case err != nil:
				return err
			default:
				x.F27 = int32(value)
			}
		case "F28":
			switch value, err := dec.ReadValueInt(32); {
			case err != nil:
				return err
			default:
				x.F28 = int32(value)
			}
		case "F29":
			switch value, err := dec.ReadValueInt(32); {
			case err != nil:
				return err
			default:
				x.F29 = int32(value)
			}
		case "F30":
			switch value, err := dec.ReadValueInt(32); {
			case err != nil:
				return err
			default:
				x.F30 = int32(value)
			}
		case "F31":
			switch value, err := dec.ReadValueInt(32); {
			case err != nil:
				return err
			default:
				x.F31 = int32(value)
			}
		case "F32":
			switch value, err := dec.ReadValueInt(32); {
			case err != nil:
				return err
			default:
				x.F32 = int32(value)
			}
		case "F33":
			switch value, err := dec.ReadValueInt(32); {
			case err != nil:
				return err
			default:
				x.F33 = int32(value)
			}
		case "F34":
			switch value, err := dec.ReadValueInt(32); {
			case err != nil:
				return err
			default:
				x.F34 = int32(value)
			}
		case "F35":
			switch value, err := dec.ReadValueInt(32); {
			case err != nil:
				return err
			default:
				x.F35 = int32(value)
			}
		case "F36":
			switch value, err := dec.ReadValueInt(32); {
			case err != nil:
				return err
			default:
				x.F36 = int32(value)
			}
		case "F37":
			switch value, err := dec.ReadValueInt(32); {
			case err != nil:
				return err
			default:
				x.F37 = int32(value)
			}
		case "F38":
			switch value, err := dec.ReadValueInt(32); {
			case err != nil:
				return err
			default:
				x.F38 = int32(value)
			}
		case "F39":
			switch value, err := dec.ReadValueInt(32); {
			case err != nil:
				return err
			default:
				x.F39 = int32(value)
			}
		case "F40":
			switch value, err := dec.ReadValueInt(32); {
			case err != nil:
				return err
			default:
				x.F40 = int32(value)
			}
		case "F41":
			switch value, err := dec.ReadValueInt(32); {
			case err != nil:
				return err
			default:
				x.F41 = int32(value)
			}
		case "F42":
			switch value, err := dec.ReadValueInt(32); {
			case err != nil:
				return err
			default:
				x.F42 = int32(value)
			}
		case "F43":
			switch value, err := dec.ReadValueInt(32); {
			case err != nil:
				return err
			default:
				x.F43 = int32(value)
			}
		case "F44":
			switch value, err := dec.ReadValueInt(32); {
			case err != nil:
				return err
			default:
				x.F44 = int32(value)
			}
		case "F45":
			switch value, err := dec.ReadValueInt(32); {
			case err != nil:
				return err
			default:
				x.F45 = int32(value)
			}
		case "F46":
			switch value, err := dec.ReadValueInt(32); {
			case err != nil:
				return err
			default:
				x.F46 = int32(value)
			}
		case "F47":
			switch value, err := dec.ReadValueInt(32); {
			case err != nil:
				return err
			default:
				x.F47 = int32(value)
			}
		case "F48":
			switch value, err := dec.ReadValueInt(32); {
			case err != nil:
				return err
			default:
				x.F48 = int32(value)
			}
		case "F49":
			switch value, err := dec.ReadValueInt(32); {
			case err != nil:
				return err
			default:
				x.F49 = int32(value)
			}
		case "F50":
			switch value, err := dec.ReadValueInt(32); {
			case err != nil:
				return err
			default:
				x.F50 = int32(value)
			}
		default:
			if err := dec.SkipValue(); err != nil {
				return err
			}
		}
	}
}

type (
	// VSmallUnion represents any single field of the VSmallUnion union type.
	VSmallUnion interface {
		// Index returns the field index.
		Index() int
		// Interface returns the field value as an interface.
		Interface() interface{}
		// Name returns the field name.
		Name() string
		// __VDLReflect describes the VSmallUnion union type.
		__VDLReflect(__VSmallUnionReflect)
		VDLIsZero() bool
		VDLWrite(vdl.Encoder) error
	}
	// VSmallUnionA represents field A of the VSmallUnion union type.
	VSmallUnionA struct{ Value int32 }
	// VSmallUnionB represents field B of the VSmallUnion union type.
	VSmallUnionB struct{ Value string }
	// VSmallUnionC represents field C of the VSmallUnion union type.
	VSmallUnionC struct{ Value bool }
	// __VSmallUnionReflect describes the VSmallUnion union type.
	__VSmallUnionReflect struct {
		Name  string `vdl:"v.io/v23/vom/internal.VSmallUnion"`
		Type  VSmallUnion
		Union struct {
			A VSmallUnionA
			B VSmallUnionB
			C VSmallUnionC
		}
	}
)

func (x VSmallUnionA) Index() int                        { return 0 }
func (x VSmallUnionA) Interface() interface{}            { return x.Value }
func (x VSmallUnionA) Name() string                      { return "A" }
func (x VSmallUnionA) __VDLReflect(__VSmallUnionReflect) {}

func (x VSmallUnionB) Index() int                        { return 1 }
func (x VSmallUnionB) Interface() interface{}            { return x.Value }
func (x VSmallUnionB) Name() string                      { return "B" }
func (x VSmallUnionB) __VDLReflect(__VSmallUnionReflect) {}

func (x VSmallUnionC) Index() int                        { return 2 }
func (x VSmallUnionC) Interface() interface{}            { return x.Value }
func (x VSmallUnionC) Name() string                      { return "C" }
func (x VSmallUnionC) __VDLReflect(__VSmallUnionReflect) {}

func (x VSmallUnionA) VDLIsZero() bool {
	return x.Value == 0
}

func (x VSmallUnionB) VDLIsZero() bool {
	return false
}

func (x VSmallUnionC) VDLIsZero() bool {
	return false
}

func (x VSmallUnionA) VDLWrite(enc vdl.Encoder) error {
	if err := enc.StartValue(__VDLType_union_13); err != nil {
		return err
	}
	if err := enc.NextFieldValueInt("A", vdl.Int32Type, int64(x.Value)); err != nil {
		return err
	}
	if err := enc.NextField(""); err != nil {
		return err
	}
	return enc.FinishValue()
}

func (x VSmallUnionB) VDLWrite(enc vdl.Encoder) error {
	if err := enc.StartValue(__VDLType_union_13); err != nil {
		return err
	}
	if err := enc.NextFieldValueString("B", vdl.StringType, x.Value); err != nil {
		return err
	}
	if err := enc.NextField(""); err != nil {
		return err
	}
	return enc.FinishValue()
}

func (x VSmallUnionC) VDLWrite(enc vdl.Encoder) error {
	if err := enc.StartValue(__VDLType_union_13); err != nil {
		return err
	}
	if err := enc.NextFieldValueBool("C", vdl.BoolType, x.Value); err != nil {
		return err
	}
	if err := enc.NextField(""); err != nil {
		return err
	}
	return enc.FinishValue()
}

func VDLReadVSmallUnion(dec vdl.Decoder, x *VSmallUnion) error {
	if err := dec.StartValue(__VDLType_union_13); err != nil {
		return err
	}
	f, err := dec.NextField()
	if err != nil {
		return err
	}
	switch f {
	case "A":
		var field VSmallUnionA
		switch value, err := dec.ReadValueInt(32); {
		case err != nil:
			return err
		default:
			field.Value = int32(value)
		}
		*x = field
	case "B":
		var field VSmallUnionB
		switch value, err := dec.ReadValueString(); {
		case err != nil:
			return err
		default:
			field.Value = value
		}
		*x = field
	case "C":
		var field VSmallUnionC
		switch value, err := dec.ReadValueBool(); {
		case err != nil:
			return err
		default:
			field.Value = value
		}
		*x = field
	case "":
		return fmt.Errorf("missing field in union %T, from %v", x, dec.Type())
	default:
		return fmt.Errorf("field %q not in union %T, from %v", f, x, dec.Type())
	}
	switch f, err := dec.NextField(); {
	case err != nil:
		return err
	case f != "":
		return fmt.Errorf("extra field %q in union %T, from %v", f, x, dec.Type())
	}
	return dec.FinishValue()
}

// Hold type definitions in package-level variables, for better performance.
var (
	__VDLType_int32_1   *vdl.Type
	__VDLType_string_2  *vdl.Type
	__VDLType_enum_3    *vdl.Type
	__VDLType_list_4    *vdl.Type
	__VDLType_array_5   *vdl.Type
	__VDLType_array_6   *vdl.Type
	__VDLType_list_7    *vdl.Type
	__VDLType_list_8    *vdl.Type
	__VDLType_set_9     *vdl.Type
	__VDLType_map_10    *vdl.Type
	__VDLType_struct_11 *vdl.Type
	__VDLType_struct_12 *vdl.Type
	__VDLType_union_13  *vdl.Type
)

var __VDLInitCalled bool

// __VDLInit performs vdl initialization.  It is safe to call multiple times.
// If you have an init ordering issue, just insert the following line verbatim
// into your source files in this package, right after the "package foo" clause:
//
//    var _ = __VDLInit()
//
// The purpose of this function is to ensure that vdl initialization occurs in
// the right order, and very early in the init sequence.  In particular, vdl
// registration and package variable initialization needs to occur before
// functions like vdl.TypeOf will work properly.
//
// This function returns a dummy value, so that it can be used to initialize the
// first var in the file, to take advantage of Go's defined init order.
func __VDLInit() struct{} {
	if __VDLInitCalled {
		return struct{}{}
	}
	__VDLInitCalled = true

	// Register types.
	vdl.Register((*VNumber)(nil))
	vdl.Register((*VString)(nil))
	vdl.Register((*VEnum)(nil))
	vdl.Register((*VByteList)(nil))
	vdl.Register((*VByteArray)(nil))
	vdl.Register((*VArray)(nil))
	vdl.Register((*VList)(nil))
	vdl.Register((*VListAny)(nil))
	vdl.Register((*VSet)(nil))
	vdl.Register((*VMap)(nil))
	vdl.Register((*VSmallStruct)(nil))
	vdl.Register((*VLargeStruct)(nil))
	vdl.Register((*VSmallUnion)(nil))

	// Initialize type definitions.
	__VDLType_int32_1 = vdl.TypeOf((*VNumber)(nil))
	__VDLType_string_2 = vdl.TypeOf((*VString)(nil))
	__VDLType_enum_3 = vdl.TypeOf((*VEnum)(nil))
	__VDLType_list_4 = vdl.TypeOf((*VByteList)(nil))
	__VDLType_array_5 = vdl.TypeOf((*VByteArray)(nil))
	__VDLType_array_6 = vdl.TypeOf((*VArray)(nil))
	__VDLType_list_7 = vdl.TypeOf((*VList)(nil))
	__VDLType_list_8 = vdl.TypeOf((*VListAny)(nil))
	__VDLType_set_9 = vdl.TypeOf((*VSet)(nil))
	__VDLType_map_10 = vdl.TypeOf((*VMap)(nil))
	__VDLType_struct_11 = vdl.TypeOf((*VSmallStruct)(nil)).Elem()
	__VDLType_struct_12 = vdl.TypeOf((*VLargeStruct)(nil)).Elem()
	__VDLType_union_13 = vdl.TypeOf((*VSmallUnion)(nil))

	return struct{}{}
}