yang.go

/*
Package arista is a generated package which contains definitions
of structs which represent a YANG schema. The generated schema can be
compressed by a series of transformations (compression was false
in this case).

This package was generated by /Users/mk/go/pkg/mod/github.com/openconfig/ygot@v0.10.0/genutil/names.go
using the following YANG input files:
	- ../../models/arista/EOS-4.24.2F/openconfig/public/release/models/interfaces/openconfig-interfaces.yang
Imported modules were sourced from:
	- ../../models/arista/EOS-4.24.2F/...
	- ../../models/openconfig/...
*/
package arista

import (
	"encoding/json"
	"fmt"
	"reflect"

	"github.com/openconfig/goyang/pkg/yang"
	"github.com/openconfig/ygot/ygot"
	"github.com/openconfig/ygot/ytypes"
)

// Binary is a type that is used for fields that have a YANG type of
// binary. It is used such that binary fields can be distinguished from
// leaf-lists of uint8s (which are mapped to []uint8, equivalent to
// []byte in reflection).
type Binary []byte

// YANGEmpty is a type that is used for fields that have a YANG type of
// empty. It is used such that empty fields can be distinguished from boolean fields
// in the generated code.
type YANGEmpty bool

var (
	SchemaTree map[string]*yang.Entry
)

func init() {
	var err error
	if SchemaTree, err = UnzipSchema(); err != nil {
		panic("schema error: " + err.Error())
	}
}

// Schema returns the details of the generated schema.
func Schema() (*ytypes.Schema, error) {
	uzp, err := UnzipSchema()
	if err != nil {
		return nil, fmt.Errorf("cannot unzip schema, %v", err)
	}

	return &ytypes.Schema{
		Root:       &Device{},
		SchemaTree: uzp,
		Unmarshal:  Unmarshal,
	}, nil
}

// UnzipSchema unzips the zipped schema and returns a map of yang.Entry nodes,
// keyed by the name of the struct that the yang.Entry describes the schema for.
func UnzipSchema() (map[string]*yang.Entry, error) {
	var schemaTree map[string]*yang.Entry
	var err error
	if schemaTree, err = ygot.GzipToSchema(ySchema); err != nil {
		return nil, fmt.Errorf("could not unzip the schema; %v", err)
	}
	return schemaTree, nil
}

// Unmarshal unmarshals data, which must be RFC7951 JSON format, into
// destStruct, which must be non-nil and the correct GoStruct type. It returns
// an error if the destStruct is not found in the schema or the data cannot be
// unmarshaled. The supplied options (opts) are used to control the behaviour
// of the unmarshal function - for example, determining whether errors are
// thrown for unknown fields in the input JSON.
func Unmarshal(data []byte, destStruct ygot.GoStruct, opts ...ytypes.UnmarshalOpt) error {
	tn := reflect.TypeOf(destStruct).Elem().Name()
	schema, ok := SchemaTree[tn]
	if !ok {
		return fmt.Errorf("could not find schema for type %s", tn)
	}
	var jsonTree interface{}
	if err := json.Unmarshal([]byte(data), &jsonTree); err != nil {
		return err
	}
	return ytypes.Unmarshal(schema, destStruct, jsonTree, opts...)
}

// Device represents the /device YANG schema element.
type Device struct {
	Interfaces *OpenconfigInterfaces_Interfaces `path:"interfaces" module:"openconfig-interfaces"`
}

// IsYANGGoStruct ensures that Device implements the yang.GoStruct
// interface. This allows functions that need to handle this struct to
// identify it as being generated by ygen.
func (*Device) IsYANGGoStruct() {}

// Validate validates s against the YANG schema corresponding to its type.
func (t *Device) Validate(opts ...ygot.ValidationOption) error {
	if err := ytypes.Validate(SchemaTree["Device"], t, opts...); err != nil {
		return err
	}
	return nil
}

// ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types
// that are included in the generated code.
func (t *Device) ΛEnumTypeMap() map[string][]reflect.Type { return ΛEnumTypes }

// OpenconfigInterfaces_Interfaces represents the /openconfig-interfaces/interfaces YANG schema element.
type OpenconfigInterfaces_Interfaces struct {
	Interface map[string]*OpenconfigInterfaces_Interfaces_Interface `path:"interface" module:"openconfig-interfaces"`
}

// IsYANGGoStruct ensures that OpenconfigInterfaces_Interfaces implements the yang.GoStruct
// interface. This allows functions that need to handle this struct to
// identify it as being generated by ygen.
func (*OpenconfigInterfaces_Interfaces) IsYANGGoStruct() {}

// NewInterface creates a new entry in the Interface list of the
// OpenconfigInterfaces_Interfaces struct. The keys of the list are populated from the input
// arguments.
func (t *OpenconfigInterfaces_Interfaces) NewInterface(Name string) (*OpenconfigInterfaces_Interfaces_Interface, error) {

	// Initialise the list within the receiver struct if it has not already been
	// created.
	if t.Interface == nil {
		t.Interface = make(map[string]*OpenconfigInterfaces_Interfaces_Interface)
	}

	key := Name

	// Ensure that this key has not already been used in the
	// list. Keyed YANG lists do not allow duplicate keys to
	// be created.
	if _, ok := t.Interface[key]; ok {
		return nil, fmt.Errorf("duplicate key %v for list Interface", key)
	}

	t.Interface[key] = &OpenconfigInterfaces_Interfaces_Interface{
		Name: &Name,
	}

	return t.Interface[key], nil
}

// Validate validates s against the YANG schema corresponding to its type.
func (t *OpenconfigInterfaces_Interfaces) Validate(opts ...ygot.ValidationOption) error {
	if err := ytypes.Validate(SchemaTree["OpenconfigInterfaces_Interfaces"], t, opts...); err != nil {
		return err
	}
	return nil
}

// ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types
// that are included in the generated code.
func (t *OpenconfigInterfaces_Interfaces) ΛEnumTypeMap() map[string][]reflect.Type {
	return ΛEnumTypes
}

// OpenconfigInterfaces_Interfaces_Interface represents the /openconfig-interfaces/interfaces/interface YANG schema element.
type OpenconfigInterfaces_Interfaces_Interface struct {
	Config        *OpenconfigInterfaces_Interfaces_Interface_Config        `path:"config" module:"openconfig-interfaces"`
	HoldTime      *OpenconfigInterfaces_Interfaces_Interface_HoldTime      `path:"hold-time" module:"openconfig-interfaces"`
	Name          *string                                                  `path:"name" module:"openconfig-interfaces"`
	State         *OpenconfigInterfaces_Interfaces_Interface_State         `path:"state" module:"openconfig-interfaces"`
	Subinterfaces *OpenconfigInterfaces_Interfaces_Interface_Subinterfaces `path:"subinterfaces" module:"openconfig-interfaces"`
}

// IsYANGGoStruct ensures that OpenconfigInterfaces_Interfaces_Interface implements the yang.GoStruct
// interface. This allows functions that need to handle this struct to
// identify it as being generated by ygen.
func (*OpenconfigInterfaces_Interfaces_Interface) IsYANGGoStruct() {}

// ΛListKeyMap returns the keys of the OpenconfigInterfaces_Interfaces_Interface struct, which is a YANG list entry.
func (t *OpenconfigInterfaces_Interfaces_Interface) ΛListKeyMap() (map[string]interface{}, error) {
	if t.Name == nil {
		return nil, fmt.Errorf("nil value for key Name")
	}

	return map[string]interface{}{
		"name": *t.Name,
	}, nil
}

// Validate validates s against the YANG schema corresponding to its type.
func (t *OpenconfigInterfaces_Interfaces_Interface) Validate(opts ...ygot.ValidationOption) error {
	if err := ytypes.Validate(SchemaTree["OpenconfigInterfaces_Interfaces_Interface"], t, opts...); err != nil {
		return err
	}
	return nil
}

// ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types
// that are included in the generated code.
func (t *OpenconfigInterfaces_Interfaces_Interface) ΛEnumTypeMap() map[string][]reflect.Type {
	return ΛEnumTypes
}

// OpenconfigInterfaces_Interfaces_Interface_Config represents the /openconfig-interfaces/interfaces/interface/config YANG schema element.
type OpenconfigInterfaces_Interfaces_Interface_Config struct {
	Description  *string                        `path:"description" module:"openconfig-interfaces"`
	Enabled      *bool                          `path:"enabled" module:"openconfig-interfaces"`
	LoopbackMode *bool                          `path:"loopback-mode" module:"openconfig-interfaces"`
	Mtu          *uint16                        `path:"mtu" module:"openconfig-interfaces"`
	Name         *string                        `path:"name" module:"openconfig-interfaces"`
	Type         E_IETFInterfaces_InterfaceType `path:"type" module:"openconfig-interfaces"`
}

// IsYANGGoStruct ensures that OpenconfigInterfaces_Interfaces_Interface_Config implements the yang.GoStruct
// interface. This allows functions that need to handle this struct to
// identify it as being generated by ygen.
func (*OpenconfigInterfaces_Interfaces_Interface_Config) IsYANGGoStruct() {}

// Validate validates s against the YANG schema corresponding to its type.
func (t *OpenconfigInterfaces_Interfaces_Interface_Config) Validate(opts ...ygot.ValidationOption) error {
	if err := ytypes.Validate(SchemaTree["OpenconfigInterfaces_Interfaces_Interface_Config"], t, opts...); err != nil {
		return err
	}
	return nil
}

// ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types
// that are included in the generated code.
func (t *OpenconfigInterfaces_Interfaces_Interface_Config) ΛEnumTypeMap() map[string][]reflect.Type {
	return ΛEnumTypes
}

// OpenconfigInterfaces_Interfaces_Interface_HoldTime represents the /openconfig-interfaces/interfaces/interface/hold-time YANG schema element.
type OpenconfigInterfaces_Interfaces_Interface_HoldTime struct {
	Config *OpenconfigInterfaces_Interfaces_Interface_HoldTime_Config `path:"config" module:"openconfig-interfaces"`
	State  *OpenconfigInterfaces_Interfaces_Interface_HoldTime_State  `path:"state" module:"openconfig-interfaces"`
}

// IsYANGGoStruct ensures that OpenconfigInterfaces_Interfaces_Interface_HoldTime implements the yang.GoStruct
// interface. This allows functions that need to handle this struct to
// identify it as being generated by ygen.
func (*OpenconfigInterfaces_Interfaces_Interface_HoldTime) IsYANGGoStruct() {}

// Validate validates s against the YANG schema corresponding to its type.
func (t *OpenconfigInterfaces_Interfaces_Interface_HoldTime) Validate(opts ...ygot.ValidationOption) error {
	if err := ytypes.Validate(SchemaTree["OpenconfigInterfaces_Interfaces_Interface_HoldTime"], t, opts...); err != nil {
		return err
	}
	return nil
}

// ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types
// that are included in the generated code.
func (t *OpenconfigInterfaces_Interfaces_Interface_HoldTime) ΛEnumTypeMap() map[string][]reflect.Type {
	return ΛEnumTypes
}

// OpenconfigInterfaces_Interfaces_Interface_HoldTime_Config represents the /openconfig-interfaces/interfaces/interface/hold-time/config YANG schema element.
type OpenconfigInterfaces_Interfaces_Interface_HoldTime_Config struct {
	Down *uint32 `path:"down" module:"openconfig-interfaces"`
	Up   *uint32 `path:"up" module:"openconfig-interfaces"`
}

// IsYANGGoStruct ensures that OpenconfigInterfaces_Interfaces_Interface_HoldTime_Config implements the yang.GoStruct
// interface. This allows functions that need to handle this struct to
// identify it as being generated by ygen.
func (*OpenconfigInterfaces_Interfaces_Interface_HoldTime_Config) IsYANGGoStruct() {}

// Validate validates s against the YANG schema corresponding to its type.
func (t *OpenconfigInterfaces_Interfaces_Interface_HoldTime_Config) Validate(opts ...ygot.ValidationOption) error {
	if err := ytypes.Validate(SchemaTree["OpenconfigInterfaces_Interfaces_Interface_HoldTime_Config"], t, opts...); err != nil {
		return err
	}
	return nil
}

// ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types
// that are included in the generated code.
func (t *OpenconfigInterfaces_Interfaces_Interface_HoldTime_Config) ΛEnumTypeMap() map[string][]reflect.Type {
	return ΛEnumTypes
}

// OpenconfigInterfaces_Interfaces_Interface_HoldTime_State represents the /openconfig-interfaces/interfaces/interface/hold-time/state YANG schema element.
type OpenconfigInterfaces_Interfaces_Interface_HoldTime_State struct {
	Down *uint32 `path:"down" module:"openconfig-interfaces"`
	Up   *uint32 `path:"up" module:"openconfig-interfaces"`
}

// IsYANGGoStruct ensures that OpenconfigInterfaces_Interfaces_Interface_HoldTime_State implements the yang.GoStruct
// interface. This allows functions that need to handle this struct to
// identify it as being generated by ygen.
func (*OpenconfigInterfaces_Interfaces_Interface_HoldTime_State) IsYANGGoStruct() {}

// Validate validates s against the YANG schema corresponding to its type.
func (t *OpenconfigInterfaces_Interfaces_Interface_HoldTime_State) Validate(opts ...ygot.ValidationOption) error {
	if err := ytypes.Validate(SchemaTree["OpenconfigInterfaces_Interfaces_Interface_HoldTime_State"], t, opts...); err != nil {
		return err
	}
	return nil
}

// ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types
// that are included in the generated code.
func (t *OpenconfigInterfaces_Interfaces_Interface_HoldTime_State) ΛEnumTypeMap() map[string][]reflect.Type {
	return ΛEnumTypes
}

// OpenconfigInterfaces_Interfaces_Interface_State represents the /openconfig-interfaces/interfaces/interface/state YANG schema element.
type OpenconfigInterfaces_Interfaces_Interface_State struct {
	AdminStatus  E_OpenconfigInterfaces_Interfaces_Interface_State_AdminStatus `path:"admin-status" module:"openconfig-interfaces"`
	Counters     *OpenconfigInterfaces_Interfaces_Interface_State_Counters     `path:"counters" module:"openconfig-interfaces"`
	Description  *string                                                       `path:"description" module:"openconfig-interfaces"`
	Enabled      *bool                                                         `path:"enabled" module:"openconfig-interfaces"`
	Ifindex      *uint32                                                       `path:"ifindex" module:"openconfig-interfaces"`
	LastChange   *uint64                                                       `path:"last-change" module:"openconfig-interfaces"`
	Logical      *bool                                                         `path:"logical" module:"openconfig-interfaces"`
	LoopbackMode *bool                                                         `path:"loopback-mode" module:"openconfig-interfaces"`
	Mtu          *uint16                                                       `path:"mtu" module:"openconfig-interfaces"`
	Name         *string                                                       `path:"name" module:"openconfig-interfaces"`
	OperStatus   E_OpenconfigInterfaces_Interfaces_Interface_State_OperStatus  `path:"oper-status" module:"openconfig-interfaces"`
	Type         E_IETFInterfaces_InterfaceType                                `path:"type" module:"openconfig-interfaces"`
}

// IsYANGGoStruct ensures that OpenconfigInterfaces_Interfaces_Interface_State implements the yang.GoStruct
// interface. This allows functions that need to handle this struct to
// identify it as being generated by ygen.
func (*OpenconfigInterfaces_Interfaces_Interface_State) IsYANGGoStruct() {}

// Validate validates s against the YANG schema corresponding to its type.
func (t *OpenconfigInterfaces_Interfaces_Interface_State) Validate(opts ...ygot.ValidationOption) error {
	if err := ytypes.Validate(SchemaTree["OpenconfigInterfaces_Interfaces_Interface_State"], t, opts...); err != nil {
		return err
	}
	return nil
}

// ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types
// that are included in the generated code.
func (t *OpenconfigInterfaces_Interfaces_Interface_State) ΛEnumTypeMap() map[string][]reflect.Type {
	return ΛEnumTypes
}

// OpenconfigInterfaces_Interfaces_Interface_State_Counters represents the /openconfig-interfaces/interfaces/interface/state/counters YANG schema element.
type OpenconfigInterfaces_Interfaces_Interface_State_Counters struct {
	CarrierTransitions *uint64 `path:"carrier-transitions" module:"openconfig-interfaces"`
	InBroadcastPkts    *uint64 `path:"in-broadcast-pkts" module:"openconfig-interfaces"`
	InDiscards         *uint64 `path:"in-discards" module:"openconfig-interfaces"`
	InErrors           *uint64 `path:"in-errors" module:"openconfig-interfaces"`
	InFcsErrors        *uint64 `path:"in-fcs-errors" module:"openconfig-interfaces"`
	InMulticastPkts    *uint64 `path:"in-multicast-pkts" module:"openconfig-interfaces"`
	InOctets           *uint64 `path:"in-octets" module:"openconfig-interfaces"`
	InPkts             *uint64 `path:"in-pkts" module:"openconfig-interfaces"`
	InUnicastPkts      *uint64 `path:"in-unicast-pkts" module:"openconfig-interfaces"`
	InUnknownProtos    *uint64 `path:"in-unknown-protos" module:"openconfig-interfaces"`
	LastClear          *uint64 `path:"last-clear" module:"openconfig-interfaces"`
	OutBroadcastPkts   *uint64 `path:"out-broadcast-pkts" module:"openconfig-interfaces"`
	OutDiscards        *uint64 `path:"out-discards" module:"openconfig-interfaces"`
	OutErrors          *uint64 `path:"out-errors" module:"openconfig-interfaces"`
	OutMulticastPkts   *uint64 `path:"out-multicast-pkts" module:"openconfig-interfaces"`
	OutOctets          *uint64 `path:"out-octets" module:"openconfig-interfaces"`
	OutPkts            *uint64 `path:"out-pkts" module:"openconfig-interfaces"`
	OutUnicastPkts     *uint64 `path:"out-unicast-pkts" module:"openconfig-interfaces"`
}

// IsYANGGoStruct ensures that OpenconfigInterfaces_Interfaces_Interface_State_Counters implements the yang.GoStruct
// interface. This allows functions that need to handle this struct to
// identify it as being generated by ygen.
func (*OpenconfigInterfaces_Interfaces_Interface_State_Counters) IsYANGGoStruct() {}

// Validate validates s against the YANG schema corresponding to its type.
func (t *OpenconfigInterfaces_Interfaces_Interface_State_Counters) Validate(opts ...ygot.ValidationOption) error {
	if err := ytypes.Validate(SchemaTree["OpenconfigInterfaces_Interfaces_Interface_State_Counters"], t, opts...); err != nil {
		return err
	}
	return nil
}

// ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types
// that are included in the generated code.
func (t *OpenconfigInterfaces_Interfaces_Interface_State_Counters) ΛEnumTypeMap() map[string][]reflect.Type {
	return ΛEnumTypes
}

// OpenconfigInterfaces_Interfaces_Interface_Subinterfaces represents the /openconfig-interfaces/interfaces/interface/subinterfaces YANG schema element.
type OpenconfigInterfaces_Interfaces_Interface_Subinterfaces struct {
	Subinterface map[uint32]*OpenconfigInterfaces_Interfaces_Interface_Subinterfaces_Subinterface `path:"subinterface" module:"openconfig-interfaces"`
}

// IsYANGGoStruct ensures that OpenconfigInterfaces_Interfaces_Interface_Subinterfaces implements the yang.GoStruct
// interface. This allows functions that need to handle this struct to
// identify it as being generated by ygen.
func (*OpenconfigInterfaces_Interfaces_Interface_Subinterfaces) IsYANGGoStruct() {}

// NewSubinterface creates a new entry in the Subinterface list of the
// OpenconfigInterfaces_Interfaces_Interface_Subinterfaces struct. The keys of the list are populated from the input
// arguments.
func (t *OpenconfigInterfaces_Interfaces_Interface_Subinterfaces) NewSubinterface(Index uint32) (*OpenconfigInterfaces_Interfaces_Interface_Subinterfaces_Subinterface, error) {

	// Initialise the list within the receiver struct if it has not already been
	// created.
	if t.Subinterface == nil {
		t.Subinterface = make(map[uint32]*OpenconfigInterfaces_Interfaces_Interface_Subinterfaces_Subinterface)
	}

	key := Index

	// Ensure that this key has not already been used in the
	// list. Keyed YANG lists do not allow duplicate keys to
	// be created.
	if _, ok := t.Subinterface[key]; ok {
		return nil, fmt.Errorf("duplicate key %v for list Subinterface", key)
	}

	t.Subinterface[key] = &OpenconfigInterfaces_Interfaces_Interface_Subinterfaces_Subinterface{
		Index: &Index,
	}

	return t.Subinterface[key], nil
}

// Validate validates s against the YANG schema corresponding to its type.
func (t *OpenconfigInterfaces_Interfaces_Interface_Subinterfaces) Validate(opts ...ygot.ValidationOption) error {
	if err := ytypes.Validate(SchemaTree["OpenconfigInterfaces_Interfaces_Interface_Subinterfaces"], t, opts...); err != nil {
		return err
	}
	return nil
}

// ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types
// that are included in the generated code.
func (t *OpenconfigInterfaces_Interfaces_Interface_Subinterfaces) ΛEnumTypeMap() map[string][]reflect.Type {
	return ΛEnumTypes
}

// OpenconfigInterfaces_Interfaces_Interface_Subinterfaces_Subinterface represents the /openconfig-interfaces/interfaces/interface/subinterfaces/subinterface YANG schema element.
type OpenconfigInterfaces_Interfaces_Interface_Subinterfaces_Subinterface struct {
	Config *OpenconfigInterfaces_Interfaces_Interface_Subinterfaces_Subinterface_Config `path:"config" module:"openconfig-interfaces"`
	Index  *uint32                                                                      `path:"index" module:"openconfig-interfaces"`
	State  *OpenconfigInterfaces_Interfaces_Interface_Subinterfaces_Subinterface_State  `path:"state" module:"openconfig-interfaces"`
}

// IsYANGGoStruct ensures that OpenconfigInterfaces_Interfaces_Interface_Subinterfaces_Subinterface implements the yang.GoStruct
// interface. This allows functions that need to handle this struct to
// identify it as being generated by ygen.
func (*OpenconfigInterfaces_Interfaces_Interface_Subinterfaces_Subinterface) IsYANGGoStruct() {}

// ΛListKeyMap returns the keys of the OpenconfigInterfaces_Interfaces_Interface_Subinterfaces_Subinterface struct, which is a YANG list entry.
func (t *OpenconfigInterfaces_Interfaces_Interface_Subinterfaces_Subinterface) ΛListKeyMap() (map[string]interface{}, error) {
	if t.Index == nil {
		return nil, fmt.Errorf("nil value for key Index")
	}

	return map[string]interface{}{
		"index": *t.Index,
	}, nil
}

// Validate validates s against the YANG schema corresponding to its type.
func (t *OpenconfigInterfaces_Interfaces_Interface_Subinterfaces_Subinterface) Validate(opts ...ygot.ValidationOption) error {
	if err := ytypes.Validate(SchemaTree["OpenconfigInterfaces_Interfaces_Interface_Subinterfaces_Subinterface"], t, opts...); err != nil {
		return err
	}
	return nil
}

// ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types
// that are included in the generated code.
func (t *OpenconfigInterfaces_Interfaces_Interface_Subinterfaces_Subinterface) ΛEnumTypeMap() map[string][]reflect.Type {
	return ΛEnumTypes
}

// OpenconfigInterfaces_Interfaces_Interface_Subinterfaces_Subinterface_Config represents the /openconfig-interfaces/interfaces/interface/subinterfaces/subinterface/config YANG schema element.
type OpenconfigInterfaces_Interfaces_Interface_Subinterfaces_Subinterface_Config struct {
	Description *string `path:"description" module:"openconfig-interfaces"`
	Enabled     *bool   `path:"enabled" module:"openconfig-interfaces"`
	Index       *uint32 `path:"index" module:"openconfig-interfaces"`
}

// IsYANGGoStruct ensures that OpenconfigInterfaces_Interfaces_Interface_Subinterfaces_Subinterface_Config implements the yang.GoStruct
// interface. This allows functions that need to handle this struct to
// identify it as being generated by ygen.
func (*OpenconfigInterfaces_Interfaces_Interface_Subinterfaces_Subinterface_Config) IsYANGGoStruct() {
}

// Validate validates s against the YANG schema corresponding to its type.
func (t *OpenconfigInterfaces_Interfaces_Interface_Subinterfaces_Subinterface_Config) Validate(opts ...ygot.ValidationOption) error {
	if err := ytypes.Validate(SchemaTree["OpenconfigInterfaces_Interfaces_Interface_Subinterfaces_Subinterface_Config"], t, opts...); err != nil {
		return err
	}
	return nil
}

// ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types
// that are included in the generated code.
func (t *OpenconfigInterfaces_Interfaces_Interface_Subinterfaces_Subinterface_Config) ΛEnumTypeMap() map[string][]reflect.Type {
	return ΛEnumTypes
}

// OpenconfigInterfaces_Interfaces_Interface_Subinterfaces_Subinterface_State represents the /openconfig-interfaces/interfaces/interface/subinterfaces/subinterface/state YANG schema element.
type OpenconfigInterfaces_Interfaces_Interface_Subinterfaces_Subinterface_State struct {
	AdminStatus E_OpenconfigInterfaces_Interfaces_Interface_State_AdminStatus                        `path:"admin-status" module:"openconfig-interfaces"`
	Counters    *OpenconfigInterfaces_Interfaces_Interface_Subinterfaces_Subinterface_State_Counters `path:"counters" module:"openconfig-interfaces"`
	Description *string                                                                              `path:"description" module:"openconfig-interfaces"`
	Enabled     *bool                                                                                `path:"enabled" module:"openconfig-interfaces"`
	Ifindex     *uint32                                                                              `path:"ifindex" module:"openconfig-interfaces"`
	Index       *uint32                                                                              `path:"index" module:"openconfig-interfaces"`
	LastChange  *uint64                                                                              `path:"last-change" module:"openconfig-interfaces"`
	Logical     *bool                                                                                `path:"logical" module:"openconfig-interfaces"`
	Name        *string                                                                              `path:"name" module:"openconfig-interfaces"`
	OperStatus  E_OpenconfigInterfaces_Interfaces_Interface_State_OperStatus                         `path:"oper-status" module:"openconfig-interfaces"`
}

// IsYANGGoStruct ensures that OpenconfigInterfaces_Interfaces_Interface_Subinterfaces_Subinterface_State implements the yang.GoStruct
// interface. This allows functions that need to handle this struct to
// identify it as being generated by ygen.
func (*OpenconfigInterfaces_Interfaces_Interface_Subinterfaces_Subinterface_State) IsYANGGoStruct() {}

// Validate validates s against the YANG schema corresponding to its type.
func (t *OpenconfigInterfaces_Interfaces_Interface_Subinterfaces_Subinterface_State) Validate(opts ...ygot.ValidationOption) error {
	if err := ytypes.Validate(SchemaTree["OpenconfigInterfaces_Interfaces_Interface_Subinterfaces_Subinterface_State"], t, opts...); err != nil {
		return err
	}
	return nil
}

// ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types
// that are included in the generated code.
func (t *OpenconfigInterfaces_Interfaces_Interface_Subinterfaces_Subinterface_State) ΛEnumTypeMap() map[string][]reflect.Type {
	return ΛEnumTypes
}

// OpenconfigInterfaces_Interfaces_Interface_Subinterfaces_Subinterface_State_Counters represents the /openconfig-interfaces/interfaces/interface/subinterfaces/subinterface/state/counters YANG schema element.
type OpenconfigInterfaces_Interfaces_Interface_Subinterfaces_Subinterface_State_Counters struct {
	CarrierTransitions *uint64 `path:"carrier-transitions" module:"openconfig-interfaces"`
	InBroadcastPkts    *uint64 `path:"in-broadcast-pkts" module:"openconfig-interfaces"`
	InDiscards         *uint64 `path:"in-discards" module:"openconfig-interfaces"`
	InErrors           *uint64 `path:"in-errors" module:"openconfig-interfaces"`
	InFcsErrors        *uint64 `path:"in-fcs-errors" module:"openconfig-interfaces"`
	InMulticastPkts    *uint64 `path:"in-multicast-pkts" module:"openconfig-interfaces"`
	InOctets           *uint64 `path:"in-octets" module:"openconfig-interfaces"`
	InPkts             *uint64 `path:"in-pkts" module:"openconfig-interfaces"`
	InUnicastPkts      *uint64 `path:"in-unicast-pkts" module:"openconfig-interfaces"`
	InUnknownProtos    *uint64 `path:"in-unknown-protos" module:"openconfig-interfaces"`
	LastClear          *uint64 `path:"last-clear" module:"openconfig-interfaces"`
	OutBroadcastPkts   *uint64 `path:"out-broadcast-pkts" module:"openconfig-interfaces"`
	OutDiscards        *uint64 `path:"out-discards" module:"openconfig-interfaces"`
	OutErrors          *uint64 `path:"out-errors" module:"openconfig-interfaces"`
	OutMulticastPkts   *uint64 `path:"out-multicast-pkts" module:"openconfig-interfaces"`
	OutOctets          *uint64 `path:"out-octets" module:"openconfig-interfaces"`
	OutPkts            *uint64 `path:"out-pkts" module:"openconfig-interfaces"`
	OutUnicastPkts     *uint64 `path:"out-unicast-pkts" module:"openconfig-interfaces"`
}

// IsYANGGoStruct ensures that OpenconfigInterfaces_Interfaces_Interface_Subinterfaces_Subinterface_State_Counters implements the yang.GoStruct
// interface. This allows functions that need to handle this struct to
// identify it as being generated by ygen.
func (*OpenconfigInterfaces_Interfaces_Interface_Subinterfaces_Subinterface_State_Counters) IsYANGGoStruct() {
}

// Validate validates s against the YANG schema corresponding to its type.
func (t *OpenconfigInterfaces_Interfaces_Interface_Subinterfaces_Subinterface_State_Counters) Validate(opts ...ygot.ValidationOption) error {
	if err := ytypes.Validate(SchemaTree["OpenconfigInterfaces_Interfaces_Interface_Subinterfaces_Subinterface_State_Counters"], t, opts...); err != nil {
		return err
	}
	return nil
}

// ΛEnumTypeMap returns a map, keyed by YANG schema path, of the enumerated types
// that are included in the generated code.
func (t *OpenconfigInterfaces_Interfaces_Interface_Subinterfaces_Subinterface_State_Counters) ΛEnumTypeMap() map[string][]reflect.Type {
	return ΛEnumTypes
}

// E_IETFInterfaces_InterfaceType is a derived int64 type which is used to represent
// the enumerated node IETFInterfaces_InterfaceType. An additional value named
// IETFInterfaces_InterfaceType_UNSET is added to the enumeration which is used as
// the nil value, indicating that the enumeration was not explicitly set by
// the program importing the generated structures.
type E_IETFInterfaces_InterfaceType int64

// IsYANGGoEnum ensures that IETFInterfaces_InterfaceType implements the yang.GoEnum
// interface. This ensures that IETFInterfaces_InterfaceType can be identified as a
// mapped type for a YANG enumeration.
func (E_IETFInterfaces_InterfaceType) IsYANGGoEnum() {}

// ΛMap returns the value lookup map associated with  IETFInterfaces_InterfaceType.
func (E_IETFInterfaces_InterfaceType) ΛMap() map[string]map[int64]ygot.EnumDefinition { return ΛEnum }

// String returns a logging-friendly string for E_IETFInterfaces_InterfaceType.
func (e E_IETFInterfaces_InterfaceType) String() string {
	return ygot.EnumLogString(e, int64(e), "E_IETFInterfaces_InterfaceType")
}

const (
	// IETFInterfaces_InterfaceType_UNSET corresponds to the value UNSET of IETFInterfaces_InterfaceType
	IETFInterfaces_InterfaceType_UNSET E_IETFInterfaces_InterfaceType = 0
)

// E_OpenconfigInterfaces_Interfaces_Interface_State_AdminStatus is a derived int64 type which is used to represent
// the enumerated node OpenconfigInterfaces_Interfaces_Interface_State_AdminStatus. An additional value named
// OpenconfigInterfaces_Interfaces_Interface_State_AdminStatus_UNSET is added to the enumeration which is used as
// the nil value, indicating that the enumeration was not explicitly set by
// the program importing the generated structures.
type E_OpenconfigInterfaces_Interfaces_Interface_State_AdminStatus int64

// IsYANGGoEnum ensures that OpenconfigInterfaces_Interfaces_Interface_State_AdminStatus implements the yang.GoEnum
// interface. This ensures that OpenconfigInterfaces_Interfaces_Interface_State_AdminStatus can be identified as a
// mapped type for a YANG enumeration.
func (E_OpenconfigInterfaces_Interfaces_Interface_State_AdminStatus) IsYANGGoEnum() {}

// ΛMap returns the value lookup map associated with  OpenconfigInterfaces_Interfaces_Interface_State_AdminStatus.
func (E_OpenconfigInterfaces_Interfaces_Interface_State_AdminStatus) ΛMap() map[string]map[int64]ygot.EnumDefinition {
	return ΛEnum
}

// String returns a logging-friendly string for E_OpenconfigInterfaces_Interfaces_Interface_State_AdminStatus.
func (e E_OpenconfigInterfaces_Interfaces_Interface_State_AdminStatus) String() string {
	return ygot.EnumLogString(e, int64(e), "E_OpenconfigInterfaces_Interfaces_Interface_State_AdminStatus")
}

const (
	// OpenconfigInterfaces_Interfaces_Interface_State_AdminStatus_UNSET corresponds to the value UNSET of OpenconfigInterfaces_Interfaces_Interface_State_AdminStatus
	OpenconfigInterfaces_Interfaces_Interface_State_AdminStatus_UNSET E_OpenconfigInterfaces_Interfaces_Interface_State_AdminStatus = 0
	// OpenconfigInterfaces_Interfaces_Interface_State_AdminStatus_UP corresponds to the value UP of OpenconfigInterfaces_Interfaces_Interface_State_AdminStatus
	OpenconfigInterfaces_Interfaces_Interface_State_AdminStatus_UP E_OpenconfigInterfaces_Interfaces_Interface_State_AdminStatus = 1
	// OpenconfigInterfaces_Interfaces_Interface_State_AdminStatus_DOWN corresponds to the value DOWN of OpenconfigInterfaces_Interfaces_Interface_State_AdminStatus
	OpenconfigInterfaces_Interfaces_Interface_State_AdminStatus_DOWN E_OpenconfigInterfaces_Interfaces_Interface_State_AdminStatus = 2
	// OpenconfigInterfaces_Interfaces_Interface_State_AdminStatus_TESTING corresponds to the value TESTING of OpenconfigInterfaces_Interfaces_Interface_State_AdminStatus
	OpenconfigInterfaces_Interfaces_Interface_State_AdminStatus_TESTING E_OpenconfigInterfaces_Interfaces_Interface_State_AdminStatus = 3
)

// E_OpenconfigInterfaces_Interfaces_Interface_State_OperStatus is a derived int64 type which is used to represent
// the enumerated node OpenconfigInterfaces_Interfaces_Interface_State_OperStatus. An additional value named
// OpenconfigInterfaces_Interfaces_Interface_State_OperStatus_UNSET is added to the enumeration which is used as
// the nil value, indicating that the enumeration was not explicitly set by
// the program importing the generated structures.
type E_OpenconfigInterfaces_Interfaces_Interface_State_OperStatus int64

// IsYANGGoEnum ensures that OpenconfigInterfaces_Interfaces_Interface_State_OperStatus implements the yang.GoEnum
// interface. This ensures that OpenconfigInterfaces_Interfaces_Interface_State_OperStatus can be identified as a
// mapped type for a YANG enumeration.
func (E_OpenconfigInterfaces_Interfaces_Interface_State_OperStatus) IsYANGGoEnum() {}

// ΛMap returns the value lookup map associated with  OpenconfigInterfaces_Interfaces_Interface_State_OperStatus.
func (E_OpenconfigInterfaces_Interfaces_Interface_State_OperStatus) ΛMap() map[string]map[int64]ygot.EnumDefinition {
	return ΛEnum
}

// String returns a logging-friendly string for E_OpenconfigInterfaces_Interfaces_Interface_State_OperStatus.
func (e E_OpenconfigInterfaces_Interfaces_Interface_State_OperStatus) String() string {
	return ygot.EnumLogString(e, int64(e), "E_OpenconfigInterfaces_Interfaces_Interface_State_OperStatus")
}

const (
	// OpenconfigInterfaces_Interfaces_Interface_State_OperStatus_UNSET corresponds to the value UNSET of OpenconfigInterfaces_Interfaces_Interface_State_OperStatus
	OpenconfigInterfaces_Interfaces_Interface_State_OperStatus_UNSET E_OpenconfigInterfaces_Interfaces_Interface_State_OperStatus = 0
	// OpenconfigInterfaces_Interfaces_Interface_State_OperStatus_UP corresponds to the value UP of OpenconfigInterfaces_Interfaces_Interface_State_OperStatus
	OpenconfigInterfaces_Interfaces_Interface_State_OperStatus_UP E_OpenconfigInterfaces_Interfaces_Interface_State_OperStatus = 2
	// OpenconfigInterfaces_Interfaces_Interface_State_OperStatus_DOWN corresponds to the value DOWN of OpenconfigInterfaces_Interfaces_Interface_State_OperStatus
	OpenconfigInterfaces_Interfaces_Interface_State_OperStatus_DOWN E_OpenconfigInterfaces_Interfaces_Interface_State_OperStatus = 3
	// OpenconfigInterfaces_Interfaces_Interface_State_OperStatus_TESTING corresponds to the value TESTING of OpenconfigInterfaces_Interfaces_Interface_State_OperStatus
	OpenconfigInterfaces_Interfaces_Interface_State_OperStatus_TESTING E_OpenconfigInterfaces_Interfaces_Interface_State_OperStatus = 4
	// OpenconfigInterfaces_Interfaces_Interface_State_OperStatus_UNKNOWN corresponds to the value UNKNOWN of OpenconfigInterfaces_Interfaces_Interface_State_OperStatus
	OpenconfigInterfaces_Interfaces_Interface_State_OperStatus_UNKNOWN E_OpenconfigInterfaces_Interfaces_Interface_State_OperStatus = 5
	// OpenconfigInterfaces_Interfaces_Interface_State_OperStatus_DORMANT corresponds to the value DORMANT of OpenconfigInterfaces_Interfaces_Interface_State_OperStatus
	OpenconfigInterfaces_Interfaces_Interface_State_OperStatus_DORMANT E_OpenconfigInterfaces_Interfaces_Interface_State_OperStatus = 6
	// OpenconfigInterfaces_Interfaces_Interface_State_OperStatus_NOT_PRESENT corresponds to the value NOT_PRESENT of OpenconfigInterfaces_Interfaces_Interface_State_OperStatus
	OpenconfigInterfaces_Interfaces_Interface_State_OperStatus_NOT_PRESENT E_OpenconfigInterfaces_Interfaces_Interface_State_OperStatus = 7
	// OpenconfigInterfaces_Interfaces_Interface_State_OperStatus_LOWER_LAYER_DOWN corresponds to the value LOWER_LAYER_DOWN of OpenconfigInterfaces_Interfaces_Interface_State_OperStatus
	OpenconfigInterfaces_Interfaces_Interface_State_OperStatus_LOWER_LAYER_DOWN E_OpenconfigInterfaces_Interfaces_Interface_State_OperStatus = 8
)

// ΛEnum is a map, keyed by the name of the type defined for each enum in the
// generated Go code, which provides a mapping between the constant int64 value
// of each value of the enumeration, and the string that is used to represent it
// in the YANG schema. The map is named ΛEnum in order to avoid clash with any
// valid YANG identifier.
var ΛEnum = map[string]map[int64]ygot.EnumDefinition{
	"E_IETFInterfaces_InterfaceType": {},
	"E_OpenconfigInterfaces_Interfaces_Interface_State_AdminStatus": {
		1: {Name: "UP"},
		2: {Name: "DOWN"},
		3: {Name: "TESTING"},
	},
	"E_OpenconfigInterfaces_Interfaces_Interface_State_OperStatus": {
		2: {Name: "UP"},
		3: {Name: "DOWN"},
		4: {Name: "TESTING"},
		5: {Name: "UNKNOWN"},
		6: {Name: "DORMANT"},
		7: {Name: "NOT_PRESENT"},
		8: {Name: "LOWER_LAYER_DOWN"},
	},
}

var (
	// ySchema is a byte slice contain a gzip compressed representation of the
	// YANG schema from which the Go code was generated. When uncompressed the
	// contents of the byte slice is a JSON document containing an object, keyed
	// on the name of the generated struct, and containing the JSON marshalled
	// contents of a goyang yang.Entry struct, which defines the schema for the
	// fields within the struct.
	ySchema = []byte{
		0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0x9d, 0x5d, 0x6f, 0xdb, 0xb8,
		0xd2, 0xc7, 0xef, 0xfd, 0x29, 0x02, 0x5d, 0xc7, 0x75, 0x9c, 0x3a, 0x6f, 0xbd, 0xeb, 0x6e, 0xba,
		0xd8, 0xe2, 0x79, 0x7a, 0xba, 0xd8, 0xee, 0x9e, 0x9b, 0x03, 0x23, 0x60, 0x24, 0x3a, 0x21, 0x22,
		0x93, 0x86, 0x44, 0x6d, 0x13, 0x1c, 0xe4, 0xbb, 0x1f, 0xc8, 0x96, 0x15, 0x29, 0x7e, 0xd3, 0x90,
		0x23, 0xd9, 0x69, 0xff, 0xbd, 0x4a, 0x52, 0x93, 0xb2, 0xc8, 0x99, 0xf9, 0xff, 0x66, 0x48, 0x51,
		0xff, 0xed, 0x1d, 0x1d, 0x1d, 0x1d, 0x05, 0xff, 0x12, 0x53, 0x19, 0x7c, 0x38, 0x0a, 0x22, 0xf9,
		0x8f, 0x0a, 0x65, 0x70, 0xbc, 0xf8, 0xeb, 0xff, 0x29, 0x1d, 0x05, 0x1f, 0x8e, 0x86, 0xc5, 0xaf,
		0xbf, 0x1a, 0x3d, 0x51, 0x77, 0xc1, 0x87, 0xa3, 0x93, 0xe2, 0x0f, 0xd7, 0x2a, 0x09, 0x3e, 0x1c,
		0x2d, 0xba, 0x98, 0xff, 0x41, 0x69, 0x2b, 0x93, 0x89, 0x08, 0x65, 0x5a, 0xfb, 0x7b, 0xed, 0x12,
		0x95, 0xcf, 0x1c, 0xd7, 0x3f, 0x51, 0xbf, 0x5c, 0xf9, 0xe7, 0xd7, 0x97, 0x2d, 0xff, 0xe3, 0x8f,
		0x44, 0x4e, 0xd4, 0xe3, 0xca, 0x95, 0x6a, 0x57, 0x33, 0x61, 0x5f, 0x4d, 0x5e, 0x5d, 0x68, 0xfe,
		0x81, 0x6f, 0x26, 0x4b, 0x42, 0xb9, 0xb6, 0xf1, 0xe2, 0xcb, 0xc8, 0xa7, 0xef, 0x26, 0xc9, 0xbf,
		0x4f, 0x30, 0x5b, 0x5c, 0xe7, 0x78, 0xfd, 0x07, 0x7f, 0x17, 0xe9, 0xc7, 0xe4, 0x2e, 0x9b, 0x4a,
		0x6d, 0x83, 0x0f, 0x47, 0x36, 0xc9, 0xe4, 0x86, 0x0f, 0x56, 0x3e, 0x55, 0x7c, 0xad, 0x95, 0xcf,
		0x3d, 0xd7, 0xfe, 0xf2, 0xfc, 0xea, 0x7e, 0x5f, 0x0f, 0xf7, 0xea, 0xb0, 0x6f, 0xbe, 0x9d, 0x95,
		0xd1, 0xdf, 0x74, 0x3b, 0xeb, 0x27, 0x61, 0xe7, 0x64, 0x34, 0x99, 0x94, 0xc6, 0x93, 0xd3, 0x74,
		0x92, 0xc8, 0x93, 0x45, 0x9e, 0x34, 0xca, 0xe4, 0xad, 0x9f, 0xc4, 0x0d, 0x93, 0xb9, 0x73, 0x52,
		0xcb, 0x0f, 0x84, 0xcb, 0x11, 0xdf, 0x31, 0x06, 0xcb, 0x41, 0x2d, 0x3e, 0xbf, 0xe3, 0x7e, 0xb6,
		0x4f, 0x73, 0xe3, 0xe9, 0xa6, 0x4c, 0x3b, 0x79, 0xfa, 0xa9, 0x66, 0xe0, 0x6c, 0x0e, 0xce, 0x66,
		0xe1, 0x62, 0x1e, 0xdb, 0xcd, 0x64, 0x87, 0xb9, 0x34, 0x36, 0x9b, 0xf2, 0x83, 0x91, 0x4c, 0xc3,
		0x44, 0xcd, 0xac, 0x32, 0xba, 0xf9, 0x00, 0xbe, 0xc8, 0xc1, 0x4b, 0xe3, 0x86, 0x23, 0x51, 0x18,
		0xd6, 0x49, 0xc3, 0x8f, 0x37, 0x35, 0x30, 0x17, 0x43, 0x73, 0x36, 0x38, 0x57, 0xc3, 0xf3, 0x36,
		0x40, 0x6f, 0x43, 0xf4, 0x31, 0xc8, 0x66, 0x86, 0xd9, 0xd0, 0x40, 0xcb, 0x2f, 0xf2, 0xd7, 0xd3,
		0x4c, 0xba, 0xcd, 0x56, 0x6a, 0x13, 0xa5, 0xef, 0x28, 0xd3, 0xb5, 0x0c, 0x6a, 0x97, 0x3d, 0x9e,
		0xfb, 0x6c, 0x70, 0x8f, 0x81, 0xd4, 0xe2, 0x36, 0x96, 0x11, 0xdd, 0xb7, 0x96, 0x0d, 0x1b, 0x8e,
		0xe3, 0xb5, 0x9c, 0x88, 0x2c, 0x9e, 0xcf, 0x67, 0x6e, 0x0e, 0x70, 0x47, 0xb8, 0x63, 0xb7, 0xee,
		0x78, 0x6b, 0x4c, 0x2c, 0x85, 0x76, 0xf1, 0xc7, 0x61, 0x87, 0xfe, 0x18, 0x1b, 0x33, 0xbb, 0x15,
		0xe1, 0x43, 0x7f, 0x6a, 0x22, 0x49, 0xf7, 0xca, 0x7a, 0x73, 0xba, 0x6f, 0x4e, 0x44, 0x9c, 0xc2,
		0x39, 0xe1, 0x9c, 0x70, 0xce, 0x75, 0xd7, 0x9c, 0xda, 0x8c, 0xee, 0x92, 0x79, 0x23, 0x38, 0x14,
		0x1c, 0xaa, 0x53, 0x87, 0xca, 0x94, 0xb6, 0xc3, 0x73, 0x07, 0x7f, 0x3a, 0x27, 0x34, 0xf9, 0x53,
		0xe8, 0xbb, 0xfc, 0x6a, 0xff, 0x21, 0x0d, 0x2f, 0xcd, 0x1c, 0xe6, 0x17, 0xfa, 0xa2, 0x34, 0xd9,
		0x8e, 0x1c, 0x9d, 0x6a, 0xa5, 0xf9, 0xbf, 0x45, 0x9c, 0x49, 0x8f, 0xf6, 0xbf, 0x25, 0x22, 0xcc,
		0x13, 0xd0, 0x6b, 0x75, 0xa7, 0x6c, 0x9a, 0x77, 0x44, 0xee, 0xe7, 0xf9, 0xd8, 0x61, 0xc8, 0xc4,
		0xe3, 0xde, 0x87, 0xec, 0xfc, 0xec, 0xec, 0xfd, 0xd9, 0x1e, 0x87, 0xad, 0xd7, 0xce, 0xa7, 0xc7,
		0x1d, 0x2a, 0x8e, 0x5e, 0xf8, 0x33, 0x51, 0x72, 0xe6, 0xad, 0xa0, 0x39, 0xd0, 0x1c, 0x14, 0x3c,
		0x56, 0xae, 0x69, 0x29, 0xf7, 0x57, 0xde, 0xdb, 0xbc, 0x15, 0x3c, 0x0a, 0x1e, 0xe5, 0xe0, 0x51,
		0x5f, 0x84, 0x8e, 0x84, 0x35, 0xc9, 0xd3, 0xee, 0x05, 0x0b, 0x06, 0x2f, 0x54, 0x91, 0xd4, 0x56,
		0xd9, 0xa7, 0x44, 0x4e, 0x5c, 0x5c, 0x91, 0xa0, 0xd7, 0xc1, 0xe7, 0xe2, 0x52, 0xbf, 0x88, 0xd4,
		0xc1, 0x42, 0x56, 0x96, 0xf4, 0xfa, 0x73, 0x27, 0xe3, 0x9e, 0xa4, 0x96, 0x17, 0x32, 0x3e, 0x3d,
		0xce, 0xe9, 0x64, 0x37, 0x02, 0xd3, 0xd7, 0x7e, 0x4c, 0xd8, 0x97, 0x8f, 0xf6, 0x83, 0x95, 0xb1,
		0x9c, 0x4a, 0x9b, 0x3c, 0xf5, 0x8d, 0xee, 0x87, 0xf7, 0x73, 0xe6, 0x76, 0x5a, 0x0f, 0x9a, 0xd7,
		0x76, 0x1c, 0x16, 0x84, 0x7c, 0xd7, 0x82, 0xc6, 0xbb, 0xd6, 0x26, 0xb5, 0x36, 0x56, 0x34, 0x5e,
		0xe1, 0x09, 0xd2, 0xf0, 0x5e, 0x4e, 0xc5, 0x4c, 0xd8, 0xfb, 0xfc, 0xdb, 0x0d, 0xcc, 0x4c, 0xea,
		0xc5, 0xa2, 0x61, 0xff, 0x65, 0x6d, 0x7e, 0xb0, 0xee, 0xc7, 0x41, 0xa3, 0xb5, 0xc5, 0xc5, 0x35,
		0x6c, 0x92, 0x85, 0xb6, 0xa0, 0xaf, 0xe0, 0x6b, 0x79, 0x89, 0xcf, 0x65, 0xb7, 0x37, 0xeb, 0x7e,
		0xbc, 0x29, 0x82, 0x79, 0xcf, 0x6d, 0xb4, 0xb6, 0x18, 0x5b, 0x70, 0x6f, 0xe2, 0xa8, 0x6f, 0x55,
		0x03, 0x1c, 0x2c, 0x3d, 0xeb, 0xa5, 0x09, 0x56, 0x53, 0xb1, 0x9a, 0x4a, 0x58, 0x8c, 0x5f, 0x99,
		0x9c, 0xc6, 0x8e, 0x43, 0x30, 0x27, 0x00, 0xd0, 0xcf, 0x02, 0x40, 0x4d, 0xcd, 0xb3, 0x6c, 0x10,
		0x99, 0xef, 0xda, 0x1d, 0x28, 0xe6, 0xad, 0x89, 0x63, 0x55, 0x59, 0x02, 0x39, 0xa1, 0xb6, 0x75,
		0xab, 0x96, 0x90, 0xcd, 0xde, 0xc7, 0xfc, 0xbd, 0xdd, 0xc0, 0xd7, 0x1d, 0xd8, 0xdc, 0x82, 0xcd,
		0x3d, 0x38, 0xdc, 0xc4, 0xb1, 0xd2, 0x44, 0x9c, 0x6f, 0x72, 0x2e, 0xb0, 0xb6, 0x1a, 0xfc, 0xfe,
		0xd4, 0x65, 0xba, 0x0b, 0xdb, 0xbe, 0x70, 0x68, 0xea, 0x56, 0x1d, 0x76, 0xaf, 0x12, 0xb3, 0x54,
		0x8b, 0x99, 0x4a, 0xa0, 0x5c, 0xd5, 0x63, 0xce, 0x72, 0xa8, 0x47, 0x35, 0x99, 0xa5, 0xaa, 0xdc,
		0xd6, 0xd0, 0x8e, 0x4e, 0xaf, 0x46, 0x57, 0xe7, 0x17, 0xa7, 0x57, 0x67, 0x07, 0x34, 0xc6, 0xbd,
		0x6e, 0x5a, 0x8d, 0x5b, 0x2a, 0x71, 0x13, 0x6c, 0x24, 0xc8, 0x66, 0xee, 0x52, 0x9d, 0xcd, 0x20,
		0xd4, 0x10, 0x6a, 0x08, 0x35, 0x84, 0x1a, 0x42, 0x0d, 0xa1, 0x86, 0x50, 0xd3, 0x85, 0x9a, 0x35,
		0x51, 0x6f, 0x5c, 0xcc, 0x76, 0x73, 0x7e, 0xd6, 0xe2, 0xf6, 0x06, 0x7d, 0x21, 0x14, 0xb9, 0xd7,
		0x0a, 0x0b, 0x77, 0x8d, 0x64, 0xdc, 0xb4, 0x66, 0x48, 0x2b, 0x82, 0x97, 0xed, 0xdc, 0x8b, 0xe1,
		0x65, 0x75, 0x78, 0x40, 0xaa, 0xee, 0x1d, 0xf9, 0x94, 0xc7, 0x7f, 0x37, 0x71, 0xf4, 0x97, 0x9a,
		0x36, 0xab, 0x93, 0x37, 0x1f, 0xe8, 0xe7, 0x46, 0x15, 0x7d, 0x61, 0x1d, 0x16, 0x7e, 0x17, 0xcd,
		0x5a, 0x2e, 0x7c, 0x9e, 0xa2, 0xf0, 0x89, 0xc2, 0x27, 0x0a, 0x9f, 0xc8, 0xa7, 0x90, 0x4f, 0x21,
		0x9f, 0x42, 0x3e, 0x85, 0x7c, 0x0a, 0xf9, 0x14, 0x0a, 0x9f, 0x10, 0x6a, 0x08, 0x35, 0x84, 0x1a,
		0x42, 0x0d, 0xa1, 0x86, 0x50, 0x43, 0xa8, 0xdb, 0x4d, 0xd4, 0xf7, 0x59, 0x7d, 0xa3, 0x54, 0x98,
		0x78, 0x8a, 0x6f, 0xdf, 0xe6, 0x57, 0x3c, 0x88, 0xed, 0xd3, 0xdd, 0xed, 0xfd, 0x6d, 0xba, 0x19,
		0x96, 0x65, 0x88, 0xdb, 0xd8, 0x00, 0xdc, 0xe8, 0x51, 0x30, 0xca, 0x23, 0x60, 0x0d, 0xc3, 0x1c,
		0xb6, 0xfd, 0x1e, 0xea, 0xb6, 0xdf, 0xc6, 0xd8, 0xf5, 0x72, 0x3c, 0x84, 0x14, 0x93, 0x66, 0x0f,
		0x86, 0x94, 0xb5, 0xec, 0x06, 0x60, 0x15, 0xfc, 0x51, 0xf8, 0xe3, 0xbb, 0x77, 0xc5, 0x5a, 0xc2,
		0x60, 0x6e, 0x7e, 0x2d, 0x38, 0x41, 0xb3, 0x2a, 0x3e, 0xa9, 0x7a, 0x4f, 0xde, 0xfd, 0x7e, 0x0a,
		0x37, 0x38, 0x28, 0x37, 0x68, 0xbc, 0xfb, 0x5d, 0x44, 0x53, 0xa5, 0xfb, 0xb9, 0x4d, 0x64, 0x29,
		0x7d, 0x25, 0xa8, 0xd6, 0x1a, 0x8f, 0x02, 0x76, 0x97, 0x50, 0xe3, 0x51, 0x40, 0xc7, 0x47, 0x01,
		0xa5, 0xce, 0xa6, 0x32, 0x11, 0x84, 0xe3, 0xef, 0x6a, 0xf1, 0x70, 0x44, 0x68, 0xf3, 0x49, 0x67,
		0xd3, 0xfc, 0x4b, 0x62, 0x3f, 0xc2, 0xfe, 0xf6, 0x23, 0x1c, 0x77, 0x37, 0x4c, 0x66, 0x56, 0xd8,
		0x95, 0x88, 0x7f, 0xb0, 0xed, 0x1a, 0x2c, 0x7b, 0x0d, 0x42, 0x93, 0xe5, 0x29, 0x41, 0xea, 0xf2,
		0xa0, 0x55, 0xd1, 0x12, 0x8f, 0x5a, 0x41, 0x60, 0x1c, 0x22, 0x26, 0x79, 0xc7, 0x41, 0x28, 0x92,
		0x44, 0xc9, 0xa4, 0x6f, 0x13, 0xa1, 0x53, 0x95, 0xbb, 0x74, 0xea, 0xbe, 0xaa, 0xb1, 0xae, 0x33,
		0x2c, 0x55, 0xb0, 0x1b, 0x3c, 0x9b, 0xe1, 0xb3, 0x39, 0x00, 0x87, 0x23, 0xb8, 0xd5, 0x18, 0xbb,
		0x5f, 0xaa, 0x28, 0x42, 0xf4, 0xf9, 0xc8, 0x63, 0xb5, 0xe2, 0x12, 0xab, 0x15, 0x7e, 0x25, 0x75,
		0xac, 0x56, 0xb4, 0x36, 0xb4, 0xc3, 0xcb, 0xd1, 0xe8, 0xfc, 0x62, 0x34, 0x3a, 0xb9, 0x78, 0x7f,
		0x71, 0x72, 0x75, 0x76, 0x36, 0x3c, 0x1f, 0x62, 0xdd, 0x82, 0x39, 0x0a, 0x91, 0x13, 0x1b, 0x3f,
		0x37, 0x6e, 0x25, 0xd1, 0xe1, 0x23, 0x7a, 0x4f, 0xb2, 0x77, 0x9b, 0xe4, 0x71, 0x2b, 0x7b, 0x42,
		0x94, 0xee, 0xdf, 0x26, 0x46, 0x44, 0xa1, 0x48, 0x6d, 0x7f, 0xf6, 0x60, 0x53, 0x9f, 0x73, 0x71,
		0x5e, 0x77, 0x05, 0x94, 0x02, 0x4a, 0x01, 0xa5, 0x80, 0x52, 0x40, 0x29, 0xa0, 0x14, 0xb6, 0x80,
		0x50, 0x75, 0x39, 0x52, 0x69, 0x28, 0x92, 0xc8, 0x4f, 0x91, 0xcb, 0x4e, 0xa0, 0xc5, 0xd0, 0x62,
		0x68, 0x31, 0xb4, 0x18, 0x5a, 0x0c, 0x2d, 0x86, 0x16, 0x53, 0xb5, 0x58, 0x26, 0x89, 0x49, 0xfc,
		0x94, 0xb8, 0xe8, 0x02, 0x3a, 0x0c, 0x1d, 0x86, 0x0e, 0x43, 0x87, 0xa1, 0xc3, 0xd0, 0x61, 0xe8,
		0x30, 0x55, 0x87, 0x27, 0x61, 0xca, 0xa1, 0xc5, 0x95, 0x6e, 0xa0, 0xc7, 0xd0, 0x63, 0xe8, 0x31,
		0xf4, 0x18, 0x7a, 0x0c, 0x3d, 0x86, 0x1e, 0x53, 0xf5, 0x78, 0x9a, 0xc5, 0x56, 0xf1, 0xac, 0x1d,
		0xbf, 0xea, 0x0a, 0xba, 0x0c, 0x5d, 0x86, 0x2e, 0x43, 0x97, 0xa1, 0xcb, 0xd0, 0x65, 0xe8, 0x32,
		0x55, 0x97, 0x4d, 0x68, 0xa5, 0xa7, 0x1e, 0x17, 0x5d, 0x40, 0x87, 0xa1, 0xc3, 0xd0, 0x61, 0xe8,
		0x30, 0x74, 0x18, 0x3a, 0x0c, 0x1d, 0xa6, 0xea, 0xb0, 0x77, 0x56, 0x8c, 0x5c, 0x18, 0x1a, 0x0c,
		0x0d, 0x86, 0x06, 0x43, 0x83, 0xa1, 0xc1, 0xd0, 0x60, 0x27, 0x0d, 0xce, 0x34, 0x53, 0x85, 0xba,
		0xd6, 0x11, 0x34, 0x19, 0x9a, 0x0c, 0x4d, 0x86, 0x26, 0x43, 0x93, 0xa1, 0xc9, 0xd0, 0x64, 0xba,
		0x26, 0x3f, 0x68, 0xf3, 0x5d, 0xf7, 0x67, 0x89, 0xb1, 0xc6, 0x57, 0x95, 0x6b, 0x5d, 0x41, 0x97,
		0xa1, 0xcb, 0xd0, 0x65, 0xe8, 0x32, 0x74, 0x19, 0xba, 0x0c, 0x5d, 0x26, 0xe9, 0x72, 0x9c, 0x27,
		0xb7, 0x61, 0x2c, 0x45, 0xe2, 0x2e, 0xc8, 0x95, 0x3e, 0xa0, 0xc4, 0x50, 0xe2, 0x1f, 0x4a, 0x89,
		0xad, 0x9a, 0x4a, 0xab, 0xc2, 0x87, 0xb4, 0x73, 0x2d, 0xfe, 0x5b, 0x2f, 0xe2, 0x58, 0xa0, 0x85,
		0x36, 0xa9, 0x0c, 0x8d, 0x26, 0x3f, 0xd1, 0x0f, 0x4d, 0x87, 0xa6, 0x43, 0xd3, 0x0f, 0x59, 0xd3,
		0x71, 0x24, 0x1b, 0x8e, 0x64, 0xcb, 0xef, 0xc0, 0x64, 0x96, 0xed, 0x4c, 0xb6, 0x35, 0x7d, 0x01,
		0xcb, 0x80, 0x65, 0x28, 0x90, 0xa0, 0x40, 0x02, 0x98, 0x02, 0x4c, 0xa1, 0x40, 0x42, 0x56, 0x66,
		0xff, 0x53, 0xd9, 0x6a, 0xbd, 0x40, 0x8d, 0xa1, 0xc6, 0x50, 0x63, 0xa8, 0x31, 0xd4, 0x18, 0x6a,
		0x0c, 0x35, 0x26, 0xab, 0xb1, 0xef, 0x59, 0x30, 0x95, 0x3e, 0xa0, 0xc4, 0x50, 0x62, 0x28, 0x31,
		0x94, 0x18, 0x4a, 0x0c, 0x25, 0x86, 0x12, 0x93, 0x95, 0x98, 0xeb, 0x24, 0x98, 0x35, 0x7d, 0x41,
		0x99, 0xa1, 0xcc, 0x50, 0x66, 0x28, 0x33, 0x94, 0x19, 0xca, 0x0c, 0x65, 0x26, 0x2b, 0xb3, 0xef,
		0x59, 0x30, 0x95, 0x3e, 0xa0, 0xc4, 0x50, 0x62, 0x28, 0x31, 0x94, 0x18, 0x4a, 0x0c, 0x25, 0x86,
		0x12, 0x93, 0x95, 0xd8, 0x3f, 0x33, 0x46, 0x3e, 0x0c, 0x15, 0x86, 0x0a, 0x43, 0x85, 0xa1, 0xc2,
		0x50, 0x61, 0xa8, 0xb0, 0x9b, 0x0a, 0xf3, 0x9c, 0x07, 0xb3, 0xd2, 0x13, 0x54, 0x19, 0xaa, 0x0c,
		0x55, 0x86, 0x2a, 0x43, 0x95, 0xa1, 0xca, 0x50, 0xe5, 0x86, 0x9f, 0x6c, 0x68, 0x53, 0xf4, 0x87,
		0xdd, 0x88, 0xaa, 0xbe, 0xfa, 0x70, 0x9b, 0x99, 0xc9, 0x44, 0xe4, 0x73, 0x29, 0x62, 0xaa, 0xb4,
		0x7b, 0x3f, 0xcc, 0xe6, 0xf8, 0x10, 0x5b, 0xb3, 0x21, 0x1f, 0x37, 0x1c, 0xf2, 0x8f, 0x5a, 0x1b,
		0x3b, 0x1f, 0x01, 0x92, 0xe7, 0x06, 0x69, 0x78, 0x2f, 0xa7, 0x62, 0x26, 0xec, 0x7d, 0xfe, 0xed,
		0x07, 0x66, 0x26, 0x75, 0x38, 0x87, 0x96, 0xbe, 0xca, 0xe5, 0x64, 0x22, 0x42, 0x99, 0x0e, 0xd6,
		0xfd, 0x38, 0x48, 0xad, 0xb0, 0x72, 0x50, 0xc8, 0x0e, 0x05, 0xa8, 0x82, 0xd4, 0x26, 0x59, 0x68,
		0x75, 0x21, 0x5c, 0x5f, 0xcb, 0x4b, 0x7e, 0x2e, 0x2f, 0x73, 0xb3, 0xee, 0xc7, 0x9b, 0x6f, 0xf9,
		0x15, 0x6f, 0x7e, 0x5d, 0x5e, 0xb1, 0xc7, 0x33, 0xca, 0x0d, 0x8c, 0x3a, 0x88, 0x64, 0x1a, 0x26,
		0x6a, 0x46, 0x1a, 0xde, 0x52, 0x99, 0xab, 0x8d, 0x1b, 0xce, 0x26, 0x2d, 0x76, 0x92, 0x31, 0xd3,
		0x05, 0x2f, 0x9d, 0xb1, 0xd2, 0x15, 0x27, 0xbd, 0x31, 0xd2, 0x1b, 0x1f, 0x7d, 0xb0, 0x91, 0x37,
		0xa0, 0x92, 0xf1, 0xb0, 0x9c, 0xad, 0xd4, 0x26, 0x4a, 0xdf, 0x51, 0xa6, 0xab, 0xb0, 0xbd, 0xe1,
		0x65, 0x87, 0xfe, 0x25, 0xb5, 0xb8, 0x8d, 0x65, 0x44, 0xf7, 0xad, 0x65, 0xc3, 0x86, 0xe3, 0x78,
		0x2d, 0x27, 0x22, 0x8b, 0xe7, 0xf3, 0x99, 0x9b, 0x03, 0xdc, 0x11, 0xee, 0xd8, 0xad, 0x3b, 0xde,
		0x1a, 0x13, 0x4b, 0xa1, 0x5d, 0xfc, 0x71, 0xd8, 0xa1, 0x3f, 0xaa, 0x89, 0xd2, 0x91, 0x7c, 0xa4,
		0xfb, 0xe3, 0xb2, 0x21, 0x1c, 0x0b, 0x8e, 0xd5, 0xa9, 0x63, 0x65, 0x4a, 0xdb, 0xf7, 0xa7, 0x0e,
		0x7e, 0x75, 0x41, 0x68, 0xe2, 0x56, 0xeb, 0x70, 0x28, 0xea, 0xf8, 0xd4, 0x36, 0x3c, 0x13, 0x6f,
		0xdf, 0x5a, 0x06, 0x47, 0x56, 0xed, 0x50, 0xbb, 0xf0, 0xaa, 0x59, 0x70, 0x0d, 0xd9, 0xe8, 0xf4,
		0x6a, 0x74, 0x75, 0x7e, 0x71, 0x7a, 0x75, 0xb6, 0xc7, 0xb1, 0x6b, 0xa9, 0x42, 0x30, 0x7e, 0xe3,
		0x15, 0x02, 0xff, 0xe3, 0x6f, 0xf6, 0x57, 0x29, 0x38, 0x46, 0x21, 0xc5, 0xbf, 0x90, 0xc2, 0x02,
		0x46, 0x8b, 0x03, 0x13, 0xef, 0x0b, 0x1d, 0x20, 0xc2, 0x51, 0xb5, 0x31, 0x00, 0x09, 0x80, 0xd4,
		0x29, 0x20, 0xb9, 0x1d, 0x87, 0xe8, 0xb0, 0x32, 0xe4, 0x7b, 0xfc, 0x21, 0x28, 0x0b, 0x94, 0xb5,
		0x75, 0xc8, 0xf8, 0x56, 0x82, 0xc0, 0x5b, 0xe0, 0x2d, 0xf0, 0xd6, 0x41, 0xf3, 0x96, 0xb9, 0x53,
		0xa1, 0x88, 0x1d, 0x58, 0xab, 0x68, 0x08, 0xce, 0x02, 0x67, 0xfd, 0x60, 0x15, 0x5e, 0x84, 0x7c,
		0x84, 0xfc, 0x1f, 0x3a, 0xe4, 0x9b, 0xd9, 0xad, 0x08, 0x1f, 0xfa, 0x53, 0x13, 0xb9, 0x24, 0xd9,
		0xb5, 0xe6, 0xf4, 0x75, 0xc1, 0xf9, 0xa0, 0x42, 0x36, 0x20, 0x1b, 0x3f, 0x9a, 0x6c, 0xb0, 0x38,
		0xe7, 0xd4, 0x66, 0x74, 0x97, 0xcc, 0x1b, 0xc1, 0xa1, 0xe0, 0x50, 0x9d, 0x3a, 0x54, 0xa6, 0xb4,
		0x1d, 0x9e, 0x3b, 0xf8, 0xd3, 0x39, 0x4a, 0x55, 0x28, 0x55, 0x31, 0x0d, 0xd9, 0xf9, 0xd9, 0xd9,
		0xfb, 0x9f, 0xb7, 0x36, 0xc5, 0xa2, 0x38, 0xc5, 0x36, 0x51, 0xa2, 0xe4, 0xcc, 0x5b, 0x41, 0x73,
		0xa0, 0x39, 0x9d, 0x6a, 0xce, 0xdb, 0xd8, 0x6c, 0x99, 0xe7, 0x9f, 0xfd, 0xd4, 0x0a, 0x9b, 0xa5,
		0x74, 0xc7, 0xaa, 0x36, 0x86, 0x7f, 0xc1, 0xbf, 0x1c, 0xfc, 0xeb, 0x8b, 0xd0, 0x91, 0xb0, 0x26,
		0x79, 0xca, 0x0d, 0xbf, 0x75, 0x9f, 0x94, 0x3a, 0x9b, 0x16, 0xf5, 0x16, 0x17, 0xc7, 0x1c, 0x11,
		0xda, 0x7c, 0xd2, 0xd9, 0x34, 0xff, 0x92, 0xcf, 0xa8, 0xe3, 0xa1, 0x8e, 0xf7, 0xd3, 0xd7, 0xf1,
		0x2c, 0xc5, 0x65, 0x5f, 0xb6, 0x29, 0xe4, 0xad, 0x20, 0x2c, 0x10, 0x96, 0x83, 0x17, 0x16, 0x15,
		0x49, 0x6d, 0x95, 0x7d, 0x4a, 0xe4, 0xc4, 0x45, 0x58, 0x08, 0x69, 0x61, 0xf0, 0xb9, 0xb8, 0xd4,
		0x2f, 0x22, 0x95, 0x3e, 0x6f, 0xdf, 0x2f, 0x1e, 0xa4, 0xeb, 0xcf, 0x9d, 0x8c, 0x7b, 0x92, 0x7a,
		0x7e, 0x9f, 0xd8, 0x31, 0xc9, 0xd4, 0x07, 0x1c, 0x7d, 0x1f, 0x6c, 0x6c, 0x30, 0xa5, 0x7e, 0xcf,
		0x31, 0x6e, 0x1f, 0xff, 0xcd, 0x63, 0xb5, 0x65, 0x9c, 0x82, 0x34, 0xbb, 0x7d, 0xb9, 0xa3, 0x9d,
		0xc3, 0xf4, 0x92, 0xb6, 0xd4, 0x9a, 0xed, 0x98, 0x87, 0xa5, 0xfd, 0xee, 0xf8, 0x58, 0xd3, 0x60,
		0x4b, 0x09, 0xb2, 0xe4, 0xe0, 0x4a, 0x0d, 0xaa, 0xce, 0xc1, 0xd4, 0x39, 0x88, 0xba, 0x04, 0x4f,
		0x3f, 0x3f, 0xba, 0x56, 0x49, 0x43, 0x07, 0xaa, 0x58, 0x05, 0x5d, 0xc7, 0x6b, 0xad, 0x69, 0x7a,
		0x3e, 0x84, 0x9e, 0x43, 0xcf, 0x29, 0xa6, 0x5a, 0x36, 0x08, 0x97, 0x16, 0xe1, 0xa8, 0x90, 0x45,
		0x7b, 0xb7, 0xb3, 0x81, 0x86, 0x38, 0x1b, 0xa8, 0x03, 0xf3, 0x66, 0x33, 0x73, 0x0e, 0x73, 0x77,
		0xac, 0xb3, 0x13, 0xe7, 0x9b, 0xea, 0x06, 0x65, 0x43, 0x97, 0x53, 0x0b, 0x36, 0x5a, 0x0c, 0xfd,
		0x14, 0x03, 0xcf, 0x7c, 0x8d, 0xcd, 0x61, 0x38, 0x1c, 0x87, 0xcd, 0x81, 0xb8, 0x1c, 0x89, 0xdd,
		0xa1, 0xd8, 0x1d, 0x8b, 0xd3, 0xc1, 0xdc, 0x1c, 0xcd, 0xd1, 0xe1, 0xdc, 0x73, 0xc3, 0xcd, 0x34,
		0x44, 0x5d, 0x18, 0xd8, 0x28, 0x32, 0x97, 0x1d, 0x1d, 0x34, 0xe4, 0xb2, 0xe2, 0x4a, 0x3d, 0xc5,
		0x61, 0x4b, 0xcd, 0x96, 0x72, 0xaa, 0xc3, 0x6a, 0xc0, 0x74, 0x3a, 0xe5, 0x01, 0xe1, 0x0a, 0xe1,
		0x0a, 0xe1, 0xca, 0x71, 0x33, 0xda, 0xc6, 0x78, 0x35, 0x3c, 0xe0, 0x78, 0x45, 0x3b, 0xe3, 0x62,
		0x4b, 0x5d, 0xad, 0xf9, 0x89, 0x17, 0xdb, 0x62, 0xd5, 0x09, 0x02, 0x15, 0x02, 0x15, 0x02, 0x15,
		0xc5, 0x5a, 0xc8, 0xa7, 0x7e, 0x6c, 0xf2, 0x9d, 0x0b, 0x8f, 0x2e, 0xfc, 0x4e, 0x40, 0x5d, 0xfe,
		0xf3, 0x33, 0xd7, 0x23, 0xae, 0x13, 0x51, 0x99, 0x82, 0xca, 0x4a, 0x77, 0x4c, 0x27, 0xa4, 0x96,
		0xfd, 0x31, 0x9e, 0xdd, 0xe9, 0x69, 0xce, 0xf5, 0x29, 0x60, 0x38, 0x39, 0xb5, 0xed, 0x29, 0xf0,
		0x3d, 0xa5, 0xa4, 0x93, 0xb9, 0xe8, 0xed, 0xa7, 0xf5, 0xb8, 0x2b, 0x5c, 0x69, 0xb5, 0x62, 0x44,
		0xde, 0x32, 0xe2, 0x17, 0x84, 0x5a, 0xd9, 0x42, 0xb2, 0x41, 0x37, 0x1d, 0xf6, 0x4a, 0xac, 0x15,
		0xcc, 0xb6, 0x8b, 0x7c, 0x63, 0x6a, 0xd1, 0xdd, 0xed, 0xfc, 0xd6, 0xb2, 0xbd, 0xc7, 0x72, 0x67,
		0x75, 0xf5, 0xaf, 0xf6, 0xdb, 0xc0, 0xa9, 0x1e, 0x7e, 0xe4, 0xb5, 0x34, 0x5a, 0xfd, 0x32, 0xb5,
		0xdf, 0x6e, 0x0a, 0x4c, 0x3d, 0x80, 0xd7, 0x12, 0xb8, 0xe5, 0x0d, 0x5e, 0xf9, 0x02, 0x5e, 0x40,
		0xb0, 0x0f, 0x76, 0xc7, 0x0b, 0x08, 0x08, 0xb3, 0x1d, 0x4b, 0x31, 0xa1, 0xed, 0x85, 0x59, 0x29,
		0x16, 0x38, 0x50, 0x78, 0xf0, 0x47, 0x11, 0xf2, 0xde, 0xbd, 0x2b, 0xc2, 0xd5, 0x60, 0xe1, 0x5f,
		0x07, 0x10, 0x27, 0x16, 0x1b, 0x49, 0x9c, 0xe3, 0x44, 0xd3, 0x7d, 0x28, 0x6b, 0x87, 0xd2, 0x35,
		0x4e, 0x9c, 0x22, 0x4e, 0x20, 0x4e, 0x6c, 0xab, 0x57, 0xb9, 0x2e, 0x46, 0x8a, 0x68, 0xaa, 0x34,
		0xf5, 0xb1, 0x83, 0x8d, 0x26, 0x53, 0xeb, 0x0d, 0x65, 0x33, 0x94, 0xcd, 0x7e, 0x82, 0xb2, 0x99,
		0xc3, 0xf6, 0xd6, 0x16, 0x4b, 0x6f, 0x6e, 0xcf, 0x55, 0x6c, 0xd4, 0xab, 0x91, 0x47, 0x1f, 0xb4,
		0xe7, 0x2e, 0xb8, 0xa6, 0xc3, 0x39, 0xc9, 0xe6, 0xa9, 0xf8, 0xb5, 0x9a, 0x74, 0xf3, 0x27, 0xdf,
		0x4c, 0x49, 0x38, 0x43, 0xad, 0x8e, 0x7d, 0xd8, 0xdd, 0x9f, 0x03, 0xc1, 0x70, 0x63, 0xb8, 0xf9,
		0x74, 0x65, 0xdc, 0xc9, 0xa2, 0x69, 0xf9, 0xc2, 0x1f, 0x6f, 0x86, 0x73, 0x78, 0x75, 0x10, 0x43,
		0xaa, 0x03, 0x7e, 0x03, 0xbf, 0xed, 0x87, 0xdf, 0x5c, 0x53, 0xa7, 0x17, 0xd7, 0x13, 0x49, 0xa2,
		0x64, 0xd2, 0xb7, 0x89, 0xd0, 0xa9, 0xca, 0x43, 0x60, 0xea, 0x3f, 0xe1, 0xa5, 0x37, 0xae, 0xe9,
		0xfc, 0xf8, 0x20, 0xde, 0x00, 0xe8, 0xeb, 0xa8, 0x9c, 0x0e, 0xcb, 0xee, 0xb8, 0xdc, 0x0e, 0xdc,
		0x9a, 0x23, 0xb7, 0xe6, 0xd0, 0x6d, 0x38, 0xb6, 0x9f, 0x83, 0x33, 0x50, 0x0f, 0x4f, 0xb2, 0xb5,
		0x49, 0x32, 0x9d, 0x5e, 0xf2, 0xba, 0xc9, 0x3d, 0x2f, 0x19, 0xba, 0xe2, 0xd9, 0x02, 0xc1, 0x83,
		0x8c, 0xf5, 0x9c, 0x99, 0x71, 0x4b, 0x04, 0x73, 0x5c, 0x5b, 0xe9, 0x96, 0x79, 0x8b, 0x44, 0xd9,
		0x6f, 0x0b, 0xcb, 0xf3, 0x4c, 0x1e, 0xf2, 0xaa, 0xbc, 0xf1, 0xf8, 0xe6, 0xa6, 0x8a, 0xff, 0xa5,
		0xb4, 0x9d, 0xce, 0x5e, 0xef, 0x30, 0x7a, 0x19, 0xef, 0x35, 0x4a, 0x7b, 0xd7, 0x71, 0x78, 0xc3,
		0x56, 0x27, 0x75, 0x9d, 0xf6, 0x32, 0x60, 0xe6, 0x4c, 0x98, 0xc7, 0xc8, 0xc6, 0x7b, 0x79, 0x8b,
		0xb6, 0xd2, 0xfd, 0xdb, 0xc4, 0x88, 0x28, 0x14, 0xa9, 0xed, 0xcf, 0x1e, 0x2c, 0x23, 0xac, 0xaf,
		0x76, 0x0d, 0x54, 0x07, 0xaa, 0x03, 0xd5, 0x81, 0xea, 0x40, 0x75, 0xa0, 0x3a, 0x50, 0x1d, 0xa8,
		0x7e, 0x98, 0xa8, 0xbe, 0x2f, 0x0e, 0x8b, 0x54, 0x1a, 0x8a, 0x24, 0xe2, 0x25, 0xb0, 0xb2, 0x53,
		0xb0, 0x17, 0xd8, 0x0b, 0xec, 0x05, 0xf6, 0x02, 0x7b, 0x81, 0xbd, 0xc0, 0x5e, 0x60, 0x2f, 0xb0,
		0x57, 0x95, 0xbd, 0x64, 0x92, 0x98, 0x84, 0x97, 0xbc, 0x8a, 0x2e, 0xc1, 0x5d, 0xe0, 0x2e, 0x70,
		0x17, 0xb8, 0x0b, 0xdc, 0x05, 0xee, 0x02, 0x77, 0x81, 0xbb, 0xc0, 0x5d, 0x55, 0xee, 0x9a, 0x84,
		0x69, 0x1b, 0xec, 0x55, 0xe9, 0x16, 0xfc, 0x05, 0xfe, 0x02, 0x7f, 0x81, 0xbf, 0xc0, 0x5f, 0xe0,
		0x2f, 0xf0, 0x17, 0xf8, 0x0b, 0xfc, 0x55, 0xe5, 0xaf, 0x69, 0x16, 0x5b, 0xd5, 0xce, 0xde, 0xaf,
		0x57, 0x5d, 0x83, 0xc3, 0xc0, 0x61, 0xe0, 0x30, 0x70, 0x18, 0x38, 0x0c, 0x1c, 0x06, 0x0e, 0x03,
		0x87, 0x81, 0xc3, 0xaa, 0x1c, 0x66, 0x42, 0x2b, 0x99, 0xf9, 0xab, 0xe8, 0x12, 0xdc, 0x05, 0xee,
		0x02, 0x77, 0x81, 0xbb, 0xc0, 0x5d, 0xe0, 0x2e, 0x70, 0x17, 0xb8, 0x0b, 0xdc, 0x55, 0xe5, 0x2e,
		0xf6, 0xaa, 0x17, 0x6a, 0x5d, 0x60, 0x2e, 0x30, 0x17, 0x98, 0x0b, 0xcc, 0x05, 0xe6, 0x02, 0x73,
		0x81, 0xb9, 0xc0, 0x5c, 0x2b, 0xcc, 0x95, 0xe9, 0x96, 0x56, 0x1c, 0x6b, 0x1d, 0x83, 0xc1, 0xc0,
		0x60, 0x60, 0x30, 0x30, 0x18, 0x18, 0x0c, 0x0c, 0x06, 0x06, 0x03, 0x83, 0x81, 0xc1, 0xea, 0x0c,
		0xf6, 0xa0, 0xcd, 0x77, 0xdd, 0x9f, 0x25, 0xc6, 0x1a, 0x6e, 0x0a, 0xab, 0x75, 0x0d, 0x0e, 0x03,
		0x87, 0x81, 0xc3, 0xc0, 0x61, 0xe0, 0x30, 0x70, 0x18, 0x38, 0x0c, 0x1c, 0x06, 0x0e, 0x2b, 0xa7,
		0x25, 0x16, 0xa9, 0xed, 0x87, 0xb1, 0x14, 0x09, 0x1f, 0x80, 0x55, 0xfa, 0x04, 0x79, 0x81, 0xbc,
		0x40, 0x5e, 0x07, 0x44, 0x5e, 0x56, 0x4d, 0xa5, 0x55, 0xe1, 0x43, 0x7a, 0x70, 0xec, 0xf5, 0xb7,
		0x5e, 0xe8, 0x42, 0xa0, 0x85, 0x36, 0xa9, 0x0c, 0x8d, 0xf6, 0x3e, 0x31, 0x10, 0x4c, 0x07, 0xa6,
		0x03, 0xd3, 0x81, 0xe9, 0xf6, 0xc7, 0x74, 0x78, 0xe5, 0x02, 0x17, 0x26, 0xe0, 0x95, 0x0b, 0x9c,
		0xd8, 0x6f, 0x32, 0xdb, 0xda, 0x3b, 0x17, 0xd6, 0xf4, 0x8d, 0x34, 0x00, 0x69, 0x00, 0xd2, 0x80,
		0x03, 0x4a, 0x03, 0x50, 0x80, 0x05, 0xac, 0x03, 0xd6, 0x01, 0xeb, 0x80, 0x75, 0x8e, 0xeb, 0xfb,
		0x92, 0x18, 0xff, 0x5b, 0x17, 0x6a, 0xbd, 0x82, 0xbe, 0x40, 0x5f, 0xa0, 0x2f, 0xd0, 0x17, 0xe8,
		0x0b, 0xf4, 0x05, 0xfa, 0x02, 0x7d, 0x81, 0xbe, 0x6a, 0xf4, 0xc5, 0x7d, 0xf6, 0x6f, 0xa5, 0x4f,
		0x90, 0x17, 0xc8, 0x0b, 0xe4, 0x05, 0xf2, 0x02, 0x79, 0x81, 0xbc, 0x40, 0x5e, 0x20, 0x2f, 0x90,
		0x57, 0x8d, 0xbc, 0xda, 0x3a, 0xf9, 0x77, 0x4d, 0xdf, 0x20, 0x31, 0x90, 0x18, 0x48, 0x0c, 0x24,
		0x06, 0x12, 0x03, 0x89, 0x81, 0xc4, 0x40, 0x62, 0x20, 0xb1, 0x1a, 0x89, 0x71, 0x9f, 0xfd, 0x5b,
		0xe9, 0x13, 0xe4, 0x05, 0xf2, 0x02, 0x79, 0x81, 0xbc, 0x40, 0x5e, 0x20, 0x2f, 0x90, 0x17, 0xc8,
		0x0b, 0xe4, 0x55, 0x23, 0x2f, 0xfe, 0xca, 0x17, 0xea, 0x5d, 0xa0, 0x2e, 0x50, 0x17, 0xa8, 0x0b,
		0xd4, 0x05, 0xea, 0x02, 0x75, 0x81, 0xba, 0x40, 0x5d, 0xab, 0xd4, 0xd5, 0xce, 0xf9, 0xbf, 0x2b,
		0x3d, 0x83, 0xc2, 0x40, 0x61, 0xa0, 0x30, 0x50, 0x18, 0x28, 0x0c, 0x14, 0x06, 0x0a, 0x03, 0x85,
		0xfd, 0x68, 0x14, 0xd6, 0xeb, 0xd0, 0xe6, 0xfd, 0x0f, 0x43, 0xf1, 0xa4, 0xbc, 0xd5, 0xc3, 0x4f,
		0xcc, 0x4c, 0x26, 0x22, 0xb7, 0x2d, 0x11, 0xfb, 0xa2, 0x1e, 0xfb, 0x61, 0x27, 0x4c, 0x87, 0x9c,
		0x78, 0x04, 0x28, 0x0c, 0x77, 0x57, 0x1e, 0x35, 0x76, 0xf4, 0xa8, 0x8f, 0x5a, 0x1b, 0x3b, 0x1f,
		0x51, 0x2f, 0xe1, 0x08, 0xd2, 0xf0, 0x5e, 0x4e, 0xc5, 0x4c, 0xd8, 0xfb, 0xfc, 0xee, 0x07, 0x66,
		0x26, 0x75, 0x38, 0xcf, 0x39, 0xfa, 0x2a, 0xa7, 0xad, 0x89, 0x08, 0x65, 0x3a, 0x58, 0xf7, 0xe3,
		0x20, 0xcd, 0x6e, 0x2b, 0x7f, 0xaf, 0xfe, 0x36, 0x48, 0xad, 0xb0, 0x72, 0x50, 0x00, 0x9b, 0x4f,
		0x2a, 0x15, 0xa4, 0x36, 0xc9, 0x42, 0xab, 0x0b, 0x04, 0xfc, 0x5a, 0x7e, 0xbb, 0xcf, 0xe5, 0x95,
		0x6f, 0xd6, 0xfd, 0x78, 0xf3, 0xad, 0xfa, 0xe5, 0x6a, 0xbf, 0xdd, 0x7c, 0xcb, 0xbf, 0xdc, 0xcd,
		0xaf, 0xcb, 0x2f, 0xd7, 0xeb, 0x66, 0xae, 0x1d, 0x9c, 0x31, 0x88, 0x64, 0x1a, 0x26, 0x6a, 0xe6,
		0x35, 0xc9, 0x25, 0x3e, 0x57, 0x3b, 0x73, 0xb4, 0x39, 0x3f, 0xa0, 0xf0, 0xce, 0x65, 0x39, 0x72,
		0x58, 0xb6, 0xdc, 0x95, 0x2b, 0x67, 0x65, 0xcf, 0x55, 0xd9, 0x73, 0x54, 0xce, 0xdc, 0xb4, 0x5b,
		0xea, 0xf0, 0xce, 0x41, 0x4b, 0x6b, 0x49, 0x6d, 0xa2, 0xf4, 0x9d, 0x8f, 0xb9, 0x14, 0xbe, 0x33,
		0xbc, 0x3c, 0xe0, 0x78, 0x23, 0xb5, 0xb8, 0x8d, 0x65, 0xe4, 0x1f, 0x6b, 0x96, 0x1d, 0x39, 0xce,
		0xdb, 0xb5, 0x9c, 0x88, 0x2c, 0x9e, 0xdb, 0x5b, 0x6e, 0xbe, 0x08, 0x57, 0x08, 0x57, 0x08, 0x57,
		0x14, 0x6b, 0xb9, 0x35, 0x26, 0x96, 0x42, 0x73, 0xc4, 0xab, 0xe1, 0x01, 0xc7, 0x2b, 0x35, 0x51,
		0x3a, 0x92, 0x8f, 0xfe, 0xf1, 0x6a, 0xd9, 0x11, 0x02, 0x0d, 0x02, 0x0d, 0x02, 0x0d, 0xc1, 0x5a,
		0x32, 0xa5, 0xed, 0xfb, 0x53, 0x86, 0x38, 0x73, 0xe1, 0xd1, 0x05, 0x4f, 0x01, 0x9e, 0x61, 0xa5,
		0x82, 0xb3, 0xe0, 0xce, 0x5c, 0xbd, 0xe5, 0x2e, 0xb0, 0xb7, 0x51, 0x9a, 0x65, 0x28, 0xa8, 0xb3,
		0x16, 0xd2, 0xdb, 0x9a, 0x82, 0xd1, 0xe9, 0xd5, 0xe8, 0xea, 0xfc, 0xe2, 0xf4, 0xea, 0xec, 0x80,
		0xe7, 0x62, 0x4f, 0x65, 0xe9, 0xf1, 0x4f, 0x5e, 0x96, 0xe6, 0x3f, 0x93, 0x1b, 0xe5, 0xe9, 0x06,
		0xc3, 0x8e, 0xd5, 0x00, 0x0c, 0x37, 0xf3, 0x70, 0xf7, 0xba, 0x09, 0x7f, 0x4e, 0x79, 0x13, 0x53,
		0xd6, 0xe4, 0x93, 0x33, 0x55, 0x6a, 0x3c, 0x27, 0xc8, 0xbb, 0x90, 0x77, 0x21, 0xef, 0x42, 0xde,
		0x85, 0xbc, 0x0b, 0x79, 0x17, 0xf2, 0xae, 0xb7, 0x94, 0x77, 0x75, 0x82, 0x2b, 0x8b, 0x77, 0x52,
		0xde, 0x17, 0xd1, 0xc6, 0x13, 0x5a, 0xaa, 0x9d, 0x01, 0x3b, 0x80, 0x1d, 0xc0, 0x0e, 0x82, 0xb5,
		0xf0, 0xbc, 0x81, 0x92, 0x61, 0xf3, 0x35, 0xf7, 0x1b, 0x27, 0xc1, 0x32, 0x60, 0x99, 0x37, 0xc5,
		0x32, 0xed, 0x6d, 0xbe, 0x06, 0xd5, 0xa0, 0x9a, 0xfc, 0x16, 0xeb, 0x6d, 0x28, 0x6f, 0x62, 0xb8,
		0x51, 0x4d, 0xf6, 0x0c, 0x7f, 0x4e, 0xe9, 0x99, 0xb9, 0x53, 0xa1, 0x88, 0x19, 0x52, 0xb3, 0xa2,
		0x23, 0xa4, 0x65, 0x48, 0xcb, 0x90, 0x96, 0x11, 0xac, 0x65, 0xff, 0xdb, 0xfd, 0x40, 0x4c, 0x90,
		0x70, 0x48, 0x38, 0x86, 0x1b, 0xc4, 0xd4, 0xe4, 0x0e, 0x8b, 0xc7, 0xd9, 0x3c, 0x71, 0x69, 0xde,
		0x0b, 0x58, 0x09, 0xac, 0x04, 0x56, 0x22, 0x58, 0xcb, 0xde, 0x9f, 0xe4, 0x02, 0x2a, 0x41, 0xbb,
		0xa1, 0xdd, 0x6f, 0x56, 0xbb, 0xf3, 0xe1, 0xef, 0xa7, 0x56, 0xd8, 0x2c, 0xf5, 0x97, 0xf0, 0x6a,
		0x67, 0x50, 0x72, 0x28, 0xf9, 0x4f, 0xa0, 0xe4, 0x5f, 0x84, 0x8e, 0x84, 0x35, 0xc9, 0x53, 0x2e,
		0xa1, 0x7b, 0xa7, 0x01, 0xa9, 0xb3, 0x69, 0x11, 0x4e, 0x39, 0x90, 0x60, 0xe4, 0xd1, 0xc7, 0x27,
		0x9d, 0x4d, 0xf3, 0x9b, 0x7a, 0x06, 0x56, 0x00, 0x2b, 0x80, 0x15, 0x18, 0x6e, 0x50, 0x5c, 0x1b,
		0xd7, 0x21, 0x1a, 0x81, 0xef, 0x39, 0x4b, 0x2d, 0x9e, 0xaf, 0xe4, 0x60, 0x37, 0xad, 0x1d, 0xa7,
		0x44, 0xb3, 0x92, 0xe6, 0x33, 0xd6, 0xec, 0x93, 0x0d, 0xe7, 0x34, 0x77, 0x43, 0xea, 0x73, 0x2b,
		0xc1, 0xff, 0xab, 0xd4, 0x7e, 0xb4, 0x36, 0x21, 0xcd, 0x7e, 0xf0, 0x45, 0xe9, 0x4f, 0xb9, 0x8c,
		0xe9, 0xc5, 0x06, 0x9a, 0x63, 0x42, 0x4b, 0xf1, 0x58, 0x69, 0xe9, 0xb7, 0xcd, 0x27, 0xf8, 0x9a,
		0x44, 0x32, 0x91, 0xd1, 0x2f, 0xf9, 0x6d, 0xeb, 0x2c, 0x8e, 0x59, 0x47, 0xd3, 0xd1, 0x33, 0x5a,
		0xf1, 0x08, 0x82, 0x2f, 0xb4, 0xe0, 0x03, 0xcd, 0xac, 0x7f, 0xb7, 0x2d, 0x6f, 0xff, 0xc4, 0x8e,
		0x79, 0xa1, 0xce, 0x07, 0xd7, 0x3c, 0x34, 0x18, 0x7a, 0x9e, 0x21, 0xdf, 0x3e, 0xca, 0x9b, 0xc7,
		0x6e, 0xfd, 0xff, 0x6c, 0x18, 0xcd, 0x65, 0x8c, 0xd8, 0x52, 0x5c, 0x6f, 0x16, 0x12, 0x9a, 0x87,
		0x00, 0x2f, 0x97, 0x6f, 0xe6, 0xe2, 0x9b, 0x6e, 0xb6, 0xa1, 0xc9, 0xb8, 0x9b, 0xca, 0x16, 0xe3,
		0x70, 0x35, 0x8a, 0xf5, 0x66, 0xb0, 0x3a, 0xc9, 0xf5, 0xbf, 0xbc, 0x1a, 0x81, 0x5d, 0x77, 0x4e,
		0xbd, 0xe3, 0x35, 0xf7, 0x49, 0xbb, 0xbf, 0xfa, 0x5d, 0xbd, 0x7c, 0xf7, 0xc5, 0x4f, 0xc5, 0xb7,
		0xdf, 0xf4, 0xad, 0x03, 0x95, 0xfe, 0x26, 0x1e, 0xe4, 0x9f, 0xc6, 0xac, 0x56, 0x17, 0x5e, 0xdf,
		0x49, 0x50, 0xfd, 0xaf, 0xda, 0x37, 0xbc, 0x96, 0xff, 0xa8, 0xe5, 0xf0, 0x3e, 0xf7, 0x9e, 0xff,
		0x07, 0x00, 0x00, 0xff, 0xff, 0x01, 0x00, 0x00, 0xff, 0xff, 0x16, 0xc7, 0x28, 0x39, 0x17, 0x5a,
		0x02, 0x00,
	}
)

// ΛEnumTypes is a map, keyed by a YANG schema path, of the enumerated types that
// correspond with the leaf. The type is represented as a reflect.Type. The naming
// of the map ensures that there are no clashes with valid YANG identifiers.
var ΛEnumTypes = map[string][]reflect.Type{
	"/interfaces/interface/config/type": []reflect.Type{
		reflect.TypeOf((E_IETFInterfaces_InterfaceType)(0)),
	},
	"/interfaces/interface/state/admin-status": []reflect.Type{
		reflect.TypeOf((E_OpenconfigInterfaces_Interfaces_Interface_State_AdminStatus)(0)),
	},
	"/interfaces/interface/state/oper-status": []reflect.Type{
		reflect.TypeOf((E_OpenconfigInterfaces_Interfaces_Interface_State_OperStatus)(0)),
	},
	"/interfaces/interface/state/type": []reflect.Type{
		reflect.TypeOf((E_IETFInterfaces_InterfaceType)(0)),
	},
	"/interfaces/interface/subinterfaces/subinterface/state/admin-status": []reflect.Type{
		reflect.TypeOf((E_OpenconfigInterfaces_Interfaces_Interface_State_AdminStatus)(0)),
	},
	"/interfaces/interface/subinterfaces/subinterface/state/oper-status": []reflect.Type{
		reflect.TypeOf((E_OpenconfigInterfaces_Interfaces_Interface_State_OperStatus)(0)),
	},
}