// Code generated by "enumer -type=ARPAllTargets,ARPValidate,AddressFlag,AddressSortAlgorithm,ADSelect,ADLACPActive,AutoHostnameKind,BondMode,BondXmitHashPolicy,ClientIdentifier,ConntrackState,DefaultAction,Duplex,Family,LACPRate,LinkFlag,LinkType,MatchOperator,NfTablesChainHook,NfTablesChainPriority,NfTablesVerdict,OperationalState,Port,PrimaryReselect,Protocol,RouteFlag,RouteProtocol,RouteType,RoutingRuleAction,RoutingTable,Scope,Status,VLANProtocol,WOLMode -linecomment -text"; DO NOT EDIT.

package nethelpers

import (
	"fmt"
	"strings"
)

const _ARPAllTargetsName = "anyall"

var _ARPAllTargetsIndex = [...]uint8{0, 3, 6}

const _ARPAllTargetsLowerName = "anyall"

func (i ARPAllTargets) String() string {
	if i >= ARPAllTargets(len(_ARPAllTargetsIndex)-1) {
		return fmt.Sprintf("ARPAllTargets(%d)", i)
	}
	return _ARPAllTargetsName[_ARPAllTargetsIndex[i]:_ARPAllTargetsIndex[i+1]]
}

// An "invalid array index" compiler error signifies that the constant values have changed.
// Re-run the stringer command to generate them again.
func _ARPAllTargetsNoOp() {
	var x [1]struct{}
	_ = x[ARPAllTargetsAny-(0)]
	_ = x[ARPAllTargetsAll-(1)]
}

var _ARPAllTargetsValues = []ARPAllTargets{ARPAllTargetsAny, ARPAllTargetsAll}

var _ARPAllTargetsNameToValueMap = map[string]ARPAllTargets{
	_ARPAllTargetsName[0:3]:      ARPAllTargetsAny,
	_ARPAllTargetsLowerName[0:3]: ARPAllTargetsAny,
	_ARPAllTargetsName[3:6]:      ARPAllTargetsAll,
	_ARPAllTargetsLowerName[3:6]: ARPAllTargetsAll,
}

var _ARPAllTargetsNames = []string{
	_ARPAllTargetsName[0:3],
	_ARPAllTargetsName[3:6],
}

// ARPAllTargetsString retrieves an enum value from the enum constants string name.
// Throws an error if the param is not part of the enum.
func ARPAllTargetsString(s string) (ARPAllTargets, error) {
	if val, ok := _ARPAllTargetsNameToValueMap[s]; ok {
		return val, nil
	}

	if val, ok := _ARPAllTargetsNameToValueMap[strings.ToLower(s)]; ok {
		return val, nil
	}
	return 0, fmt.Errorf("%s does not belong to ARPAllTargets values", s)
}

// ARPAllTargetsValues returns all values of the enum
func ARPAllTargetsValues() []ARPAllTargets {
	return _ARPAllTargetsValues
}

// ARPAllTargetsStrings returns a slice of all String values of the enum
func ARPAllTargetsStrings() []string {
	strs := make([]string, len(_ARPAllTargetsNames))
	copy(strs, _ARPAllTargetsNames)
	return strs
}

// IsAARPAllTargets returns "true" if the value is listed in the enum definition. "false" otherwise
func (i ARPAllTargets) IsAARPAllTargets() bool {
	for _, v := range _ARPAllTargetsValues {
		if i == v {
			return true
		}
	}
	return false
}

// MarshalText implements the encoding.TextMarshaler interface for ARPAllTargets
func (i ARPAllTargets) MarshalText() ([]byte, error) {
	return []byte(i.String()), nil
}

// UnmarshalText implements the encoding.TextUnmarshaler interface for ARPAllTargets
func (i *ARPAllTargets) UnmarshalText(text []byte) error {
	var err error
	*i, err = ARPAllTargetsString(string(text))
	return err
}

const _ARPValidateName = "noneactivebackupallfilterfilter-activefilter-backup"

var _ARPValidateIndex = [...]uint8{0, 4, 10, 16, 19, 25, 38, 51}

const _ARPValidateLowerName = "noneactivebackupallfilterfilter-activefilter-backup"

func (i ARPValidate) String() string {
	if i >= ARPValidate(len(_ARPValidateIndex)-1) {
		return fmt.Sprintf("ARPValidate(%d)", i)
	}
	return _ARPValidateName[_ARPValidateIndex[i]:_ARPValidateIndex[i+1]]
}

// An "invalid array index" compiler error signifies that the constant values have changed.
// Re-run the stringer command to generate them again.
func _ARPValidateNoOp() {
	var x [1]struct{}
	_ = x[ARPValidateNone-(0)]
	_ = x[ARPValidateActive-(1)]
	_ = x[ARPValidateBackup-(2)]
	_ = x[ARPValidateAll-(3)]
	_ = x[ARPValidateFilter-(4)]
	_ = x[ARPValidateFilterActive-(5)]
	_ = x[ARPValidateFilterBackup-(6)]
}

var _ARPValidateValues = []ARPValidate{ARPValidateNone, ARPValidateActive, ARPValidateBackup, ARPValidateAll, ARPValidateFilter, ARPValidateFilterActive, ARPValidateFilterBackup}

var _ARPValidateNameToValueMap = map[string]ARPValidate{
	_ARPValidateName[0:4]:        ARPValidateNone,
	_ARPValidateLowerName[0:4]:   ARPValidateNone,
	_ARPValidateName[4:10]:       ARPValidateActive,
	_ARPValidateLowerName[4:10]:  ARPValidateActive,
	_ARPValidateName[10:16]:      ARPValidateBackup,
	_ARPValidateLowerName[10:16]: ARPValidateBackup,
	_ARPValidateName[16:19]:      ARPValidateAll,
	_ARPValidateLowerName[16:19]: ARPValidateAll,
	_ARPValidateName[19:25]:      ARPValidateFilter,
	_ARPValidateLowerName[19:25]: ARPValidateFilter,
	_ARPValidateName[25:38]:      ARPValidateFilterActive,
	_ARPValidateLowerName[25:38]: ARPValidateFilterActive,
	_ARPValidateName[38:51]:      ARPValidateFilterBackup,
	_ARPValidateLowerName[38:51]: ARPValidateFilterBackup,
}

var _ARPValidateNames = []string{
	_ARPValidateName[0:4],
	_ARPValidateName[4:10],
	_ARPValidateName[10:16],
	_ARPValidateName[16:19],
	_ARPValidateName[19:25],
	_ARPValidateName[25:38],
	_ARPValidateName[38:51],
}

// ARPValidateString retrieves an enum value from the enum constants string name.
// Throws an error if the param is not part of the enum.
func ARPValidateString(s string) (ARPValidate, error) {
	if val, ok := _ARPValidateNameToValueMap[s]; ok {
		return val, nil
	}

	if val, ok := _ARPValidateNameToValueMap[strings.ToLower(s)]; ok {
		return val, nil
	}
	return 0, fmt.Errorf("%s does not belong to ARPValidate values", s)
}

// ARPValidateValues returns all values of the enum
func ARPValidateValues() []ARPValidate {
	return _ARPValidateValues
}

// ARPValidateStrings returns a slice of all String values of the enum
func ARPValidateStrings() []string {
	strs := make([]string, len(_ARPValidateNames))
	copy(strs, _ARPValidateNames)
	return strs
}

// IsAARPValidate returns "true" if the value is listed in the enum definition. "false" otherwise
func (i ARPValidate) IsAARPValidate() bool {
	for _, v := range _ARPValidateValues {
		if i == v {
			return true
		}
	}
	return false
}

// MarshalText implements the encoding.TextMarshaler interface for ARPValidate
func (i ARPValidate) MarshalText() ([]byte, error) {
	return []byte(i.String()), nil
}

// UnmarshalText implements the encoding.TextUnmarshaler interface for ARPValidate
func (i *ARPValidate) UnmarshalText(text []byte) error {
	var err error
	*i, err = ARPValidateString(string(text))
	return err
}

const _AddressFlagName = "temporarynodadoptimisticdadfailedhomeaddressdeprecatedtentativepermanentmngmtmpaddrnoprefixroutemcautojoinstableprivacy"
const _AddressFlagLowerName = "temporarynodadoptimisticdadfailedhomeaddressdeprecatedtentativepermanentmngmtmpaddrnoprefixroutemcautojoinstableprivacy"

var _AddressFlagMap = map[AddressFlag]string{
	1:    _AddressFlagName[0:9],
	2:    _AddressFlagName[9:14],
	4:    _AddressFlagName[14:24],
	8:    _AddressFlagName[24:33],
	16:   _AddressFlagName[33:44],
	32:   _AddressFlagName[44:54],
	64:   _AddressFlagName[54:63],
	128:  _AddressFlagName[63:72],
	256:  _AddressFlagName[72:83],
	512:  _AddressFlagName[83:96],
	1024: _AddressFlagName[96:106],
	2048: _AddressFlagName[106:119],
}

func (i AddressFlag) String() string {
	if str, ok := _AddressFlagMap[i]; ok {
		return str
	}
	return fmt.Sprintf("AddressFlag(%d)", i)
}

// An "invalid array index" compiler error signifies that the constant values have changed.
// Re-run the stringer command to generate them again.
func _AddressFlagNoOp() {
	var x [1]struct{}
	_ = x[AddressTemporary-(1)]
	_ = x[AddressNoDAD-(2)]
	_ = x[AddressOptimistic-(4)]
	_ = x[AddressDADFailed-(8)]
	_ = x[AddressHome-(16)]
	_ = x[AddressDeprecated-(32)]
	_ = x[AddressTentative-(64)]
	_ = x[AddressPermanent-(128)]
	_ = x[AddressManagementTemp-(256)]
	_ = x[AddressNoPrefixRoute-(512)]
	_ = x[AddressMCAutoJoin-(1024)]
	_ = x[AddressStablePrivacy-(2048)]
}

var _AddressFlagValues = []AddressFlag{AddressTemporary, AddressNoDAD, AddressOptimistic, AddressDADFailed, AddressHome, AddressDeprecated, AddressTentative, AddressPermanent, AddressManagementTemp, AddressNoPrefixRoute, AddressMCAutoJoin, AddressStablePrivacy}

var _AddressFlagNameToValueMap = map[string]AddressFlag{
	_AddressFlagName[0:9]:          AddressTemporary,
	_AddressFlagLowerName[0:9]:     AddressTemporary,
	_AddressFlagName[9:14]:         AddressNoDAD,
	_AddressFlagLowerName[9:14]:    AddressNoDAD,
	_AddressFlagName[14:24]:        AddressOptimistic,
	_AddressFlagLowerName[14:24]:   AddressOptimistic,
	_AddressFlagName[24:33]:        AddressDADFailed,
	_AddressFlagLowerName[24:33]:   AddressDADFailed,
	_AddressFlagName[33:44]:        AddressHome,
	_AddressFlagLowerName[33:44]:   AddressHome,
	_AddressFlagName[44:54]:        AddressDeprecated,
	_AddressFlagLowerName[44:54]:   AddressDeprecated,
	_AddressFlagName[54:63]:        AddressTentative,
	_AddressFlagLowerName[54:63]:   AddressTentative,
	_AddressFlagName[63:72]:        AddressPermanent,
	_AddressFlagLowerName[63:72]:   AddressPermanent,
	_AddressFlagName[72:83]:        AddressManagementTemp,
	_AddressFlagLowerName[72:83]:   AddressManagementTemp,
	_AddressFlagName[83:96]:        AddressNoPrefixRoute,
	_AddressFlagLowerName[83:96]:   AddressNoPrefixRoute,
	_AddressFlagName[96:106]:       AddressMCAutoJoin,
	_AddressFlagLowerName[96:106]:  AddressMCAutoJoin,
	_AddressFlagName[106:119]:      AddressStablePrivacy,
	_AddressFlagLowerName[106:119]: AddressStablePrivacy,
}

var _AddressFlagNames = []string{
	_AddressFlagName[0:9],
	_AddressFlagName[9:14],
	_AddressFlagName[14:24],
	_AddressFlagName[24:33],
	_AddressFlagName[33:44],
	_AddressFlagName[44:54],
	_AddressFlagName[54:63],
	_AddressFlagName[63:72],
	_AddressFlagName[72:83],
	_AddressFlagName[83:96],
	_AddressFlagName[96:106],
	_AddressFlagName[106:119],
}

// AddressFlagString retrieves an enum value from the enum constants string name.
// Throws an error if the param is not part of the enum.
func AddressFlagString(s string) (AddressFlag, error) {
	if val, ok := _AddressFlagNameToValueMap[s]; ok {
		return val, nil
	}

	if val, ok := _AddressFlagNameToValueMap[strings.ToLower(s)]; ok {
		return val, nil
	}
	return 0, fmt.Errorf("%s does not belong to AddressFlag values", s)
}

// AddressFlagValues returns all values of the enum
func AddressFlagValues() []AddressFlag {
	return _AddressFlagValues
}

// AddressFlagStrings returns a slice of all String values of the enum
func AddressFlagStrings() []string {
	strs := make([]string, len(_AddressFlagNames))
	copy(strs, _AddressFlagNames)
	return strs
}

// IsAAddressFlag returns "true" if the value is listed in the enum definition. "false" otherwise
func (i AddressFlag) IsAAddressFlag() bool {
	_, ok := _AddressFlagMap[i]
	return ok
}

// MarshalText implements the encoding.TextMarshaler interface for AddressFlag
func (i AddressFlag) MarshalText() ([]byte, error) {
	return []byte(i.String()), nil
}

// UnmarshalText implements the encoding.TextUnmarshaler interface for AddressFlag
func (i *AddressFlag) UnmarshalText(text []byte) error {
	var err error
	*i, err = AddressFlagString(string(text))
	return err
}

const _AddressSortAlgorithmName = "v1v2"

var _AddressSortAlgorithmIndex = [...]uint8{0, 2, 4}

const _AddressSortAlgorithmLowerName = "v1v2"

func (i AddressSortAlgorithm) String() string {
	if i < 0 || i >= AddressSortAlgorithm(len(_AddressSortAlgorithmIndex)-1) {
		return fmt.Sprintf("AddressSortAlgorithm(%d)", i)
	}
	return _AddressSortAlgorithmName[_AddressSortAlgorithmIndex[i]:_AddressSortAlgorithmIndex[i+1]]
}

// An "invalid array index" compiler error signifies that the constant values have changed.
// Re-run the stringer command to generate them again.
func _AddressSortAlgorithmNoOp() {
	var x [1]struct{}
	_ = x[AddressSortAlgorithmV1-(0)]
	_ = x[AddressSortAlgorithmV2-(1)]
}

var _AddressSortAlgorithmValues = []AddressSortAlgorithm{AddressSortAlgorithmV1, AddressSortAlgorithmV2}

var _AddressSortAlgorithmNameToValueMap = map[string]AddressSortAlgorithm{
	_AddressSortAlgorithmName[0:2]:      AddressSortAlgorithmV1,
	_AddressSortAlgorithmLowerName[0:2]: AddressSortAlgorithmV1,
	_AddressSortAlgorithmName[2:4]:      AddressSortAlgorithmV2,
	_AddressSortAlgorithmLowerName[2:4]: AddressSortAlgorithmV2,
}

var _AddressSortAlgorithmNames = []string{
	_AddressSortAlgorithmName[0:2],
	_AddressSortAlgorithmName[2:4],
}

// AddressSortAlgorithmString retrieves an enum value from the enum constants string name.
// Throws an error if the param is not part of the enum.
func AddressSortAlgorithmString(s string) (AddressSortAlgorithm, error) {
	if val, ok := _AddressSortAlgorithmNameToValueMap[s]; ok {
		return val, nil
	}

	if val, ok := _AddressSortAlgorithmNameToValueMap[strings.ToLower(s)]; ok {
		return val, nil
	}
	return 0, fmt.Errorf("%s does not belong to AddressSortAlgorithm values", s)
}

// AddressSortAlgorithmValues returns all values of the enum
func AddressSortAlgorithmValues() []AddressSortAlgorithm {
	return _AddressSortAlgorithmValues
}

// AddressSortAlgorithmStrings returns a slice of all String values of the enum
func AddressSortAlgorithmStrings() []string {
	strs := make([]string, len(_AddressSortAlgorithmNames))
	copy(strs, _AddressSortAlgorithmNames)
	return strs
}

// IsAAddressSortAlgorithm returns "true" if the value is listed in the enum definition. "false" otherwise
func (i AddressSortAlgorithm) IsAAddressSortAlgorithm() bool {
	for _, v := range _AddressSortAlgorithmValues {
		if i == v {
			return true
		}
	}
	return false
}

// MarshalText implements the encoding.TextMarshaler interface for AddressSortAlgorithm
func (i AddressSortAlgorithm) MarshalText() ([]byte, error) {
	return []byte(i.String()), nil
}

// UnmarshalText implements the encoding.TextUnmarshaler interface for AddressSortAlgorithm
func (i *AddressSortAlgorithm) UnmarshalText(text []byte) error {
	var err error
	*i, err = AddressSortAlgorithmString(string(text))
	return err
}

const _ADSelectName = "stablebandwidthcount"

var _ADSelectIndex = [...]uint8{0, 6, 15, 20}

const _ADSelectLowerName = "stablebandwidthcount"

func (i ADSelect) String() string {
	if i >= ADSelect(len(_ADSelectIndex)-1) {
		return fmt.Sprintf("ADSelect(%d)", i)
	}
	return _ADSelectName[_ADSelectIndex[i]:_ADSelectIndex[i+1]]
}

// An "invalid array index" compiler error signifies that the constant values have changed.
// Re-run the stringer command to generate them again.
func _ADSelectNoOp() {
	var x [1]struct{}
	_ = x[ADSelectStable-(0)]
	_ = x[ADSelectBandwidth-(1)]
	_ = x[ADSelectCount-(2)]
}

var _ADSelectValues = []ADSelect{ADSelectStable, ADSelectBandwidth, ADSelectCount}

var _ADSelectNameToValueMap = map[string]ADSelect{
	_ADSelectName[0:6]:        ADSelectStable,
	_ADSelectLowerName[0:6]:   ADSelectStable,
	_ADSelectName[6:15]:       ADSelectBandwidth,
	_ADSelectLowerName[6:15]:  ADSelectBandwidth,
	_ADSelectName[15:20]:      ADSelectCount,
	_ADSelectLowerName[15:20]: ADSelectCount,
}

var _ADSelectNames = []string{
	_ADSelectName[0:6],
	_ADSelectName[6:15],
	_ADSelectName[15:20],
}

// ADSelectString retrieves an enum value from the enum constants string name.
// Throws an error if the param is not part of the enum.
func ADSelectString(s string) (ADSelect, error) {
	if val, ok := _ADSelectNameToValueMap[s]; ok {
		return val, nil
	}

	if val, ok := _ADSelectNameToValueMap[strings.ToLower(s)]; ok {
		return val, nil
	}
	return 0, fmt.Errorf("%s does not belong to ADSelect values", s)
}

// ADSelectValues returns all values of the enum
func ADSelectValues() []ADSelect {
	return _ADSelectValues
}

// ADSelectStrings returns a slice of all String values of the enum
func ADSelectStrings() []string {
	strs := make([]string, len(_ADSelectNames))
	copy(strs, _ADSelectNames)
	return strs
}

// IsAADSelect returns "true" if the value is listed in the enum definition. "false" otherwise
func (i ADSelect) IsAADSelect() bool {
	for _, v := range _ADSelectValues {
		if i == v {
			return true
		}
	}
	return false
}

// MarshalText implements the encoding.TextMarshaler interface for ADSelect
func (i ADSelect) MarshalText() ([]byte, error) {
	return []byte(i.String()), nil
}

// UnmarshalText implements the encoding.TextUnmarshaler interface for ADSelect
func (i *ADSelect) UnmarshalText(text []byte) error {
	var err error
	*i, err = ADSelectString(string(text))
	return err
}

const _ADLACPActiveName = "offon"

var _ADLACPActiveIndex = [...]uint8{0, 3, 5}

const _ADLACPActiveLowerName = "offon"

func (i ADLACPActive) String() string {
	if i >= ADLACPActive(len(_ADLACPActiveIndex)-1) {
		return fmt.Sprintf("ADLACPActive(%d)", i)
	}
	return _ADLACPActiveName[_ADLACPActiveIndex[i]:_ADLACPActiveIndex[i+1]]
}

// An "invalid array index" compiler error signifies that the constant values have changed.
// Re-run the stringer command to generate them again.
func _ADLACPActiveNoOp() {
	var x [1]struct{}
	_ = x[ADLACPActiveOff-(0)]
	_ = x[ADLACPActiveOn-(1)]
}

var _ADLACPActiveValues = []ADLACPActive{ADLACPActiveOff, ADLACPActiveOn}

var _ADLACPActiveNameToValueMap = map[string]ADLACPActive{
	_ADLACPActiveName[0:3]:      ADLACPActiveOff,
	_ADLACPActiveLowerName[0:3]: ADLACPActiveOff,
	_ADLACPActiveName[3:5]:      ADLACPActiveOn,
	_ADLACPActiveLowerName[3:5]: ADLACPActiveOn,
}

var _ADLACPActiveNames = []string{
	_ADLACPActiveName[0:3],
	_ADLACPActiveName[3:5],
}

// ADLACPActiveString retrieves an enum value from the enum constants string name.
// Throws an error if the param is not part of the enum.
func ADLACPActiveString(s string) (ADLACPActive, error) {
	if val, ok := _ADLACPActiveNameToValueMap[s]; ok {
		return val, nil
	}

	if val, ok := _ADLACPActiveNameToValueMap[strings.ToLower(s)]; ok {
		return val, nil
	}
	return 0, fmt.Errorf("%s does not belong to ADLACPActive values", s)
}

// ADLACPActiveValues returns all values of the enum
func ADLACPActiveValues() []ADLACPActive {
	return _ADLACPActiveValues
}

// ADLACPActiveStrings returns a slice of all String values of the enum
func ADLACPActiveStrings() []string {
	strs := make([]string, len(_ADLACPActiveNames))
	copy(strs, _ADLACPActiveNames)
	return strs
}

// IsAADLACPActive returns "true" if the value is listed in the enum definition. "false" otherwise
func (i ADLACPActive) IsAADLACPActive() bool {
	for _, v := range _ADLACPActiveValues {
		if i == v {
			return true
		}
	}
	return false
}

// MarshalText implements the encoding.TextMarshaler interface for ADLACPActive
func (i ADLACPActive) MarshalText() ([]byte, error) {
	return []byte(i.String()), nil
}

// UnmarshalText implements the encoding.TextUnmarshaler interface for ADLACPActive
func (i *ADLACPActive) UnmarshalText(text []byte) error {
	var err error
	*i, err = ADLACPActiveString(string(text))
	return err
}

const _AutoHostnameKindName = "offtalos-addrstable"

var _AutoHostnameKindIndex = [...]uint8{0, 3, 13, 19}

const _AutoHostnameKindLowerName = "offtalos-addrstable"

func (i AutoHostnameKind) String() string {
	if i >= AutoHostnameKind(len(_AutoHostnameKindIndex)-1) {
		return fmt.Sprintf("AutoHostnameKind(%d)", i)
	}
	return _AutoHostnameKindName[_AutoHostnameKindIndex[i]:_AutoHostnameKindIndex[i+1]]
}

// An "invalid array index" compiler error signifies that the constant values have changed.
// Re-run the stringer command to generate them again.
func _AutoHostnameKindNoOp() {
	var x [1]struct{}
	_ = x[AutoHostnameKindOff-(0)]
	_ = x[AutoHostnameKindAddr-(1)]
	_ = x[AutoHostnameKindStable-(2)]
}

var _AutoHostnameKindValues = []AutoHostnameKind{AutoHostnameKindOff, AutoHostnameKindAddr, AutoHostnameKindStable}

var _AutoHostnameKindNameToValueMap = map[string]AutoHostnameKind{
	_AutoHostnameKindName[0:3]:        AutoHostnameKindOff,
	_AutoHostnameKindLowerName[0:3]:   AutoHostnameKindOff,
	_AutoHostnameKindName[3:13]:       AutoHostnameKindAddr,
	_AutoHostnameKindLowerName[3:13]:  AutoHostnameKindAddr,
	_AutoHostnameKindName[13:19]:      AutoHostnameKindStable,
	_AutoHostnameKindLowerName[13:19]: AutoHostnameKindStable,
}

var _AutoHostnameKindNames = []string{
	_AutoHostnameKindName[0:3],
	_AutoHostnameKindName[3:13],
	_AutoHostnameKindName[13:19],
}

// AutoHostnameKindString retrieves an enum value from the enum constants string name.
// Throws an error if the param is not part of the enum.
func AutoHostnameKindString(s string) (AutoHostnameKind, error) {
	if val, ok := _AutoHostnameKindNameToValueMap[s]; ok {
		return val, nil
	}

	if val, ok := _AutoHostnameKindNameToValueMap[strings.ToLower(s)]; ok {
		return val, nil
	}
	return 0, fmt.Errorf("%s does not belong to AutoHostnameKind values", s)
}

// AutoHostnameKindValues returns all values of the enum
func AutoHostnameKindValues() []AutoHostnameKind {
	return _AutoHostnameKindValues
}

// AutoHostnameKindStrings returns a slice of all String values of the enum
func AutoHostnameKindStrings() []string {
	strs := make([]string, len(_AutoHostnameKindNames))
	copy(strs, _AutoHostnameKindNames)
	return strs
}

// IsAAutoHostnameKind returns "true" if the value is listed in the enum definition. "false" otherwise
func (i AutoHostnameKind) IsAAutoHostnameKind() bool {
	for _, v := range _AutoHostnameKindValues {
		if i == v {
			return true
		}
	}
	return false
}

// MarshalText implements the encoding.TextMarshaler interface for AutoHostnameKind
func (i AutoHostnameKind) MarshalText() ([]byte, error) {
	return []byte(i.String()), nil
}

// UnmarshalText implements the encoding.TextUnmarshaler interface for AutoHostnameKind
func (i *AutoHostnameKind) UnmarshalText(text []byte) error {
	var err error
	*i, err = AutoHostnameKindString(string(text))
	return err
}

const _BondModeName = "balance-rractive-backupbalance-xorbroadcast802.3adbalance-tlbbalance-alb"

var _BondModeIndex = [...]uint8{0, 10, 23, 34, 43, 50, 61, 72}

const _BondModeLowerName = "balance-rractive-backupbalance-xorbroadcast802.3adbalance-tlbbalance-alb"

func (i BondMode) String() string {
	if i >= BondMode(len(_BondModeIndex)-1) {
		return fmt.Sprintf("BondMode(%d)", i)
	}
	return _BondModeName[_BondModeIndex[i]:_BondModeIndex[i+1]]
}

// An "invalid array index" compiler error signifies that the constant values have changed.
// Re-run the stringer command to generate them again.
func _BondModeNoOp() {
	var x [1]struct{}
	_ = x[BondModeRoundrobin-(0)]
	_ = x[BondModeActiveBackup-(1)]
	_ = x[BondModeXOR-(2)]
	_ = x[BondModeBroadcast-(3)]
	_ = x[BondMode8023AD-(4)]
	_ = x[BondModeTLB-(5)]
	_ = x[BondModeALB-(6)]
}

var _BondModeValues = []BondMode{BondModeRoundrobin, BondModeActiveBackup, BondModeXOR, BondModeBroadcast, BondMode8023AD, BondModeTLB, BondModeALB}

var _BondModeNameToValueMap = map[string]BondMode{
	_BondModeName[0:10]:       BondModeRoundrobin,
	_BondModeLowerName[0:10]:  BondModeRoundrobin,
	_BondModeName[10:23]:      BondModeActiveBackup,
	_BondModeLowerName[10:23]: BondModeActiveBackup,
	_BondModeName[23:34]:      BondModeXOR,
	_BondModeLowerName[23:34]: BondModeXOR,
	_BondModeName[34:43]:      BondModeBroadcast,
	_BondModeLowerName[34:43]: BondModeBroadcast,
	_BondModeName[43:50]:      BondMode8023AD,
	_BondModeLowerName[43:50]: BondMode8023AD,
	_BondModeName[50:61]:      BondModeTLB,
	_BondModeLowerName[50:61]: BondModeTLB,
	_BondModeName[61:72]:      BondModeALB,
	_BondModeLowerName[61:72]: BondModeALB,
}

var _BondModeNames = []string{
	_BondModeName[0:10],
	_BondModeName[10:23],
	_BondModeName[23:34],
	_BondModeName[34:43],
	_BondModeName[43:50],
	_BondModeName[50:61],
	_BondModeName[61:72],
}

// BondModeString retrieves an enum value from the enum constants string name.
// Throws an error if the param is not part of the enum.
func BondModeString(s string) (BondMode, error) {
	if val, ok := _BondModeNameToValueMap[s]; ok {
		return val, nil
	}

	if val, ok := _BondModeNameToValueMap[strings.ToLower(s)]; ok {
		return val, nil
	}
	return 0, fmt.Errorf("%s does not belong to BondMode values", s)
}

// BondModeValues returns all values of the enum
func BondModeValues() []BondMode {
	return _BondModeValues
}

// BondModeStrings returns a slice of all String values of the enum
func BondModeStrings() []string {
	strs := make([]string, len(_BondModeNames))
	copy(strs, _BondModeNames)
	return strs
}

// IsABondMode returns "true" if the value is listed in the enum definition. "false" otherwise
func (i BondMode) IsABondMode() bool {
	for _, v := range _BondModeValues {
		if i == v {
			return true
		}
	}
	return false
}

// MarshalText implements the encoding.TextMarshaler interface for BondMode
func (i BondMode) MarshalText() ([]byte, error) {
	return []byte(i.String()), nil
}

// UnmarshalText implements the encoding.TextUnmarshaler interface for BondMode
func (i *BondMode) UnmarshalText(text []byte) error {
	var err error
	*i, err = BondModeString(string(text))
	return err
}

const _BondXmitHashPolicyName = "layer2layer3+4layer2+3encap2+3encap3+4"

var _BondXmitHashPolicyIndex = [...]uint8{0, 6, 14, 22, 30, 38}

const _BondXmitHashPolicyLowerName = "layer2layer3+4layer2+3encap2+3encap3+4"

func (i BondXmitHashPolicy) String() string {
	if i >= BondXmitHashPolicy(len(_BondXmitHashPolicyIndex)-1) {
		return fmt.Sprintf("BondXmitHashPolicy(%d)", i)
	}
	return _BondXmitHashPolicyName[_BondXmitHashPolicyIndex[i]:_BondXmitHashPolicyIndex[i+1]]
}

// An "invalid array index" compiler error signifies that the constant values have changed.
// Re-run the stringer command to generate them again.
func _BondXmitHashPolicyNoOp() {
	var x [1]struct{}
	_ = x[BondXmitPolicyLayer2-(0)]
	_ = x[BondXmitPolicyLayer34-(1)]
	_ = x[BondXmitPolicyLayer23-(2)]
	_ = x[BondXmitPolicyEncap23-(3)]
	_ = x[BondXmitPolicyEncap34-(4)]
}

var _BondXmitHashPolicyValues = []BondXmitHashPolicy{BondXmitPolicyLayer2, BondXmitPolicyLayer34, BondXmitPolicyLayer23, BondXmitPolicyEncap23, BondXmitPolicyEncap34}

var _BondXmitHashPolicyNameToValueMap = map[string]BondXmitHashPolicy{
	_BondXmitHashPolicyName[0:6]:        BondXmitPolicyLayer2,
	_BondXmitHashPolicyLowerName[0:6]:   BondXmitPolicyLayer2,
	_BondXmitHashPolicyName[6:14]:       BondXmitPolicyLayer34,
	_BondXmitHashPolicyLowerName[6:14]:  BondXmitPolicyLayer34,
	_BondXmitHashPolicyName[14:22]:      BondXmitPolicyLayer23,
	_BondXmitHashPolicyLowerName[14:22]: BondXmitPolicyLayer23,
	_BondXmitHashPolicyName[22:30]:      BondXmitPolicyEncap23,
	_BondXmitHashPolicyLowerName[22:30]: BondXmitPolicyEncap23,
	_BondXmitHashPolicyName[30:38]:      BondXmitPolicyEncap34,
	_BondXmitHashPolicyLowerName[30:38]: BondXmitPolicyEncap34,
}

var _BondXmitHashPolicyNames = []string{
	_BondXmitHashPolicyName[0:6],
	_BondXmitHashPolicyName[6:14],
	_BondXmitHashPolicyName[14:22],
	_BondXmitHashPolicyName[22:30],
	_BondXmitHashPolicyName[30:38],
}

// BondXmitHashPolicyString retrieves an enum value from the enum constants string name.
// Throws an error if the param is not part of the enum.
func BondXmitHashPolicyString(s string) (BondXmitHashPolicy, error) {
	if val, ok := _BondXmitHashPolicyNameToValueMap[s]; ok {
		return val, nil
	}

	if val, ok := _BondXmitHashPolicyNameToValueMap[strings.ToLower(s)]; ok {
		return val, nil
	}
	return 0, fmt.Errorf("%s does not belong to BondXmitHashPolicy values", s)
}

// BondXmitHashPolicyValues returns all values of the enum
func BondXmitHashPolicyValues() []BondXmitHashPolicy {
	return _BondXmitHashPolicyValues
}

// BondXmitHashPolicyStrings returns a slice of all String values of the enum
func BondXmitHashPolicyStrings() []string {
	strs := make([]string, len(_BondXmitHashPolicyNames))
	copy(strs, _BondXmitHashPolicyNames)
	return strs
}

// IsABondXmitHashPolicy returns "true" if the value is listed in the enum definition. "false" otherwise
func (i BondXmitHashPolicy) IsABondXmitHashPolicy() bool {
	for _, v := range _BondXmitHashPolicyValues {
		if i == v {
			return true
		}
	}
	return false
}

// MarshalText implements the encoding.TextMarshaler interface for BondXmitHashPolicy
func (i BondXmitHashPolicy) MarshalText() ([]byte, error) {
	return []byte(i.String()), nil
}

// UnmarshalText implements the encoding.TextUnmarshaler interface for BondXmitHashPolicy
func (i *BondXmitHashPolicy) UnmarshalText(text []byte) error {
	var err error
	*i, err = BondXmitHashPolicyString(string(text))
	return err
}

const _ClientIdentifierName = "nonemacduid"

var _ClientIdentifierIndex = [...]uint8{0, 4, 7, 11}

const _ClientIdentifierLowerName = "nonemacduid"

func (i ClientIdentifier) String() string {
	if i < 0 || i >= ClientIdentifier(len(_ClientIdentifierIndex)-1) {
		return fmt.Sprintf("ClientIdentifier(%d)", i)
	}
	return _ClientIdentifierName[_ClientIdentifierIndex[i]:_ClientIdentifierIndex[i+1]]
}

// An "invalid array index" compiler error signifies that the constant values have changed.
// Re-run the stringer command to generate them again.
func _ClientIdentifierNoOp() {
	var x [1]struct{}
	_ = x[ClientIdentifierNone-(0)]
	_ = x[ClientIdentifierMAC-(1)]
	_ = x[ClientIdentifierDUID-(2)]
}

var _ClientIdentifierValues = []ClientIdentifier{ClientIdentifierNone, ClientIdentifierMAC, ClientIdentifierDUID}

var _ClientIdentifierNameToValueMap = map[string]ClientIdentifier{
	_ClientIdentifierName[0:4]:       ClientIdentifierNone,
	_ClientIdentifierLowerName[0:4]:  ClientIdentifierNone,
	_ClientIdentifierName[4:7]:       ClientIdentifierMAC,
	_ClientIdentifierLowerName[4:7]:  ClientIdentifierMAC,
	_ClientIdentifierName[7:11]:      ClientIdentifierDUID,
	_ClientIdentifierLowerName[7:11]: ClientIdentifierDUID,
}

var _ClientIdentifierNames = []string{
	_ClientIdentifierName[0:4],
	_ClientIdentifierName[4:7],
	_ClientIdentifierName[7:11],
}

// ClientIdentifierString retrieves an enum value from the enum constants string name.
// Throws an error if the param is not part of the enum.
func ClientIdentifierString(s string) (ClientIdentifier, error) {
	if val, ok := _ClientIdentifierNameToValueMap[s]; ok {
		return val, nil
	}

	if val, ok := _ClientIdentifierNameToValueMap[strings.ToLower(s)]; ok {
		return val, nil
	}
	return 0, fmt.Errorf("%s does not belong to ClientIdentifier values", s)
}

// ClientIdentifierValues returns all values of the enum
func ClientIdentifierValues() []ClientIdentifier {
	return _ClientIdentifierValues
}

// ClientIdentifierStrings returns a slice of all String values of the enum
func ClientIdentifierStrings() []string {
	strs := make([]string, len(_ClientIdentifierNames))
	copy(strs, _ClientIdentifierNames)
	return strs
}

// IsAClientIdentifier returns "true" if the value is listed in the enum definition. "false" otherwise
func (i ClientIdentifier) IsAClientIdentifier() bool {
	for _, v := range _ClientIdentifierValues {
		if i == v {
			return true
		}
	}
	return false
}

// MarshalText implements the encoding.TextMarshaler interface for ClientIdentifier
func (i ClientIdentifier) MarshalText() ([]byte, error) {
	return []byte(i.String()), nil
}

// UnmarshalText implements the encoding.TextUnmarshaler interface for ClientIdentifier
func (i *ClientIdentifier) UnmarshalText(text []byte) error {
	var err error
	*i, err = ClientIdentifierString(string(text))
	return err
}

const (
	_ConntrackStateName_0      = "invalidestablished"
	_ConntrackStateLowerName_0 = "invalidestablished"
	_ConntrackStateName_1      = "related"
	_ConntrackStateLowerName_1 = "related"
	_ConntrackStateName_2      = "new"
	_ConntrackStateLowerName_2 = "new"
)

var (
	_ConntrackStateIndex_0 = [...]uint8{0, 7, 18}
	_ConntrackStateIndex_1 = [...]uint8{0, 7}
	_ConntrackStateIndex_2 = [...]uint8{0, 3}
)

func (i ConntrackState) String() string {
	switch {
	case 1 <= i && i <= 2:
		i -= 1
		return _ConntrackStateName_0[_ConntrackStateIndex_0[i]:_ConntrackStateIndex_0[i+1]]
	case i == 4:
		return _ConntrackStateName_1
	case i == 8:
		return _ConntrackStateName_2
	default:
		return fmt.Sprintf("ConntrackState(%d)", i)
	}
}

// An "invalid array index" compiler error signifies that the constant values have changed.
// Re-run the stringer command to generate them again.
func _ConntrackStateNoOp() {
	var x [1]struct{}
	_ = x[ConntrackStateInvalid-(1)]
	_ = x[ConntrackStateEstablished-(2)]
	_ = x[ConntrackStateRelated-(4)]
	_ = x[ConntrackStateNew-(8)]
}

var _ConntrackStateValues = []ConntrackState{ConntrackStateInvalid, ConntrackStateEstablished, ConntrackStateRelated, ConntrackStateNew}

var _ConntrackStateNameToValueMap = map[string]ConntrackState{
	_ConntrackStateName_0[0:7]:       ConntrackStateInvalid,
	_ConntrackStateLowerName_0[0:7]:  ConntrackStateInvalid,
	_ConntrackStateName_0[7:18]:      ConntrackStateEstablished,
	_ConntrackStateLowerName_0[7:18]: ConntrackStateEstablished,
	_ConntrackStateName_1[0:7]:       ConntrackStateRelated,
	_ConntrackStateLowerName_1[0:7]:  ConntrackStateRelated,
	_ConntrackStateName_2[0:3]:       ConntrackStateNew,
	_ConntrackStateLowerName_2[0:3]:  ConntrackStateNew,
}

var _ConntrackStateNames = []string{
	_ConntrackStateName_0[0:7],
	_ConntrackStateName_0[7:18],
	_ConntrackStateName_1[0:7],
	_ConntrackStateName_2[0:3],
}

// ConntrackStateString retrieves an enum value from the enum constants string name.
// Throws an error if the param is not part of the enum.
func ConntrackStateString(s string) (ConntrackState, error) {
	if val, ok := _ConntrackStateNameToValueMap[s]; ok {
		return val, nil
	}

	if val, ok := _ConntrackStateNameToValueMap[strings.ToLower(s)]; ok {
		return val, nil
	}
	return 0, fmt.Errorf("%s does not belong to ConntrackState values", s)
}

// ConntrackStateValues returns all values of the enum
func ConntrackStateValues() []ConntrackState {
	return _ConntrackStateValues
}

// ConntrackStateStrings returns a slice of all String values of the enum
func ConntrackStateStrings() []string {
	strs := make([]string, len(_ConntrackStateNames))
	copy(strs, _ConntrackStateNames)
	return strs
}

// IsAConntrackState returns "true" if the value is listed in the enum definition. "false" otherwise
func (i ConntrackState) IsAConntrackState() bool {
	for _, v := range _ConntrackStateValues {
		if i == v {
			return true
		}
	}
	return false
}

// MarshalText implements the encoding.TextMarshaler interface for ConntrackState
func (i ConntrackState) MarshalText() ([]byte, error) {
	return []byte(i.String()), nil
}

// UnmarshalText implements the encoding.TextUnmarshaler interface for ConntrackState
func (i *ConntrackState) UnmarshalText(text []byte) error {
	var err error
	*i, err = ConntrackStateString(string(text))
	return err
}

const _DefaultActionName = "acceptblock"

var _DefaultActionIndex = [...]uint8{0, 6, 11}

const _DefaultActionLowerName = "acceptblock"

func (i DefaultAction) String() string {
	if i < 0 || i >= DefaultAction(len(_DefaultActionIndex)-1) {
		return fmt.Sprintf("DefaultAction(%d)", i)
	}
	return _DefaultActionName[_DefaultActionIndex[i]:_DefaultActionIndex[i+1]]
}

// An "invalid array index" compiler error signifies that the constant values have changed.
// Re-run the stringer command to generate them again.
func _DefaultActionNoOp() {
	var x [1]struct{}
	_ = x[DefaultActionAccept-(0)]
	_ = x[DefaultActionBlock-(1)]
}

var _DefaultActionValues = []DefaultAction{DefaultActionAccept, DefaultActionBlock}

var _DefaultActionNameToValueMap = map[string]DefaultAction{
	_DefaultActionName[0:6]:       DefaultActionAccept,
	_DefaultActionLowerName[0:6]:  DefaultActionAccept,
	_DefaultActionName[6:11]:      DefaultActionBlock,
	_DefaultActionLowerName[6:11]: DefaultActionBlock,
}

var _DefaultActionNames = []string{
	_DefaultActionName[0:6],
	_DefaultActionName[6:11],
}

// DefaultActionString retrieves an enum value from the enum constants string name.
// Throws an error if the param is not part of the enum.
func DefaultActionString(s string) (DefaultAction, error) {
	if val, ok := _DefaultActionNameToValueMap[s]; ok {
		return val, nil
	}

	if val, ok := _DefaultActionNameToValueMap[strings.ToLower(s)]; ok {
		return val, nil
	}
	return 0, fmt.Errorf("%s does not belong to DefaultAction values", s)
}

// DefaultActionValues returns all values of the enum
func DefaultActionValues() []DefaultAction {
	return _DefaultActionValues
}

// DefaultActionStrings returns a slice of all String values of the enum
func DefaultActionStrings() []string {
	strs := make([]string, len(_DefaultActionNames))
	copy(strs, _DefaultActionNames)
	return strs
}

// IsADefaultAction returns "true" if the value is listed in the enum definition. "false" otherwise
func (i DefaultAction) IsADefaultAction() bool {
	for _, v := range _DefaultActionValues {
		if i == v {
			return true
		}
	}
	return false
}

// MarshalText implements the encoding.TextMarshaler interface for DefaultAction
func (i DefaultAction) MarshalText() ([]byte, error) {
	return []byte(i.String()), nil
}

// UnmarshalText implements the encoding.TextUnmarshaler interface for DefaultAction
func (i *DefaultAction) UnmarshalText(text []byte) error {
	var err error
	*i, err = DefaultActionString(string(text))
	return err
}

const (
	_DuplexName_0      = "HalfFull"
	_DuplexLowerName_0 = "halffull"
	_DuplexName_1      = "Unknown"
	_DuplexLowerName_1 = "unknown"
)

var (
	_DuplexIndex_0 = [...]uint8{0, 4, 8}
	_DuplexIndex_1 = [...]uint8{0, 7}
)

func (i Duplex) String() string {
	switch {
	case 0 <= i && i <= 1:
		return _DuplexName_0[_DuplexIndex_0[i]:_DuplexIndex_0[i+1]]
	case i == 255:
		return _DuplexName_1
	default:
		return fmt.Sprintf("Duplex(%d)", i)
	}
}

// An "invalid array index" compiler error signifies that the constant values have changed.
// Re-run the stringer command to generate them again.
func _DuplexNoOp() {
	var x [1]struct{}
	_ = x[Half-(0)]
	_ = x[Full-(1)]
	_ = x[Unknown-(255)]
}

var _DuplexValues = []Duplex{Half, Full, Unknown}

var _DuplexNameToValueMap = map[string]Duplex{
	_DuplexName_0[0:4]:      Half,
	_DuplexLowerName_0[0:4]: Half,
	_DuplexName_0[4:8]:      Full,
	_DuplexLowerName_0[4:8]: Full,
	_DuplexName_1[0:7]:      Unknown,
	_DuplexLowerName_1[0:7]: Unknown,
}

var _DuplexNames = []string{
	_DuplexName_0[0:4],
	_DuplexName_0[4:8],
	_DuplexName_1[0:7],
}

// DuplexString retrieves an enum value from the enum constants string name.
// Throws an error if the param is not part of the enum.
func DuplexString(s string) (Duplex, error) {
	if val, ok := _DuplexNameToValueMap[s]; ok {
		return val, nil
	}

	if val, ok := _DuplexNameToValueMap[strings.ToLower(s)]; ok {
		return val, nil
	}
	return 0, fmt.Errorf("%s does not belong to Duplex values", s)
}

// DuplexValues returns all values of the enum
func DuplexValues() []Duplex {
	return _DuplexValues
}

// DuplexStrings returns a slice of all String values of the enum
func DuplexStrings() []string {
	strs := make([]string, len(_DuplexNames))
	copy(strs, _DuplexNames)
	return strs
}

// IsADuplex returns "true" if the value is listed in the enum definition. "false" otherwise
func (i Duplex) IsADuplex() bool {
	for _, v := range _DuplexValues {
		if i == v {
			return true
		}
	}
	return false
}

// MarshalText implements the encoding.TextMarshaler interface for Duplex
func (i Duplex) MarshalText() ([]byte, error) {
	return []byte(i.String()), nil
}

// UnmarshalText implements the encoding.TextUnmarshaler interface for Duplex
func (i *Duplex) UnmarshalText(text []byte) error {
	var err error
	*i, err = DuplexString(string(text))
	return err
}

const (
	_FamilyName_0      = "inet4"
	_FamilyLowerName_0 = "inet4"
	_FamilyName_1      = "inet6"
	_FamilyLowerName_1 = "inet6"
)

var (
	_FamilyIndex_0 = [...]uint8{0, 5}
	_FamilyIndex_1 = [...]uint8{0, 5}
)

func (i Family) String() string {
	switch {
	case i == 2:
		return _FamilyName_0
	case i == 10:
		return _FamilyName_1
	default:
		return fmt.Sprintf("Family(%d)", i)
	}
}

// An "invalid array index" compiler error signifies that the constant values have changed.
// Re-run the stringer command to generate them again.
func _FamilyNoOp() {
	var x [1]struct{}
	_ = x[FamilyInet4-(2)]
	_ = x[FamilyInet6-(10)]
}

var _FamilyValues = []Family{FamilyInet4, FamilyInet6}

var _FamilyNameToValueMap = map[string]Family{
	_FamilyName_0[0:5]:      FamilyInet4,
	_FamilyLowerName_0[0:5]: FamilyInet4,
	_FamilyName_1[0:5]:      FamilyInet6,
	_FamilyLowerName_1[0:5]: FamilyInet6,
}

var _FamilyNames = []string{
	_FamilyName_0[0:5],
	_FamilyName_1[0:5],
}

// FamilyString retrieves an enum value from the enum constants string name.
// Throws an error if the param is not part of the enum.
func FamilyString(s string) (Family, error) {
	if val, ok := _FamilyNameToValueMap[s]; ok {
		return val, nil
	}

	if val, ok := _FamilyNameToValueMap[strings.ToLower(s)]; ok {
		return val, nil
	}
	return 0, fmt.Errorf("%s does not belong to Family values", s)
}

// FamilyValues returns all values of the enum
func FamilyValues() []Family {
	return _FamilyValues
}

// FamilyStrings returns a slice of all String values of the enum
func FamilyStrings() []string {
	strs := make([]string, len(_FamilyNames))
	copy(strs, _FamilyNames)
	return strs
}

// IsAFamily returns "true" if the value is listed in the enum definition. "false" otherwise
func (i Family) IsAFamily() bool {
	for _, v := range _FamilyValues {
		if i == v {
			return true
		}
	}
	return false
}

// MarshalText implements the encoding.TextMarshaler interface for Family
func (i Family) MarshalText() ([]byte, error) {
	return []byte(i.String()), nil
}

// UnmarshalText implements the encoding.TextUnmarshaler interface for Family
func (i *Family) UnmarshalText(text []byte) error {
	var err error
	*i, err = FamilyString(string(text))
	return err
}

const _LACPRateName = "slowfast"

var _LACPRateIndex = [...]uint8{0, 4, 8}

const _LACPRateLowerName = "slowfast"

func (i LACPRate) String() string {
	if i >= LACPRate(len(_LACPRateIndex)-1) {
		return fmt.Sprintf("LACPRate(%d)", i)
	}
	return _LACPRateName[_LACPRateIndex[i]:_LACPRateIndex[i+1]]
}

// An "invalid array index" compiler error signifies that the constant values have changed.
// Re-run the stringer command to generate them again.
func _LACPRateNoOp() {
	var x [1]struct{}
	_ = x[LACPRateSlow-(0)]
	_ = x[LACPRateFast-(1)]
}

var _LACPRateValues = []LACPRate{LACPRateSlow, LACPRateFast}

var _LACPRateNameToValueMap = map[string]LACPRate{
	_LACPRateName[0:4]:      LACPRateSlow,
	_LACPRateLowerName[0:4]: LACPRateSlow,
	_LACPRateName[4:8]:      LACPRateFast,
	_LACPRateLowerName[4:8]: LACPRateFast,
}

var _LACPRateNames = []string{
	_LACPRateName[0:4],
	_LACPRateName[4:8],
}

// LACPRateString retrieves an enum value from the enum constants string name.
// Throws an error if the param is not part of the enum.
func LACPRateString(s string) (LACPRate, error) {
	if val, ok := _LACPRateNameToValueMap[s]; ok {
		return val, nil
	}

	if val, ok := _LACPRateNameToValueMap[strings.ToLower(s)]; ok {
		return val, nil
	}
	return 0, fmt.Errorf("%s does not belong to LACPRate values", s)
}

// LACPRateValues returns all values of the enum
func LACPRateValues() []LACPRate {
	return _LACPRateValues
}

// LACPRateStrings returns a slice of all String values of the enum
func LACPRateStrings() []string {
	strs := make([]string, len(_LACPRateNames))
	copy(strs, _LACPRateNames)
	return strs
}

// IsALACPRate returns "true" if the value is listed in the enum definition. "false" otherwise
func (i LACPRate) IsALACPRate() bool {
	for _, v := range _LACPRateValues {
		if i == v {
			return true
		}
	}
	return false
}

// MarshalText implements the encoding.TextMarshaler interface for LACPRate
func (i LACPRate) MarshalText() ([]byte, error) {
	return []byte(i.String()), nil
}

// UnmarshalText implements the encoding.TextUnmarshaler interface for LACPRate
func (i *LACPRate) UnmarshalText(text []byte) error {
	var err error
	*i, err = LACPRateString(string(text))
	return err
}

const _LinkFlagName = "UPBROADCASTDEBUGLOOPBACKPOINTTOPOINTNOTRAILERSRUNNINGNOARPPROMISCALLMULTIMASTERSLAVEMULTICASTPORTSELAUTOMEDIADYNAMICLOWER_UPDORMANTECHO"
const _LinkFlagLowerName = "upbroadcastdebugloopbackpointtopointnotrailersrunningnoarppromiscallmultimasterslavemulticastportselautomediadynamiclower_updormantecho"

var _LinkFlagMap = map[LinkFlag]string{
	1:      _LinkFlagName[0:2],
	2:      _LinkFlagName[2:11],
	4:      _LinkFlagName[11:16],
	8:      _LinkFlagName[16:24],
	16:     _LinkFlagName[24:36],
	32:     _LinkFlagName[36:46],
	64:     _LinkFlagName[46:53],
	128:    _LinkFlagName[53:58],
	256:    _LinkFlagName[58:65],
	512:    _LinkFlagName[65:73],
	1024:   _LinkFlagName[73:79],
	2048:   _LinkFlagName[79:84],
	4096:   _LinkFlagName[84:93],
	8192:   _LinkFlagName[93:100],
	16384:  _LinkFlagName[100:109],
	32768:  _LinkFlagName[109:116],
	65536:  _LinkFlagName[116:124],
	131072: _LinkFlagName[124:131],
	262144: _LinkFlagName[131:135],
}

func (i LinkFlag) String() string {
	if str, ok := _LinkFlagMap[i]; ok {
		return str
	}
	return fmt.Sprintf("LinkFlag(%d)", i)
}

// An "invalid array index" compiler error signifies that the constant values have changed.
// Re-run the stringer command to generate them again.
func _LinkFlagNoOp() {
	var x [1]struct{}
	_ = x[LinkUp-(1)]
	_ = x[LinkBroadcast-(2)]
	_ = x[LinkDebug-(4)]
	_ = x[LinkLoopback-(8)]
	_ = x[LinkPointToPoint-(16)]
	_ = x[LinkNoTrailers-(32)]
	_ = x[LinkRunning-(64)]
	_ = x[LinkNoArp-(128)]
	_ = x[LinkPromisc-(256)]
	_ = x[LinkAllMulti-(512)]
	_ = x[LinkMaster-(1024)]
	_ = x[LinkSlave-(2048)]
	_ = x[LinkMulticast-(4096)]
	_ = x[LinkPortsel-(8192)]
	_ = x[LinKAutoMedia-(16384)]
	_ = x[LinkDynamic-(32768)]
	_ = x[LinkLowerUp-(65536)]
	_ = x[LinkDormant-(131072)]
	_ = x[LinkEcho-(262144)]
}

var _LinkFlagValues = []LinkFlag{LinkUp, LinkBroadcast, LinkDebug, LinkLoopback, LinkPointToPoint, LinkNoTrailers, LinkRunning, LinkNoArp, LinkPromisc, LinkAllMulti, LinkMaster, LinkSlave, LinkMulticast, LinkPortsel, LinKAutoMedia, LinkDynamic, LinkLowerUp, LinkDormant, LinkEcho}

var _LinkFlagNameToValueMap = map[string]LinkFlag{
	_LinkFlagName[0:2]:          LinkUp,
	_LinkFlagLowerName[0:2]:     LinkUp,
	_LinkFlagName[2:11]:         LinkBroadcast,
	_LinkFlagLowerName[2:11]:    LinkBroadcast,
	_LinkFlagName[11:16]:        LinkDebug,
	_LinkFlagLowerName[11:16]:   LinkDebug,
	_LinkFlagName[16:24]:        LinkLoopback,
	_LinkFlagLowerName[16:24]:   LinkLoopback,
	_LinkFlagName[24:36]:        LinkPointToPoint,
	_LinkFlagLowerName[24:36]:   LinkPointToPoint,
	_LinkFlagName[36:46]:        LinkNoTrailers,
	_LinkFlagLowerName[36:46]:   LinkNoTrailers,
	_LinkFlagName[46:53]:        LinkRunning,
	_LinkFlagLowerName[46:53]:   LinkRunning,
	_LinkFlagName[53:58]:        LinkNoArp,
	_LinkFlagLowerName[53:58]:   LinkNoArp,
	_LinkFlagName[58:65]:        LinkPromisc,
	_LinkFlagLowerName[58:65]:   LinkPromisc,
	_LinkFlagName[65:73]:        LinkAllMulti,
	_LinkFlagLowerName[65:73]:   LinkAllMulti,
	_LinkFlagName[73:79]:        LinkMaster,
	_LinkFlagLowerName[73:79]:   LinkMaster,
	_LinkFlagName[79:84]:        LinkSlave,
	_LinkFlagLowerName[79:84]:   LinkSlave,
	_LinkFlagName[84:93]:        LinkMulticast,
	_LinkFlagLowerName[84:93]:   LinkMulticast,
	_LinkFlagName[93:100]:       LinkPortsel,
	_LinkFlagLowerName[93:100]:  LinkPortsel,
	_LinkFlagName[100:109]:      LinKAutoMedia,
	_LinkFlagLowerName[100:109]: LinKAutoMedia,
	_LinkFlagName[109:116]:      LinkDynamic,
	_LinkFlagLowerName[109:116]: LinkDynamic,
	_LinkFlagName[116:124]:      LinkLowerUp,
	_LinkFlagLowerName[116:124]: LinkLowerUp,
	_LinkFlagName[124:131]:      LinkDormant,
	_LinkFlagLowerName[124:131]: LinkDormant,
	_LinkFlagName[131:135]:      LinkEcho,
	_LinkFlagLowerName[131:135]: LinkEcho,
}

var _LinkFlagNames = []string{
	_LinkFlagName[0:2],
	_LinkFlagName[2:11],
	_LinkFlagName[11:16],
	_LinkFlagName[16:24],
	_LinkFlagName[24:36],
	_LinkFlagName[36:46],
	_LinkFlagName[46:53],
	_LinkFlagName[53:58],
	_LinkFlagName[58:65],
	_LinkFlagName[65:73],
	_LinkFlagName[73:79],
	_LinkFlagName[79:84],
	_LinkFlagName[84:93],
	_LinkFlagName[93:100],
	_LinkFlagName[100:109],
	_LinkFlagName[109:116],
	_LinkFlagName[116:124],
	_LinkFlagName[124:131],
	_LinkFlagName[131:135],
}

// LinkFlagString retrieves an enum value from the enum constants string name.
// Throws an error if the param is not part of the enum.
func LinkFlagString(s string) (LinkFlag, error) {
	if val, ok := _LinkFlagNameToValueMap[s]; ok {
		return val, nil
	}

	if val, ok := _LinkFlagNameToValueMap[strings.ToLower(s)]; ok {
		return val, nil
	}
	return 0, fmt.Errorf("%s does not belong to LinkFlag values", s)
}

// LinkFlagValues returns all values of the enum
func LinkFlagValues() []LinkFlag {
	return _LinkFlagValues
}

// LinkFlagStrings returns a slice of all String values of the enum
func LinkFlagStrings() []string {
	strs := make([]string, len(_LinkFlagNames))
	copy(strs, _LinkFlagNames)
	return strs
}

// IsALinkFlag returns "true" if the value is listed in the enum definition. "false" otherwise
func (i LinkFlag) IsALinkFlag() bool {
	_, ok := _LinkFlagMap[i]
	return ok
}

// MarshalText implements the encoding.TextMarshaler interface for LinkFlag
func (i LinkFlag) MarshalText() ([]byte, error) {
	return []byte(i.String()), nil
}

// UnmarshalText implements the encoding.TextUnmarshaler interface for LinkFlag
func (i *LinkFlag) UnmarshalText(text []byte) error {
	var err error
	*i, err = LinkFlagString(string(text))
	return err
}

const _LinkTypeName = "netromethereetherax25pronetchaosieee802arcnetatalkdlciatmmetricomieee1394eui64infinibandslipcslipslip6cslip6rsrvdadaptrosex25hwx25canpppciscolapbddcmprawhdlcipiptunnel6fradskiploopbacklocaltlkfddibifsitip/ddpgrepimreghippiasheconetirdafcppfcalfcplfcfb_0fcfb_1fcfb_2fcfb_3fcfb_4fcfb_5fcfb_6fcfb_7fcfb_8fcfb_9fcfb_10fcfb_11fcfb_12trieee802.11ieee802.11_prismieee802.11_radiotapieee802.15.4ieee802.15.4_monitorphonetphonet_pipecaifip6grenetlink6lowpannohdrvoid"
const _LinkTypeLowerName = "netromethereetherax25pronetchaosieee802arcnetatalkdlciatmmetricomieee1394eui64infinibandslipcslipslip6cslip6rsrvdadaptrosex25hwx25canpppciscolapbddcmprawhdlcipiptunnel6fradskiploopbacklocaltlkfddibifsitip/ddpgrepimreghippiasheconetirdafcppfcalfcplfcfb_0fcfb_1fcfb_2fcfb_3fcfb_4fcfb_5fcfb_6fcfb_7fcfb_8fcfb_9fcfb_10fcfb_11fcfb_12trieee802.11ieee802.11_prismieee802.11_radiotapieee802.15.4ieee802.15.4_monitorphonetphonet_pipecaifip6grenetlink6lowpannohdrvoid"

var _LinkTypeMap = map[LinkType]string{
	0:     _LinkTypeName[0:6],
	1:     _LinkTypeName[6:11],
	2:     _LinkTypeName[11:17],
	3:     _LinkTypeName[17:21],
	4:     _LinkTypeName[21:27],
	5:     _LinkTypeName[27:32],
	6:     _LinkTypeName[32:39],
	7:     _LinkTypeName[39:45],
	8:     _LinkTypeName[45:50],
	15:    _LinkTypeName[50:54],
	19:    _LinkTypeName[54:57],
	23:    _LinkTypeName[57:65],
	24:    _LinkTypeName[65:73],
	27:    _LinkTypeName[73:78],
	32:    _LinkTypeName[78:88],
	256:   _LinkTypeName[88:92],
	257:   _LinkTypeName[92:97],
	258:   _LinkTypeName[97:102],
	259:   _LinkTypeName[102:108],
	260:   _LinkTypeName[108:113],
	264:   _LinkTypeName[113:118],
	270:   _LinkTypeName[118:122],
	271:   _LinkTypeName[122:125],
	272:   _LinkTypeName[125:130],
	280:   _LinkTypeName[130:133],
	512:   _LinkTypeName[133:136],
	513:   _LinkTypeName[136:141],
	516:   _LinkTypeName[141:145],
	517:   _LinkTypeName[145:150],
	518:   _LinkTypeName[150:157],
	768:   _LinkTypeName[157:161],
	769:   _LinkTypeName[161:168],
	770:   _LinkTypeName[168:172],
	771:   _LinkTypeName[172:176],
	772:   _LinkTypeName[176:184],
	773:   _LinkTypeName[184:192],
	774:   _LinkTypeName[192:196],
	775:   _LinkTypeName[196:199],
	776:   _LinkTypeName[199:202],
	777:   _LinkTypeName[202:208],
	778:   _LinkTypeName[208:211],
	779:   _LinkTypeName[211:217],
	780:   _LinkTypeName[217:222],
	781:   _LinkTypeName[222:225],
	782:   _LinkTypeName[225:231],
	783:   _LinkTypeName[231:235],
	784:   _LinkTypeName[235:239],
	785:   _LinkTypeName[239:243],
	786:   _LinkTypeName[243:247],
	787:   _LinkTypeName[247:253],
	788:   _LinkTypeName[253:259],
	789:   _LinkTypeName[259:265],
	790:   _LinkTypeName[265:271],
	791:   _LinkTypeName[271:277],
	792:   _LinkTypeName[277:283],
	793:   _LinkTypeName[283:289],
	794:   _LinkTypeName[289:295],
	795:   _LinkTypeName[295:301],
	796:   _LinkTypeName[301:307],
	797:   _LinkTypeName[307:314],
	798:   _LinkTypeName[314:321],
	799:   _LinkTypeName[321:328],
	800:   _LinkTypeName[328:330],
	801:   _LinkTypeName[330:340],
	802:   _LinkTypeName[340:356],
	803:   _LinkTypeName[356:375],
	804:   _LinkTypeName[375:387],
	805:   _LinkTypeName[387:407],
	820:   _LinkTypeName[407:413],
	821:   _LinkTypeName[413:424],
	822:   _LinkTypeName[424:428],
	823:   _LinkTypeName[428:434],
	824:   _LinkTypeName[434:441],
	825:   _LinkTypeName[441:448],
	65534: _LinkTypeName[448:453],
	65535: _LinkTypeName[453:457],
}

func (i LinkType) String() string {
	if str, ok := _LinkTypeMap[i]; ok {
		return str
	}
	return fmt.Sprintf("LinkType(%d)", i)
}

// An "invalid array index" compiler error signifies that the constant values have changed.
// Re-run the stringer command to generate them again.
func _LinkTypeNoOp() {
	var x [1]struct{}
	_ = x[LinkNetrom-(0)]
	_ = x[LinkEther-(1)]
	_ = x[LinkEether-(2)]
	_ = x[LinkAx25-(3)]
	_ = x[LinkPronet-(4)]
	_ = x[LinkChaos-(5)]
	_ = x[LinkIee802-(6)]
	_ = x[LinkArcnet-(7)]
	_ = x[LinkAtalk-(8)]
	_ = x[LinkDlci-(15)]
	_ = x[LinkAtm-(19)]
	_ = x[LinkMetricom-(23)]
	_ = x[LinkIeee1394-(24)]
	_ = x[LinkEui64-(27)]
	_ = x[LinkInfiniband-(32)]
	_ = x[LinkSlip-(256)]
	_ = x[LinkCslip-(257)]
	_ = x[LinkSlip6-(258)]
	_ = x[LinkCslip6-(259)]
	_ = x[LinkRsrvd-(260)]
	_ = x[LinkAdapt-(264)]
	_ = x[LinkRose-(270)]
	_ = x[LinkX25-(271)]
	_ = x[LinkHwx25-(272)]
	_ = x[LinkCan-(280)]
	_ = x[LinkPpp-(512)]
	_ = x[LinkCisco-(513)]
	_ = x[LinkLapb-(516)]
	_ = x[LinkDdcmp-(517)]
	_ = x[LinkRawhdlc-(518)]
	_ = x[LinkTunnel-(768)]
	_ = x[LinkTunnel6-(769)]
	_ = x[LinkFrad-(770)]
	_ = x[LinkSkip-(771)]
	_ = x[LinkLoopbck-(772)]
	_ = x[LinkLocaltlk-(773)]
	_ = x[LinkFddi-(774)]
	_ = x[LinkBif-(775)]
	_ = x[LinkSit-(776)]
	_ = x[LinkIpddp-(777)]
	_ = x[LinkIpgre-(778)]
	_ = x[LinkPimreg-(779)]
	_ = x[LinkHippi-(780)]
	_ = x[LinkAsh-(781)]
	_ = x[LinkEconet-(782)]
	_ = x[LinkIrda-(783)]
	_ = x[LinkFcpp-(784)]
	_ = x[LinkFcal-(785)]
	_ = x[LinkFcpl-(786)]
	_ = x[LinkFcfabric-(787)]
	_ = x[LinkFcfabric1-(788)]
	_ = x[LinkFcfabric2-(789)]
	_ = x[LinkFcfabric3-(790)]
	_ = x[LinkFcfabric4-(791)]
	_ = x[LinkFcfabric5-(792)]
	_ = x[LinkFcfabric6-(793)]
	_ = x[LinkFcfabric7-(794)]
	_ = x[LinkFcfabric8-(795)]
	_ = x[LinkFcfabric9-(796)]
	_ = x[LinkFcfabric10-(797)]
	_ = x[LinkFcfabric11-(798)]
	_ = x[LinkFcfabric12-(799)]
	_ = x[LinkIee802tr-(800)]
	_ = x[LinkIee80211-(801)]
	_ = x[LinkIee80211prism-(802)]
	_ = x[LinkIee80211Radiotap-(803)]
	_ = x[LinkIee8021154-(804)]
	_ = x[LinkIee8021154monitor-(805)]
	_ = x[LinkPhonet-(820)]
	_ = x[LinkPhonetpipe-(821)]
	_ = x[LinkCaif-(822)]
	_ = x[LinkIP6gre-(823)]
	_ = x[LinkNetlink-(824)]
	_ = x[Link6Lowpan-(825)]
	_ = x[LinkNone-(65534)]
	_ = x[LinkVoid-(65535)]
}

var _LinkTypeValues = []LinkType{LinkNetrom, LinkEther, LinkEether, LinkAx25, LinkPronet, LinkChaos, LinkIee802, LinkArcnet, LinkAtalk, LinkDlci, LinkAtm, LinkMetricom, LinkIeee1394, LinkEui64, LinkInfiniband, LinkSlip, LinkCslip, LinkSlip6, LinkCslip6, LinkRsrvd, LinkAdapt, LinkRose, LinkX25, LinkHwx25, LinkCan, LinkPpp, LinkCisco, LinkLapb, LinkDdcmp, LinkRawhdlc, LinkTunnel, LinkTunnel6, LinkFrad, LinkSkip, LinkLoopbck, LinkLocaltlk, LinkFddi, LinkBif, LinkSit, LinkIpddp, LinkIpgre, LinkPimreg, LinkHippi, LinkAsh, LinkEconet, LinkIrda, LinkFcpp, LinkFcal, LinkFcpl, LinkFcfabric, LinkFcfabric1, LinkFcfabric2, LinkFcfabric3, LinkFcfabric4, LinkFcfabric5, LinkFcfabric6, LinkFcfabric7, LinkFcfabric8, LinkFcfabric9, LinkFcfabric10, LinkFcfabric11, LinkFcfabric12, LinkIee802tr, LinkIee80211, LinkIee80211prism, LinkIee80211Radiotap, LinkIee8021154, LinkIee8021154monitor, LinkPhonet, LinkPhonetpipe, LinkCaif, LinkIP6gre, LinkNetlink, Link6Lowpan, LinkNone, LinkVoid}

var _LinkTypeNameToValueMap = map[string]LinkType{
	_LinkTypeName[0:6]:          LinkNetrom,
	_LinkTypeLowerName[0:6]:     LinkNetrom,
	_LinkTypeName[6:11]:         LinkEther,
	_LinkTypeLowerName[6:11]:    LinkEther,
	_LinkTypeName[11:17]:        LinkEether,
	_LinkTypeLowerName[11:17]:   LinkEether,
	_LinkTypeName[17:21]:        LinkAx25,
	_LinkTypeLowerName[17:21]:   LinkAx25,
	_LinkTypeName[21:27]:        LinkPronet,
	_LinkTypeLowerName[21:27]:   LinkPronet,
	_LinkTypeName[27:32]:        LinkChaos,
	_LinkTypeLowerName[27:32]:   LinkChaos,
	_LinkTypeName[32:39]:        LinkIee802,
	_LinkTypeLowerName[32:39]:   LinkIee802,
	_LinkTypeName[39:45]:        LinkArcnet,
	_LinkTypeLowerName[39:45]:   LinkArcnet,
	_LinkTypeName[45:50]:        LinkAtalk,
	_LinkTypeLowerName[45:50]:   LinkAtalk,
	_LinkTypeName[50:54]:        LinkDlci,
	_LinkTypeLowerName[50:54]:   LinkDlci,
	_LinkTypeName[54:57]:        LinkAtm,
	_LinkTypeLowerName[54:57]:   LinkAtm,
	_LinkTypeName[57:65]:        LinkMetricom,
	_LinkTypeLowerName[57:65]:   LinkMetricom,
	_LinkTypeName[65:73]:        LinkIeee1394,
	_LinkTypeLowerName[65:73]:   LinkIeee1394,
	_LinkTypeName[73:78]:        LinkEui64,
	_LinkTypeLowerName[73:78]:   LinkEui64,
	_LinkTypeName[78:88]:        LinkInfiniband,
	_LinkTypeLowerName[78:88]:   LinkInfiniband,
	_LinkTypeName[88:92]:        LinkSlip,
	_LinkTypeLowerName[88:92]:   LinkSlip,
	_LinkTypeName[92:97]:        LinkCslip,
	_LinkTypeLowerName[92:97]:   LinkCslip,
	_LinkTypeName[97:102]:       LinkSlip6,
	_LinkTypeLowerName[97:102]:  LinkSlip6,
	_LinkTypeName[102:108]:      LinkCslip6,
	_LinkTypeLowerName[102:108]: LinkCslip6,
	_LinkTypeName[108:113]:      LinkRsrvd,
	_LinkTypeLowerName[108:113]: LinkRsrvd,
	_LinkTypeName[113:118]:      LinkAdapt,
	_LinkTypeLowerName[113:118]: LinkAdapt,
	_LinkTypeName[118:122]:      LinkRose,
	_LinkTypeLowerName[118:122]: LinkRose,
	_LinkTypeName[122:125]:      LinkX25,
	_LinkTypeLowerName[122:125]: LinkX25,
	_LinkTypeName[125:130]:      LinkHwx25,
	_LinkTypeLowerName[125:130]: LinkHwx25,
	_LinkTypeName[130:133]:      LinkCan,
	_LinkTypeLowerName[130:133]: LinkCan,
	_LinkTypeName[133:136]:      LinkPpp,
	_LinkTypeLowerName[133:136]: LinkPpp,
	_LinkTypeName[136:141]:      LinkCisco,
	_LinkTypeLowerName[136:141]: LinkCisco,
	_LinkTypeName[141:145]:      LinkLapb,
	_LinkTypeLowerName[141:145]: LinkLapb,
	_LinkTypeName[145:150]:      LinkDdcmp,
	_LinkTypeLowerName[145:150]: LinkDdcmp,
	_LinkTypeName[150:157]:      LinkRawhdlc,
	_LinkTypeLowerName[150:157]: LinkRawhdlc,
	_LinkTypeName[157:161]:      LinkTunnel,
	_LinkTypeLowerName[157:161]: LinkTunnel,
	_LinkTypeName[161:168]:      LinkTunnel6,
	_LinkTypeLowerName[161:168]: LinkTunnel6,
	_LinkTypeName[168:172]:      LinkFrad,
	_LinkTypeLowerName[168:172]: LinkFrad,
	_LinkTypeName[172:176]:      LinkSkip,
	_LinkTypeLowerName[172:176]: LinkSkip,
	_LinkTypeName[176:184]:      LinkLoopbck,
	_LinkTypeLowerName[176:184]: LinkLoopbck,
	_LinkTypeName[184:192]:      LinkLocaltlk,
	_LinkTypeLowerName[184:192]: LinkLocaltlk,
	_LinkTypeName[192:196]:      LinkFddi,
	_LinkTypeLowerName[192:196]: LinkFddi,
	_LinkTypeName[196:199]:      LinkBif,
	_LinkTypeLowerName[196:199]: LinkBif,
	_LinkTypeName[199:202]:      LinkSit,
	_LinkTypeLowerName[199:202]: LinkSit,
	_LinkTypeName[202:208]:      LinkIpddp,
	_LinkTypeLowerName[202:208]: LinkIpddp,
	_LinkTypeName[208:211]:      LinkIpgre,
	_LinkTypeLowerName[208:211]: LinkIpgre,
	_LinkTypeName[211:217]:      LinkPimreg,
	_LinkTypeLowerName[211:217]: LinkPimreg,
	_LinkTypeName[217:222]:      LinkHippi,
	_LinkTypeLowerName[217:222]: LinkHippi,
	_LinkTypeName[222:225]:      LinkAsh,
	_LinkTypeLowerName[222:225]: LinkAsh,
	_LinkTypeName[225:231]:      LinkEconet,
	_LinkTypeLowerName[225:231]: LinkEconet,
	_LinkTypeName[231:235]:      LinkIrda,
	_LinkTypeLowerName[231:235]: LinkIrda,
	_LinkTypeName[235:239]:      LinkFcpp,
	_LinkTypeLowerName[235:239]: LinkFcpp,
	_LinkTypeName[239:243]:      LinkFcal,
	_LinkTypeLowerName[239:243]: LinkFcal,
	_LinkTypeName[243:247]:      LinkFcpl,
	_LinkTypeLowerName[243:247]: LinkFcpl,
	_LinkTypeName[247:253]:      LinkFcfabric,
	_LinkTypeLowerName[247:253]: LinkFcfabric,
	_LinkTypeName[253:259]:      LinkFcfabric1,
	_LinkTypeLowerName[253:259]: LinkFcfabric1,
	_LinkTypeName[259:265]:      LinkFcfabric2,
	_LinkTypeLowerName[259:265]: LinkFcfabric2,
	_LinkTypeName[265:271]:      LinkFcfabric3,
	_LinkTypeLowerName[265:271]: LinkFcfabric3,
	_LinkTypeName[271:277]:      LinkFcfabric4,
	_LinkTypeLowerName[271:277]: LinkFcfabric4,
	_LinkTypeName[277:283]:      LinkFcfabric5,
	_LinkTypeLowerName[277:283]: LinkFcfabric5,
	_LinkTypeName[283:289]:      LinkFcfabric6,
	_LinkTypeLowerName[283:289]: LinkFcfabric6,
	_LinkTypeName[289:295]:      LinkFcfabric7,
	_LinkTypeLowerName[289:295]: LinkFcfabric7,
	_LinkTypeName[295:301]:      LinkFcfabric8,
	_LinkTypeLowerName[295:301]: LinkFcfabric8,
	_LinkTypeName[301:307]:      LinkFcfabric9,
	_LinkTypeLowerName[301:307]: LinkFcfabric9,
	_LinkTypeName[307:314]:      LinkFcfabric10,
	_LinkTypeLowerName[307:314]: LinkFcfabric10,
	_LinkTypeName[314:321]:      LinkFcfabric11,
	_LinkTypeLowerName[314:321]: LinkFcfabric11,
	_LinkTypeName[321:328]:      LinkFcfabric12,
	_LinkTypeLowerName[321:328]: LinkFcfabric12,
	_LinkTypeName[328:330]:      LinkIee802tr,
	_LinkTypeLowerName[328:330]: LinkIee802tr,
	_LinkTypeName[330:340]:      LinkIee80211,
	_LinkTypeLowerName[330:340]: LinkIee80211,
	_LinkTypeName[340:356]:      LinkIee80211prism,
	_LinkTypeLowerName[340:356]: LinkIee80211prism,
	_LinkTypeName[356:375]:      LinkIee80211Radiotap,
	_LinkTypeLowerName[356:375]: LinkIee80211Radiotap,
	_LinkTypeName[375:387]:      LinkIee8021154,
	_LinkTypeLowerName[375:387]: LinkIee8021154,
	_LinkTypeName[387:407]:      LinkIee8021154monitor,
	_LinkTypeLowerName[387:407]: LinkIee8021154monitor,
	_LinkTypeName[407:413]:      LinkPhonet,
	_LinkTypeLowerName[407:413]: LinkPhonet,
	_LinkTypeName[413:424]:      LinkPhonetpipe,
	_LinkTypeLowerName[413:424]: LinkPhonetpipe,
	_LinkTypeName[424:428]:      LinkCaif,
	_LinkTypeLowerName[424:428]: LinkCaif,
	_LinkTypeName[428:434]:      LinkIP6gre,
	_LinkTypeLowerName[428:434]: LinkIP6gre,
	_LinkTypeName[434:441]:      LinkNetlink,
	_LinkTypeLowerName[434:441]: LinkNetlink,
	_LinkTypeName[441:448]:      Link6Lowpan,
	_LinkTypeLowerName[441:448]: Link6Lowpan,
	_LinkTypeName[448:453]:      LinkNone,
	_LinkTypeLowerName[448:453]: LinkNone,
	_LinkTypeName[453:457]:      LinkVoid,
	_LinkTypeLowerName[453:457]: LinkVoid,
}

var _LinkTypeNames = []string{
	_LinkTypeName[0:6],
	_LinkTypeName[6:11],
	_LinkTypeName[11:17],
	_LinkTypeName[17:21],
	_LinkTypeName[21:27],
	_LinkTypeName[27:32],
	_LinkTypeName[32:39],
	_LinkTypeName[39:45],
	_LinkTypeName[45:50],
	_LinkTypeName[50:54],
	_LinkTypeName[54:57],
	_LinkTypeName[57:65],
	_LinkTypeName[65:73],
	_LinkTypeName[73:78],
	_LinkTypeName[78:88],
	_LinkTypeName[88:92],
	_LinkTypeName[92:97],
	_LinkTypeName[97:102],
	_LinkTypeName[102:108],
	_LinkTypeName[108:113],
	_LinkTypeName[113:118],
	_LinkTypeName[118:122],
	_LinkTypeName[122:125],
	_LinkTypeName[125:130],
	_LinkTypeName[130:133],
	_LinkTypeName[133:136],
	_LinkTypeName[136:141],
	_LinkTypeName[141:145],
	_LinkTypeName[145:150],
	_LinkTypeName[150:157],
	_LinkTypeName[157:161],
	_LinkTypeName[161:168],
	_LinkTypeName[168:172],
	_LinkTypeName[172:176],
	_LinkTypeName[176:184],
	_LinkTypeName[184:192],
	_LinkTypeName[192:196],
	_LinkTypeName[196:199],
	_LinkTypeName[199:202],
	_LinkTypeName[202:208],
	_LinkTypeName[208:211],
	_LinkTypeName[211:217],
	_LinkTypeName[217:222],
	_LinkTypeName[222:225],
	_LinkTypeName[225:231],
	_LinkTypeName[231:235],
	_LinkTypeName[235:239],
	_LinkTypeName[239:243],
	_LinkTypeName[243:247],
	_LinkTypeName[247:253],
	_LinkTypeName[253:259],
	_LinkTypeName[259:265],
	_LinkTypeName[265:271],
	_LinkTypeName[271:277],
	_LinkTypeName[277:283],
	_LinkTypeName[283:289],
	_LinkTypeName[289:295],
	_LinkTypeName[295:301],
	_LinkTypeName[301:307],
	_LinkTypeName[307:314],
	_LinkTypeName[314:321],
	_LinkTypeName[321:328],
	_LinkTypeName[328:330],
	_LinkTypeName[330:340],
	_LinkTypeName[340:356],
	_LinkTypeName[356:375],
	_LinkTypeName[375:387],
	_LinkTypeName[387:407],
	_LinkTypeName[407:413],
	_LinkTypeName[413:424],
	_LinkTypeName[424:428],
	_LinkTypeName[428:434],
	_LinkTypeName[434:441],
	_LinkTypeName[441:448],
	_LinkTypeName[448:453],
	_LinkTypeName[453:457],
}

// LinkTypeString retrieves an enum value from the enum constants string name.
// Throws an error if the param is not part of the enum.
func LinkTypeString(s string) (LinkType, error) {
	if val, ok := _LinkTypeNameToValueMap[s]; ok {
		return val, nil
	}

	if val, ok := _LinkTypeNameToValueMap[strings.ToLower(s)]; ok {
		return val, nil
	}
	return 0, fmt.Errorf("%s does not belong to LinkType values", s)
}

// LinkTypeValues returns all values of the enum
func LinkTypeValues() []LinkType {
	return _LinkTypeValues
}

// LinkTypeStrings returns a slice of all String values of the enum
func LinkTypeStrings() []string {
	strs := make([]string, len(_LinkTypeNames))
	copy(strs, _LinkTypeNames)
	return strs
}

// IsALinkType returns "true" if the value is listed in the enum definition. "false" otherwise
func (i LinkType) IsALinkType() bool {
	_, ok := _LinkTypeMap[i]
	return ok
}

// MarshalText implements the encoding.TextMarshaler interface for LinkType
func (i LinkType) MarshalText() ([]byte, error) {
	return []byte(i.String()), nil
}

// UnmarshalText implements the encoding.TextUnmarshaler interface for LinkType
func (i *LinkType) UnmarshalText(text []byte) error {
	var err error
	*i, err = LinkTypeString(string(text))
	return err
}

const _MatchOperatorName = "==!="

var _MatchOperatorIndex = [...]uint8{0, 2, 4}

const _MatchOperatorLowerName = "==!="

func (i MatchOperator) String() string {
	if i < 0 || i >= MatchOperator(len(_MatchOperatorIndex)-1) {
		return fmt.Sprintf("MatchOperator(%d)", i)
	}
	return _MatchOperatorName[_MatchOperatorIndex[i]:_MatchOperatorIndex[i+1]]
}

// An "invalid array index" compiler error signifies that the constant values have changed.
// Re-run the stringer command to generate them again.
func _MatchOperatorNoOp() {
	var x [1]struct{}
	_ = x[OperatorEqual-(0)]
	_ = x[OperatorNotEqual-(1)]
}

var _MatchOperatorValues = []MatchOperator{OperatorEqual, OperatorNotEqual}

var _MatchOperatorNameToValueMap = map[string]MatchOperator{
	_MatchOperatorName[0:2]:      OperatorEqual,
	_MatchOperatorLowerName[0:2]: OperatorEqual,
	_MatchOperatorName[2:4]:      OperatorNotEqual,
	_MatchOperatorLowerName[2:4]: OperatorNotEqual,
}

var _MatchOperatorNames = []string{
	_MatchOperatorName[0:2],
	_MatchOperatorName[2:4],
}

// MatchOperatorString retrieves an enum value from the enum constants string name.
// Throws an error if the param is not part of the enum.
func MatchOperatorString(s string) (MatchOperator, error) {
	if val, ok := _MatchOperatorNameToValueMap[s]; ok {
		return val, nil
	}

	if val, ok := _MatchOperatorNameToValueMap[strings.ToLower(s)]; ok {
		return val, nil
	}
	return 0, fmt.Errorf("%s does not belong to MatchOperator values", s)
}

// MatchOperatorValues returns all values of the enum
func MatchOperatorValues() []MatchOperator {
	return _MatchOperatorValues
}

// MatchOperatorStrings returns a slice of all String values of the enum
func MatchOperatorStrings() []string {
	strs := make([]string, len(_MatchOperatorNames))
	copy(strs, _MatchOperatorNames)
	return strs
}

// IsAMatchOperator returns "true" if the value is listed in the enum definition. "false" otherwise
func (i MatchOperator) IsAMatchOperator() bool {
	for _, v := range _MatchOperatorValues {
		if i == v {
			return true
		}
	}
	return false
}

// MarshalText implements the encoding.TextMarshaler interface for MatchOperator
func (i MatchOperator) MarshalText() ([]byte, error) {
	return []byte(i.String()), nil
}

// UnmarshalText implements the encoding.TextUnmarshaler interface for MatchOperator
func (i *MatchOperator) UnmarshalText(text []byte) error {
	var err error
	*i, err = MatchOperatorString(string(text))
	return err
}

const _NfTablesChainHookName = "preroutinginputforwardoutputpostrouting"

var _NfTablesChainHookIndex = [...]uint8{0, 10, 15, 22, 28, 39}

const _NfTablesChainHookLowerName = "preroutinginputforwardoutputpostrouting"

func (i NfTablesChainHook) String() string {
	if i >= NfTablesChainHook(len(_NfTablesChainHookIndex)-1) {
		return fmt.Sprintf("NfTablesChainHook(%d)", i)
	}
	return _NfTablesChainHookName[_NfTablesChainHookIndex[i]:_NfTablesChainHookIndex[i+1]]
}

// An "invalid array index" compiler error signifies that the constant values have changed.
// Re-run the stringer command to generate them again.
func _NfTablesChainHookNoOp() {
	var x [1]struct{}
	_ = x[ChainHookPrerouting-(0)]
	_ = x[ChainHookInput-(1)]
	_ = x[ChainHookForward-(2)]
	_ = x[ChainHookOutput-(3)]
	_ = x[ChainHookPostrouting-(4)]
}

var _NfTablesChainHookValues = []NfTablesChainHook{ChainHookPrerouting, ChainHookInput, ChainHookForward, ChainHookOutput, ChainHookPostrouting}

var _NfTablesChainHookNameToValueMap = map[string]NfTablesChainHook{
	_NfTablesChainHookName[0:10]:       ChainHookPrerouting,
	_NfTablesChainHookLowerName[0:10]:  ChainHookPrerouting,
	_NfTablesChainHookName[10:15]:      ChainHookInput,
	_NfTablesChainHookLowerName[10:15]: ChainHookInput,
	_NfTablesChainHookName[15:22]:      ChainHookForward,
	_NfTablesChainHookLowerName[15:22]: ChainHookForward,
	_NfTablesChainHookName[22:28]:      ChainHookOutput,
	_NfTablesChainHookLowerName[22:28]: ChainHookOutput,
	_NfTablesChainHookName[28:39]:      ChainHookPostrouting,
	_NfTablesChainHookLowerName[28:39]: ChainHookPostrouting,
}

var _NfTablesChainHookNames = []string{
	_NfTablesChainHookName[0:10],
	_NfTablesChainHookName[10:15],
	_NfTablesChainHookName[15:22],
	_NfTablesChainHookName[22:28],
	_NfTablesChainHookName[28:39],
}

// NfTablesChainHookString retrieves an enum value from the enum constants string name.
// Throws an error if the param is not part of the enum.
func NfTablesChainHookString(s string) (NfTablesChainHook, error) {
	if val, ok := _NfTablesChainHookNameToValueMap[s]; ok {
		return val, nil
	}

	if val, ok := _NfTablesChainHookNameToValueMap[strings.ToLower(s)]; ok {
		return val, nil
	}
	return 0, fmt.Errorf("%s does not belong to NfTablesChainHook values", s)
}

// NfTablesChainHookValues returns all values of the enum
func NfTablesChainHookValues() []NfTablesChainHook {
	return _NfTablesChainHookValues
}

// NfTablesChainHookStrings returns a slice of all String values of the enum
func NfTablesChainHookStrings() []string {
	strs := make([]string, len(_NfTablesChainHookNames))
	copy(strs, _NfTablesChainHookNames)
	return strs
}

// IsANfTablesChainHook returns "true" if the value is listed in the enum definition. "false" otherwise
func (i NfTablesChainHook) IsANfTablesChainHook() bool {
	for _, v := range _NfTablesChainHookValues {
		if i == v {
			return true
		}
	}
	return false
}

// MarshalText implements the encoding.TextMarshaler interface for NfTablesChainHook
func (i NfTablesChainHook) MarshalText() ([]byte, error) {
	return []byte(i.String()), nil
}

// UnmarshalText implements the encoding.TextUnmarshaler interface for NfTablesChainHook
func (i *NfTablesChainHook) UnmarshalText(text []byte) error {
	var err error
	*i, err = NfTablesChainHookString(string(text))
	return err
}

const _NfTablesChainPriorityName = "firstconntrack-defragrawselinux-firstconntrackmanglenat-destfiltersecuritynat-sourceselinux-lastconntrack-helperlast"
const _NfTablesChainPriorityLowerName = "firstconntrack-defragrawselinux-firstconntrackmanglenat-destfiltersecuritynat-sourceselinux-lastconntrack-helperlast"

var _NfTablesChainPriorityMap = map[NfTablesChainPriority]string{
	-2147483648: _NfTablesChainPriorityName[0:5],
	-400:        _NfTablesChainPriorityName[5:21],
	-300:        _NfTablesChainPriorityName[21:24],
	-225:        _NfTablesChainPriorityName[24:37],
	-200:        _NfTablesChainPriorityName[37:46],
	-150:        _NfTablesChainPriorityName[46:52],
	-100:        _NfTablesChainPriorityName[52:60],
	0:           _NfTablesChainPriorityName[60:66],
	50:          _NfTablesChainPriorityName[66:74],
	100:         _NfTablesChainPriorityName[74:84],
	225:         _NfTablesChainPriorityName[84:96],
	300:         _NfTablesChainPriorityName[96:112],
	2147483647:  _NfTablesChainPriorityName[112:116],
}

func (i NfTablesChainPriority) String() string {
	if str, ok := _NfTablesChainPriorityMap[i]; ok {
		return str
	}
	return fmt.Sprintf("NfTablesChainPriority(%d)", i)
}

// An "invalid array index" compiler error signifies that the constant values have changed.
// Re-run the stringer command to generate them again.
func _NfTablesChainPriorityNoOp() {
	var x [1]struct{}
	_ = x[ChainPriorityFirst-(-2147483648)]
	_ = x[ChainPriorityConntrackDefrag-(-400)]
	_ = x[ChainPriorityRaw-(-300)]
	_ = x[ChainPrioritySELinuxFirst-(-225)]
	_ = x[ChainPriorityConntrack-(-200)]
	_ = x[ChainPriorityMangle-(-150)]
	_ = x[ChainPriorityNATDest-(-100)]
	_ = x[ChainPriorityFilter-(0)]
	_ = x[ChainPrioritySecurity-(50)]
	_ = x[ChainPriorityNATSource-(100)]
	_ = x[ChainPrioritySELinuxLast-(225)]
	_ = x[ChainPriorityConntrackHelper-(300)]
	_ = x[ChainPriorityLast-(2147483647)]
}

var _NfTablesChainPriorityValues = []NfTablesChainPriority{ChainPriorityFirst, ChainPriorityConntrackDefrag, ChainPriorityRaw, ChainPrioritySELinuxFirst, ChainPriorityConntrack, ChainPriorityMangle, ChainPriorityNATDest, ChainPriorityFilter, ChainPrioritySecurity, ChainPriorityNATSource, ChainPrioritySELinuxLast, ChainPriorityConntrackHelper, ChainPriorityLast}

var _NfTablesChainPriorityNameToValueMap = map[string]NfTablesChainPriority{
	_NfTablesChainPriorityName[0:5]:          ChainPriorityFirst,
	_NfTablesChainPriorityLowerName[0:5]:     ChainPriorityFirst,
	_NfTablesChainPriorityName[5:21]:         ChainPriorityConntrackDefrag,
	_NfTablesChainPriorityLowerName[5:21]:    ChainPriorityConntrackDefrag,
	_NfTablesChainPriorityName[21:24]:        ChainPriorityRaw,
	_NfTablesChainPriorityLowerName[21:24]:   ChainPriorityRaw,
	_NfTablesChainPriorityName[24:37]:        ChainPrioritySELinuxFirst,
	_NfTablesChainPriorityLowerName[24:37]:   ChainPrioritySELinuxFirst,
	_NfTablesChainPriorityName[37:46]:        ChainPriorityConntrack,
	_NfTablesChainPriorityLowerName[37:46]:   ChainPriorityConntrack,
	_NfTablesChainPriorityName[46:52]:        ChainPriorityMangle,
	_NfTablesChainPriorityLowerName[46:52]:   ChainPriorityMangle,
	_NfTablesChainPriorityName[52:60]:        ChainPriorityNATDest,
	_NfTablesChainPriorityLowerName[52:60]:   ChainPriorityNATDest,
	_NfTablesChainPriorityName[60:66]:        ChainPriorityFilter,
	_NfTablesChainPriorityLowerName[60:66]:   ChainPriorityFilter,
	_NfTablesChainPriorityName[66:74]:        ChainPrioritySecurity,
	_NfTablesChainPriorityLowerName[66:74]:   ChainPrioritySecurity,
	_NfTablesChainPriorityName[74:84]:        ChainPriorityNATSource,
	_NfTablesChainPriorityLowerName[74:84]:   ChainPriorityNATSource,
	_NfTablesChainPriorityName[84:96]:        ChainPrioritySELinuxLast,
	_NfTablesChainPriorityLowerName[84:96]:   ChainPrioritySELinuxLast,
	_NfTablesChainPriorityName[96:112]:       ChainPriorityConntrackHelper,
	_NfTablesChainPriorityLowerName[96:112]:  ChainPriorityConntrackHelper,
	_NfTablesChainPriorityName[112:116]:      ChainPriorityLast,
	_NfTablesChainPriorityLowerName[112:116]: ChainPriorityLast,
}

var _NfTablesChainPriorityNames = []string{
	_NfTablesChainPriorityName[0:5],
	_NfTablesChainPriorityName[5:21],
	_NfTablesChainPriorityName[21:24],
	_NfTablesChainPriorityName[24:37],
	_NfTablesChainPriorityName[37:46],
	_NfTablesChainPriorityName[46:52],
	_NfTablesChainPriorityName[52:60],
	_NfTablesChainPriorityName[60:66],
	_NfTablesChainPriorityName[66:74],
	_NfTablesChainPriorityName[74:84],
	_NfTablesChainPriorityName[84:96],
	_NfTablesChainPriorityName[96:112],
	_NfTablesChainPriorityName[112:116],
}

// NfTablesChainPriorityString retrieves an enum value from the enum constants string name.
// Throws an error if the param is not part of the enum.
func NfTablesChainPriorityString(s string) (NfTablesChainPriority, error) {
	if val, ok := _NfTablesChainPriorityNameToValueMap[s]; ok {
		return val, nil
	}

	if val, ok := _NfTablesChainPriorityNameToValueMap[strings.ToLower(s)]; ok {
		return val, nil
	}
	return 0, fmt.Errorf("%s does not belong to NfTablesChainPriority values", s)
}

// NfTablesChainPriorityValues returns all values of the enum
func NfTablesChainPriorityValues() []NfTablesChainPriority {
	return _NfTablesChainPriorityValues
}

// NfTablesChainPriorityStrings returns a slice of all String values of the enum
func NfTablesChainPriorityStrings() []string {
	strs := make([]string, len(_NfTablesChainPriorityNames))
	copy(strs, _NfTablesChainPriorityNames)
	return strs
}

// IsANfTablesChainPriority returns "true" if the value is listed in the enum definition. "false" otherwise
func (i NfTablesChainPriority) IsANfTablesChainPriority() bool {
	_, ok := _NfTablesChainPriorityMap[i]
	return ok
}

// MarshalText implements the encoding.TextMarshaler interface for NfTablesChainPriority
func (i NfTablesChainPriority) MarshalText() ([]byte, error) {
	return []byte(i.String()), nil
}

// UnmarshalText implements the encoding.TextUnmarshaler interface for NfTablesChainPriority
func (i *NfTablesChainPriority) UnmarshalText(text []byte) error {
	var err error
	*i, err = NfTablesChainPriorityString(string(text))
	return err
}

const _NfTablesVerdictName = "dropaccept"

var _NfTablesVerdictIndex = [...]uint8{0, 4, 10}

const _NfTablesVerdictLowerName = "dropaccept"

func (i NfTablesVerdict) String() string {
	if i < 0 || i >= NfTablesVerdict(len(_NfTablesVerdictIndex)-1) {
		return fmt.Sprintf("NfTablesVerdict(%d)", i)
	}
	return _NfTablesVerdictName[_NfTablesVerdictIndex[i]:_NfTablesVerdictIndex[i+1]]
}

// An "invalid array index" compiler error signifies that the constant values have changed.
// Re-run the stringer command to generate them again.
func _NfTablesVerdictNoOp() {
	var x [1]struct{}
	_ = x[VerdictDrop-(0)]
	_ = x[VerdictAccept-(1)]
}

var _NfTablesVerdictValues = []NfTablesVerdict{VerdictDrop, VerdictAccept}

var _NfTablesVerdictNameToValueMap = map[string]NfTablesVerdict{
	_NfTablesVerdictName[0:4]:       VerdictDrop,
	_NfTablesVerdictLowerName[0:4]:  VerdictDrop,
	_NfTablesVerdictName[4:10]:      VerdictAccept,
	_NfTablesVerdictLowerName[4:10]: VerdictAccept,
}

var _NfTablesVerdictNames = []string{
	_NfTablesVerdictName[0:4],
	_NfTablesVerdictName[4:10],
}

// NfTablesVerdictString retrieves an enum value from the enum constants string name.
// Throws an error if the param is not part of the enum.
func NfTablesVerdictString(s string) (NfTablesVerdict, error) {
	if val, ok := _NfTablesVerdictNameToValueMap[s]; ok {
		return val, nil
	}

	if val, ok := _NfTablesVerdictNameToValueMap[strings.ToLower(s)]; ok {
		return val, nil
	}
	return 0, fmt.Errorf("%s does not belong to NfTablesVerdict values", s)
}

// NfTablesVerdictValues returns all values of the enum
func NfTablesVerdictValues() []NfTablesVerdict {
	return _NfTablesVerdictValues
}

// NfTablesVerdictStrings returns a slice of all String values of the enum
func NfTablesVerdictStrings() []string {
	strs := make([]string, len(_NfTablesVerdictNames))
	copy(strs, _NfTablesVerdictNames)
	return strs
}

// IsANfTablesVerdict returns "true" if the value is listed in the enum definition. "false" otherwise
func (i NfTablesVerdict) IsANfTablesVerdict() bool {
	for _, v := range _NfTablesVerdictValues {
		if i == v {
			return true
		}
	}
	return false
}

// MarshalText implements the encoding.TextMarshaler interface for NfTablesVerdict
func (i NfTablesVerdict) MarshalText() ([]byte, error) {
	return []byte(i.String()), nil
}

// UnmarshalText implements the encoding.TextUnmarshaler interface for NfTablesVerdict
func (i *NfTablesVerdict) UnmarshalText(text []byte) error {
	var err error
	*i, err = NfTablesVerdictString(string(text))
	return err
}

const _OperationalStateName = "unknownnotPresentdownlowerLayerDowntestingdormantup"

var _OperationalStateIndex = [...]uint8{0, 7, 17, 21, 35, 42, 49, 51}

const _OperationalStateLowerName = "unknownnotpresentdownlowerlayerdowntestingdormantup"

func (i OperationalState) String() string {
	if i >= OperationalState(len(_OperationalStateIndex)-1) {
		return fmt.Sprintf("OperationalState(%d)", i)
	}
	return _OperationalStateName[_OperationalStateIndex[i]:_OperationalStateIndex[i+1]]
}

// An "invalid array index" compiler error signifies that the constant values have changed.
// Re-run the stringer command to generate them again.
func _OperationalStateNoOp() {
	var x [1]struct{}
	_ = x[OperStateUnknown-(0)]
	_ = x[OperStateNotPresent-(1)]
	_ = x[OperStateDown-(2)]
	_ = x[OperStateLowerLayerDown-(3)]
	_ = x[OperStateTesting-(4)]
	_ = x[OperStateDormant-(5)]
	_ = x[OperStateUp-(6)]
}

var _OperationalStateValues = []OperationalState{OperStateUnknown, OperStateNotPresent, OperStateDown, OperStateLowerLayerDown, OperStateTesting, OperStateDormant, OperStateUp}

var _OperationalStateNameToValueMap = map[string]OperationalState{
	_OperationalStateName[0:7]:        OperStateUnknown,
	_OperationalStateLowerName[0:7]:   OperStateUnknown,
	_OperationalStateName[7:17]:       OperStateNotPresent,
	_OperationalStateLowerName[7:17]:  OperStateNotPresent,
	_OperationalStateName[17:21]:      OperStateDown,
	_OperationalStateLowerName[17:21]: OperStateDown,
	_OperationalStateName[21:35]:      OperStateLowerLayerDown,
	_OperationalStateLowerName[21:35]: OperStateLowerLayerDown,
	_OperationalStateName[35:42]:      OperStateTesting,
	_OperationalStateLowerName[35:42]: OperStateTesting,
	_OperationalStateName[42:49]:      OperStateDormant,
	_OperationalStateLowerName[42:49]: OperStateDormant,
	_OperationalStateName[49:51]:      OperStateUp,
	_OperationalStateLowerName[49:51]: OperStateUp,
}

var _OperationalStateNames = []string{
	_OperationalStateName[0:7],
	_OperationalStateName[7:17],
	_OperationalStateName[17:21],
	_OperationalStateName[21:35],
	_OperationalStateName[35:42],
	_OperationalStateName[42:49],
	_OperationalStateName[49:51],
}

// OperationalStateString retrieves an enum value from the enum constants string name.
// Throws an error if the param is not part of the enum.
func OperationalStateString(s string) (OperationalState, error) {
	if val, ok := _OperationalStateNameToValueMap[s]; ok {
		return val, nil
	}

	if val, ok := _OperationalStateNameToValueMap[strings.ToLower(s)]; ok {
		return val, nil
	}
	return 0, fmt.Errorf("%s does not belong to OperationalState values", s)
}

// OperationalStateValues returns all values of the enum
func OperationalStateValues() []OperationalState {
	return _OperationalStateValues
}

// OperationalStateStrings returns a slice of all String values of the enum
func OperationalStateStrings() []string {
	strs := make([]string, len(_OperationalStateNames))
	copy(strs, _OperationalStateNames)
	return strs
}

// IsAOperationalState returns "true" if the value is listed in the enum definition. "false" otherwise
func (i OperationalState) IsAOperationalState() bool {
	for _, v := range _OperationalStateValues {
		if i == v {
			return true
		}
	}
	return false
}

// MarshalText implements the encoding.TextMarshaler interface for OperationalState
func (i OperationalState) MarshalText() ([]byte, error) {
	return []byte(i.String()), nil
}

// UnmarshalText implements the encoding.TextUnmarshaler interface for OperationalState
func (i *OperationalState) UnmarshalText(text []byte) error {
	var err error
	*i, err = OperationalStateString(string(text))
	return err
}

const (
	_PortName_0      = "TwistedPairAUIMIIBNCDirectAttach"
	_PortLowerName_0 = "twistedpairauimiibncdirectattach"
	_PortName_1      = "None"
	_PortLowerName_1 = "none"
	_PortName_2      = "Other"
	_PortLowerName_2 = "other"
)

var (
	_PortIndex_0 = [...]uint8{0, 11, 14, 17, 17, 20, 32}
	_PortIndex_1 = [...]uint8{0, 4}
	_PortIndex_2 = [...]uint8{0, 5}
)

func (i Port) String() string {
	switch {
	case 0 <= i && i <= 5:
		return _PortName_0[_PortIndex_0[i]:_PortIndex_0[i+1]]
	case i == 239:
		return _PortName_1
	case i == 255:
		return _PortName_2
	default:
		return fmt.Sprintf("Port(%d)", i)
	}
}

// An "invalid array index" compiler error signifies that the constant values have changed.
// Re-run the stringer command to generate them again.
func _PortNoOp() {
	var x [1]struct{}
	_ = x[TwistedPair-(0)]
	_ = x[AUI-(1)]
	_ = x[MII-(2)]
	_ = x[Fibre-(3)]
	_ = x[BNC-(4)]
	_ = x[DirectAttach-(5)]
	_ = x[None-(239)]
	_ = x[Other-(255)]
}

var _PortValues = []Port{TwistedPair, AUI, MII, Fibre, BNC, DirectAttach, None, Other}

var _PortNameToValueMap = map[string]Port{
	_PortName_0[0:11]:       TwistedPair,
	_PortLowerName_0[0:11]:  TwistedPair,
	_PortName_0[11:14]:      AUI,
	_PortLowerName_0[11:14]: AUI,
	_PortName_0[14:17]:      MII,
	_PortLowerName_0[14:17]: MII,
	_PortName_0[17:17]:      Fibre,
	_PortLowerName_0[17:17]: Fibre,
	_PortName_0[17:20]:      BNC,
	_PortLowerName_0[17:20]: BNC,
	_PortName_0[20:32]:      DirectAttach,
	_PortLowerName_0[20:32]: DirectAttach,
	_PortName_1[0:4]:        None,
	_PortLowerName_1[0:4]:   None,
	_PortName_2[0:5]:        Other,
	_PortLowerName_2[0:5]:   Other,
}

var _PortNames = []string{
	_PortName_0[0:11],
	_PortName_0[11:14],
	_PortName_0[14:17],
	_PortName_0[17:17],
	_PortName_0[17:20],
	_PortName_0[20:32],
	_PortName_1[0:4],
	_PortName_2[0:5],
}

// PortString retrieves an enum value from the enum constants string name.
// Throws an error if the param is not part of the enum.
func PortString(s string) (Port, error) {
	if val, ok := _PortNameToValueMap[s]; ok {
		return val, nil
	}

	if val, ok := _PortNameToValueMap[strings.ToLower(s)]; ok {
		return val, nil
	}
	return 0, fmt.Errorf("%s does not belong to Port values", s)
}

// PortValues returns all values of the enum
func PortValues() []Port {
	return _PortValues
}

// PortStrings returns a slice of all String values of the enum
func PortStrings() []string {
	strs := make([]string, len(_PortNames))
	copy(strs, _PortNames)
	return strs
}

// IsAPort returns "true" if the value is listed in the enum definition. "false" otherwise
func (i Port) IsAPort() bool {
	for _, v := range _PortValues {
		if i == v {
			return true
		}
	}
	return false
}

// MarshalText implements the encoding.TextMarshaler interface for Port
func (i Port) MarshalText() ([]byte, error) {
	return []byte(i.String()), nil
}

// UnmarshalText implements the encoding.TextUnmarshaler interface for Port
func (i *Port) UnmarshalText(text []byte) error {
	var err error
	*i, err = PortString(string(text))
	return err
}

const _PrimaryReselectName = "alwaysbetterfailure"

var _PrimaryReselectIndex = [...]uint8{0, 6, 12, 19}

const _PrimaryReselectLowerName = "alwaysbetterfailure"

func (i PrimaryReselect) String() string {
	if i >= PrimaryReselect(len(_PrimaryReselectIndex)-1) {
		return fmt.Sprintf("PrimaryReselect(%d)", i)
	}
	return _PrimaryReselectName[_PrimaryReselectIndex[i]:_PrimaryReselectIndex[i+1]]
}

// An "invalid array index" compiler error signifies that the constant values have changed.
// Re-run the stringer command to generate them again.
func _PrimaryReselectNoOp() {
	var x [1]struct{}
	_ = x[PrimaryReselectAlways-(0)]
	_ = x[PrimaryReselectBetter-(1)]
	_ = x[PrimaryReselectFailure-(2)]
}

var _PrimaryReselectValues = []PrimaryReselect{PrimaryReselectAlways, PrimaryReselectBetter, PrimaryReselectFailure}

var _PrimaryReselectNameToValueMap = map[string]PrimaryReselect{
	_PrimaryReselectName[0:6]:        PrimaryReselectAlways,
	_PrimaryReselectLowerName[0:6]:   PrimaryReselectAlways,
	_PrimaryReselectName[6:12]:       PrimaryReselectBetter,
	_PrimaryReselectLowerName[6:12]:  PrimaryReselectBetter,
	_PrimaryReselectName[12:19]:      PrimaryReselectFailure,
	_PrimaryReselectLowerName[12:19]: PrimaryReselectFailure,
}

var _PrimaryReselectNames = []string{
	_PrimaryReselectName[0:6],
	_PrimaryReselectName[6:12],
	_PrimaryReselectName[12:19],
}

// PrimaryReselectString retrieves an enum value from the enum constants string name.
// Throws an error if the param is not part of the enum.
func PrimaryReselectString(s string) (PrimaryReselect, error) {
	if val, ok := _PrimaryReselectNameToValueMap[s]; ok {
		return val, nil
	}

	if val, ok := _PrimaryReselectNameToValueMap[strings.ToLower(s)]; ok {
		return val, nil
	}
	return 0, fmt.Errorf("%s does not belong to PrimaryReselect values", s)
}

// PrimaryReselectValues returns all values of the enum
func PrimaryReselectValues() []PrimaryReselect {
	return _PrimaryReselectValues
}

// PrimaryReselectStrings returns a slice of all String values of the enum
func PrimaryReselectStrings() []string {
	strs := make([]string, len(_PrimaryReselectNames))
	copy(strs, _PrimaryReselectNames)
	return strs
}

// IsAPrimaryReselect returns "true" if the value is listed in the enum definition. "false" otherwise
func (i PrimaryReselect) IsAPrimaryReselect() bool {
	for _, v := range _PrimaryReselectValues {
		if i == v {
			return true
		}
	}
	return false
}

// MarshalText implements the encoding.TextMarshaler interface for PrimaryReselect
func (i PrimaryReselect) MarshalText() ([]byte, error) {
	return []byte(i.String()), nil
}

// UnmarshalText implements the encoding.TextUnmarshaler interface for PrimaryReselect
func (i *PrimaryReselect) UnmarshalText(text []byte) error {
	var err error
	*i, err = PrimaryReselectString(string(text))
	return err
}

const (
	_ProtocolName_0      = "icmp"
	_ProtocolLowerName_0 = "icmp"
	_ProtocolName_1      = "tcp"
	_ProtocolLowerName_1 = "tcp"
	_ProtocolName_2      = "udp"
	_ProtocolLowerName_2 = "udp"
	_ProtocolName_3      = "icmpv6"
	_ProtocolLowerName_3 = "icmpv6"
)

var (
	_ProtocolIndex_0 = [...]uint8{0, 4}
	_ProtocolIndex_1 = [...]uint8{0, 3}
	_ProtocolIndex_2 = [...]uint8{0, 3}
	_ProtocolIndex_3 = [...]uint8{0, 6}
)

func (i Protocol) String() string {
	switch {
	case i == 1:
		return _ProtocolName_0
	case i == 6:
		return _ProtocolName_1
	case i == 17:
		return _ProtocolName_2
	case i == 58:
		return _ProtocolName_3
	default:
		return fmt.Sprintf("Protocol(%d)", i)
	}
}

// An "invalid array index" compiler error signifies that the constant values have changed.
// Re-run the stringer command to generate them again.
func _ProtocolNoOp() {
	var x [1]struct{}
	_ = x[ProtocolICMP-(1)]
	_ = x[ProtocolTCP-(6)]
	_ = x[ProtocolUDP-(17)]
	_ = x[ProtocolICMPv6-(58)]
}

var _ProtocolValues = []Protocol{ProtocolICMP, ProtocolTCP, ProtocolUDP, ProtocolICMPv6}

var _ProtocolNameToValueMap = map[string]Protocol{
	_ProtocolName_0[0:4]:      ProtocolICMP,
	_ProtocolLowerName_0[0:4]: ProtocolICMP,
	_ProtocolName_1[0:3]:      ProtocolTCP,
	_ProtocolLowerName_1[0:3]: ProtocolTCP,
	_ProtocolName_2[0:3]:      ProtocolUDP,
	_ProtocolLowerName_2[0:3]: ProtocolUDP,
	_ProtocolName_3[0:6]:      ProtocolICMPv6,
	_ProtocolLowerName_3[0:6]: ProtocolICMPv6,
}

var _ProtocolNames = []string{
	_ProtocolName_0[0:4],
	_ProtocolName_1[0:3],
	_ProtocolName_2[0:3],
	_ProtocolName_3[0:6],
}

// ProtocolString retrieves an enum value from the enum constants string name.
// Throws an error if the param is not part of the enum.
func ProtocolString(s string) (Protocol, error) {
	if val, ok := _ProtocolNameToValueMap[s]; ok {
		return val, nil
	}

	if val, ok := _ProtocolNameToValueMap[strings.ToLower(s)]; ok {
		return val, nil
	}
	return 0, fmt.Errorf("%s does not belong to Protocol values", s)
}

// ProtocolValues returns all values of the enum
func ProtocolValues() []Protocol {
	return _ProtocolValues
}

// ProtocolStrings returns a slice of all String values of the enum
func ProtocolStrings() []string {
	strs := make([]string, len(_ProtocolNames))
	copy(strs, _ProtocolNames)
	return strs
}

// IsAProtocol returns "true" if the value is listed in the enum definition. "false" otherwise
func (i Protocol) IsAProtocol() bool {
	for _, v := range _ProtocolValues {
		if i == v {
			return true
		}
	}
	return false
}

// MarshalText implements the encoding.TextMarshaler interface for Protocol
func (i Protocol) MarshalText() ([]byte, error) {
	return []byte(i.String()), nil
}

// UnmarshalText implements the encoding.TextUnmarshaler interface for Protocol
func (i *Protocol) UnmarshalText(text []byte) error {
	var err error
	*i, err = ProtocolString(string(text))
	return err
}

const (
	_RouteFlagName_0      = "notify"
	_RouteFlagLowerName_0 = "notify"
	_RouteFlagName_1      = "cloned"
	_RouteFlagLowerName_1 = "cloned"
	_RouteFlagName_2      = "equalize"
	_RouteFlagLowerName_2 = "equalize"
	_RouteFlagName_3      = "prefix"
	_RouteFlagLowerName_3 = "prefix"
	_RouteFlagName_4      = "lookup_table"
	_RouteFlagLowerName_4 = "lookup_table"
	_RouteFlagName_5      = "fib_match"
	_RouteFlagLowerName_5 = "fib_match"
	_RouteFlagName_6      = "offload"
	_RouteFlagLowerName_6 = "offload"
	_RouteFlagName_7      = "trap"
	_RouteFlagLowerName_7 = "trap"
)

var (
	_RouteFlagIndex_0 = [...]uint8{0, 6}
	_RouteFlagIndex_1 = [...]uint8{0, 6}
	_RouteFlagIndex_2 = [...]uint8{0, 8}
	_RouteFlagIndex_3 = [...]uint8{0, 6}
	_RouteFlagIndex_4 = [...]uint8{0, 12}
	_RouteFlagIndex_5 = [...]uint8{0, 9}
	_RouteFlagIndex_6 = [...]uint8{0, 7}
	_RouteFlagIndex_7 = [...]uint8{0, 4}
)

func (i RouteFlag) String() string {
	switch {
	case i == 256:
		return _RouteFlagName_0
	case i == 512:
		return _RouteFlagName_1
	case i == 1024:
		return _RouteFlagName_2
	case i == 2048:
		return _RouteFlagName_3
	case i == 4096:
		return _RouteFlagName_4
	case i == 8192:
		return _RouteFlagName_5
	case i == 16384:
		return _RouteFlagName_6
	case i == 32768:
		return _RouteFlagName_7
	default:
		return fmt.Sprintf("RouteFlag(%d)", i)
	}
}

// An "invalid array index" compiler error signifies that the constant values have changed.
// Re-run the stringer command to generate them again.
func _RouteFlagNoOp() {
	var x [1]struct{}
	_ = x[RouteNotify-(256)]
	_ = x[RouteCloned-(512)]
	_ = x[RouteEqualize-(1024)]
	_ = x[RoutePrefix-(2048)]
	_ = x[RouteLookupTable-(4096)]
	_ = x[RouteFIBMatch-(8192)]
	_ = x[RouteOffload-(16384)]
	_ = x[RouteTrap-(32768)]
}

var _RouteFlagValues = []RouteFlag{RouteNotify, RouteCloned, RouteEqualize, RoutePrefix, RouteLookupTable, RouteFIBMatch, RouteOffload, RouteTrap}

var _RouteFlagNameToValueMap = map[string]RouteFlag{
	_RouteFlagName_0[0:6]:       RouteNotify,
	_RouteFlagLowerName_0[0:6]:  RouteNotify,
	_RouteFlagName_1[0:6]:       RouteCloned,
	_RouteFlagLowerName_1[0:6]:  RouteCloned,
	_RouteFlagName_2[0:8]:       RouteEqualize,
	_RouteFlagLowerName_2[0:8]:  RouteEqualize,
	_RouteFlagName_3[0:6]:       RoutePrefix,
	_RouteFlagLowerName_3[0:6]:  RoutePrefix,
	_RouteFlagName_4[0:12]:      RouteLookupTable,
	_RouteFlagLowerName_4[0:12]: RouteLookupTable,
	_RouteFlagName_5[0:9]:       RouteFIBMatch,
	_RouteFlagLowerName_5[0:9]:  RouteFIBMatch,
	_RouteFlagName_6[0:7]:       RouteOffload,
	_RouteFlagLowerName_6[0:7]:  RouteOffload,
	_RouteFlagName_7[0:4]:       RouteTrap,
	_RouteFlagLowerName_7[0:4]:  RouteTrap,
}

var _RouteFlagNames = []string{
	_RouteFlagName_0[0:6],
	_RouteFlagName_1[0:6],
	_RouteFlagName_2[0:8],
	_RouteFlagName_3[0:6],
	_RouteFlagName_4[0:12],
	_RouteFlagName_5[0:9],
	_RouteFlagName_6[0:7],
	_RouteFlagName_7[0:4],
}

// RouteFlagString retrieves an enum value from the enum constants string name.
// Throws an error if the param is not part of the enum.
func RouteFlagString(s string) (RouteFlag, error) {
	if val, ok := _RouteFlagNameToValueMap[s]; ok {
		return val, nil
	}

	if val, ok := _RouteFlagNameToValueMap[strings.ToLower(s)]; ok {
		return val, nil
	}
	return 0, fmt.Errorf("%s does not belong to RouteFlag values", s)
}

// RouteFlagValues returns all values of the enum
func RouteFlagValues() []RouteFlag {
	return _RouteFlagValues
}

// RouteFlagStrings returns a slice of all String values of the enum
func RouteFlagStrings() []string {
	strs := make([]string, len(_RouteFlagNames))
	copy(strs, _RouteFlagNames)
	return strs
}

// IsARouteFlag returns "true" if the value is listed in the enum definition. "false" otherwise
func (i RouteFlag) IsARouteFlag() bool {
	for _, v := range _RouteFlagValues {
		if i == v {
			return true
		}
	}
	return false
}

// MarshalText implements the encoding.TextMarshaler interface for RouteFlag
func (i RouteFlag) MarshalText() ([]byte, error) {
	return []byte(i.String()), nil
}

// UnmarshalText implements the encoding.TextUnmarshaler interface for RouteFlag
func (i *RouteFlag) UnmarshalText(text []byte) error {
	var err error
	*i, err = RouteFlagString(string(text))
	return err
}

const (
	_RouteProtocolName_0      = "unspecredirectkernelbootstatic"
	_RouteProtocolLowerName_0 = "unspecredirectkernelbootstatic"
	_RouteProtocolName_1      = "ramrtzebrabirddnroutedxorpntkdhcpmrtdkeepalived"
	_RouteProtocolLowerName_1 = "ramrtzebrabirddnroutedxorpntkdhcpmrtdkeepalived"
	_RouteProtocolName_2      = "babel"
	_RouteProtocolLowerName_2 = "babel"
	_RouteProtocolName_3      = "openr"
	_RouteProtocolLowerName_3 = "openr"
	_RouteProtocolName_4      = "bgpisisospfrip"
	_RouteProtocolLowerName_4 = "bgpisisospfrip"
	_RouteProtocolName_5      = "eigrp"
	_RouteProtocolLowerName_5 = "eigrp"
)

var (
	_RouteProtocolIndex_0 = [...]uint8{0, 6, 14, 20, 24, 30}
	_RouteProtocolIndex_1 = [...]uint8{0, 2, 5, 10, 14, 22, 26, 29, 33, 37, 47}
	_RouteProtocolIndex_2 = [...]uint8{0, 5}
	_RouteProtocolIndex_3 = [...]uint8{0, 5}
	_RouteProtocolIndex_4 = [...]uint8{0, 3, 7, 11, 14}
	_RouteProtocolIndex_5 = [...]uint8{0, 5}
)

func (i RouteProtocol) String() string {
	switch {
	case 0 <= i && i <= 4:
		return _RouteProtocolName_0[_RouteProtocolIndex_0[i]:_RouteProtocolIndex_0[i+1]]
	case 9 <= i && i <= 18:
		i -= 9
		return _RouteProtocolName_1[_RouteProtocolIndex_1[i]:_RouteProtocolIndex_1[i+1]]
	case i == 42:
		return _RouteProtocolName_2
	case i == 99:
		return _RouteProtocolName_3
	case 186 <= i && i <= 189:
		i -= 186
		return _RouteProtocolName_4[_RouteProtocolIndex_4[i]:_RouteProtocolIndex_4[i+1]]
	case i == 192:
		return _RouteProtocolName_5
	default:
		return fmt.Sprintf("RouteProtocol(%d)", i)
	}
}

// An "invalid array index" compiler error signifies that the constant values have changed.
// Re-run the stringer command to generate them again.
func _RouteProtocolNoOp() {
	var x [1]struct{}
	_ = x[ProtocolUnspec-(0)]
	_ = x[ProtocolRedirect-(1)]
	_ = x[ProtocolKernel-(2)]
	_ = x[ProtocolBoot-(3)]
	_ = x[ProtocolStatic-(4)]
	_ = x[ProtocolRA-(9)]
	_ = x[ProtocolMRT-(10)]
	_ = x[ProtocolZebra-(11)]
	_ = x[ProtocolBird-(12)]
	_ = x[ProtocolDnrouted-(13)]
	_ = x[ProtocolXorp-(14)]
	_ = x[ProtocolNTK-(15)]
	_ = x[ProtocolDHCP-(16)]
	_ = x[ProtocolMRTD-(17)]
	_ = x[ProtocolKeepalived-(18)]
	_ = x[ProtocolBabel-(42)]
	_ = x[ProtocolOpenr-(99)]
	_ = x[ProtocolBGP-(186)]
	_ = x[ProtocolISIS-(187)]
	_ = x[ProtocolOSPF-(188)]
	_ = x[ProtocolRIP-(189)]
	_ = x[ProtocolEIGRP-(192)]
}

var _RouteProtocolValues = []RouteProtocol{ProtocolUnspec, ProtocolRedirect, ProtocolKernel, ProtocolBoot, ProtocolStatic, ProtocolRA, ProtocolMRT, ProtocolZebra, ProtocolBird, ProtocolDnrouted, ProtocolXorp, ProtocolNTK, ProtocolDHCP, ProtocolMRTD, ProtocolKeepalived, ProtocolBabel, ProtocolOpenr, ProtocolBGP, ProtocolISIS, ProtocolOSPF, ProtocolRIP, ProtocolEIGRP}

var _RouteProtocolNameToValueMap = map[string]RouteProtocol{
	_RouteProtocolName_0[0:6]:        ProtocolUnspec,
	_RouteProtocolLowerName_0[0:6]:   ProtocolUnspec,
	_RouteProtocolName_0[6:14]:       ProtocolRedirect,
	_RouteProtocolLowerName_0[6:14]:  ProtocolRedirect,
	_RouteProtocolName_0[14:20]:      ProtocolKernel,
	_RouteProtocolLowerName_0[14:20]: ProtocolKernel,
	_RouteProtocolName_0[20:24]:      ProtocolBoot,
	_RouteProtocolLowerName_0[20:24]: ProtocolBoot,
	_RouteProtocolName_0[24:30]:      ProtocolStatic,
	_RouteProtocolLowerName_0[24:30]: ProtocolStatic,
	_RouteProtocolName_1[0:2]:        ProtocolRA,
	_RouteProtocolLowerName_1[0:2]:   ProtocolRA,
	_RouteProtocolName_1[2:5]:        ProtocolMRT,
	_RouteProtocolLowerName_1[2:5]:   ProtocolMRT,
	_RouteProtocolName_1[5:10]:       ProtocolZebra,
	_RouteProtocolLowerName_1[5:10]:  ProtocolZebra,
	_RouteProtocolName_1[10:14]:      ProtocolBird,
	_RouteProtocolLowerName_1[10:14]: ProtocolBird,
	_RouteProtocolName_1[14:22]:      ProtocolDnrouted,
	_RouteProtocolLowerName_1[14:22]: ProtocolDnrouted,
	_RouteProtocolName_1[22:26]:      ProtocolXorp,
	_RouteProtocolLowerName_1[22:26]: ProtocolXorp,
	_RouteProtocolName_1[26:29]:      ProtocolNTK,
	_RouteProtocolLowerName_1[26:29]: ProtocolNTK,
	_RouteProtocolName_1[29:33]:      ProtocolDHCP,
	_RouteProtocolLowerName_1[29:33]: ProtocolDHCP,
	_RouteProtocolName_1[33:37]:      ProtocolMRTD,
	_RouteProtocolLowerName_1[33:37]: ProtocolMRTD,
	_RouteProtocolName_1[37:47]:      ProtocolKeepalived,
	_RouteProtocolLowerName_1[37:47]: ProtocolKeepalived,
	_RouteProtocolName_2[0:5]:        ProtocolBabel,
	_RouteProtocolLowerName_2[0:5]:   ProtocolBabel,
	_RouteProtocolName_3[0:5]:        ProtocolOpenr,
	_RouteProtocolLowerName_3[0:5]:   ProtocolOpenr,
	_RouteProtocolName_4[0:3]:        ProtocolBGP,
	_RouteProtocolLowerName_4[0:3]:   ProtocolBGP,
	_RouteProtocolName_4[3:7]:        ProtocolISIS,
	_RouteProtocolLowerName_4[3:7]:   ProtocolISIS,
	_RouteProtocolName_4[7:11]:       ProtocolOSPF,
	_RouteProtocolLowerName_4[7:11]:  ProtocolOSPF,
	_RouteProtocolName_4[11:14]:      ProtocolRIP,
	_RouteProtocolLowerName_4[11:14]: ProtocolRIP,
	_RouteProtocolName_5[0:5]:        ProtocolEIGRP,
	_RouteProtocolLowerName_5[0:5]:   ProtocolEIGRP,
}

var _RouteProtocolNames = []string{
	_RouteProtocolName_0[0:6],
	_RouteProtocolName_0[6:14],
	_RouteProtocolName_0[14:20],
	_RouteProtocolName_0[20:24],
	_RouteProtocolName_0[24:30],
	_RouteProtocolName_1[0:2],
	_RouteProtocolName_1[2:5],
	_RouteProtocolName_1[5:10],
	_RouteProtocolName_1[10:14],
	_RouteProtocolName_1[14:22],
	_RouteProtocolName_1[22:26],
	_RouteProtocolName_1[26:29],
	_RouteProtocolName_1[29:33],
	_RouteProtocolName_1[33:37],
	_RouteProtocolName_1[37:47],
	_RouteProtocolName_2[0:5],
	_RouteProtocolName_3[0:5],
	_RouteProtocolName_4[0:3],
	_RouteProtocolName_4[3:7],
	_RouteProtocolName_4[7:11],
	_RouteProtocolName_4[11:14],
	_RouteProtocolName_5[0:5],
}

// RouteProtocolString retrieves an enum value from the enum constants string name.
// Throws an error if the param is not part of the enum.
func RouteProtocolString(s string) (RouteProtocol, error) {
	if val, ok := _RouteProtocolNameToValueMap[s]; ok {
		return val, nil
	}

	if val, ok := _RouteProtocolNameToValueMap[strings.ToLower(s)]; ok {
		return val, nil
	}
	return 0, fmt.Errorf("%s does not belong to RouteProtocol values", s)
}

// RouteProtocolValues returns all values of the enum
func RouteProtocolValues() []RouteProtocol {
	return _RouteProtocolValues
}

// RouteProtocolStrings returns a slice of all String values of the enum
func RouteProtocolStrings() []string {
	strs := make([]string, len(_RouteProtocolNames))
	copy(strs, _RouteProtocolNames)
	return strs
}

// IsARouteProtocol returns "true" if the value is listed in the enum definition. "false" otherwise
func (i RouteProtocol) IsARouteProtocol() bool {
	for _, v := range _RouteProtocolValues {
		if i == v {
			return true
		}
	}
	return false
}

// MarshalText implements the encoding.TextMarshaler interface for RouteProtocol
func (i RouteProtocol) MarshalText() ([]byte, error) {
	return []byte(i.String()), nil
}

// UnmarshalText implements the encoding.TextUnmarshaler interface for RouteProtocol
func (i *RouteProtocol) UnmarshalText(text []byte) error {
	var err error
	*i, err = RouteProtocolString(string(text))
	return err
}

const _RouteTypeName = "unspecunicastlocalbroadcastanycastmulticastblackholeunreachableprohibitthrownatxresolve"

var _RouteTypeIndex = [...]uint8{0, 6, 13, 18, 27, 34, 43, 52, 63, 71, 76, 79, 87}

const _RouteTypeLowerName = "unspecunicastlocalbroadcastanycastmulticastblackholeunreachableprohibitthrownatxresolve"

func (i RouteType) String() string {
	if i >= RouteType(len(_RouteTypeIndex)-1) {
		return fmt.Sprintf("RouteType(%d)", i)
	}
	return _RouteTypeName[_RouteTypeIndex[i]:_RouteTypeIndex[i+1]]
}

// An "invalid array index" compiler error signifies that the constant values have changed.
// Re-run the stringer command to generate them again.
func _RouteTypeNoOp() {
	var x [1]struct{}
	_ = x[TypeUnspec-(0)]
	_ = x[TypeUnicast-(1)]
	_ = x[TypeLocal-(2)]
	_ = x[TypeBroadcast-(3)]
	_ = x[TypeAnycast-(4)]
	_ = x[TypeMulticast-(5)]
	_ = x[TypeBlackhole-(6)]
	_ = x[TypeUnreachable-(7)]
	_ = x[TypeProhibit-(8)]
	_ = x[TypeThrow-(9)]
	_ = x[TypeNAT-(10)]
	_ = x[TypeXResolve-(11)]
}

var _RouteTypeValues = []RouteType{TypeUnspec, TypeUnicast, TypeLocal, TypeBroadcast, TypeAnycast, TypeMulticast, TypeBlackhole, TypeUnreachable, TypeProhibit, TypeThrow, TypeNAT, TypeXResolve}

var _RouteTypeNameToValueMap = map[string]RouteType{
	_RouteTypeName[0:6]:        TypeUnspec,
	_RouteTypeLowerName[0:6]:   TypeUnspec,
	_RouteTypeName[6:13]:       TypeUnicast,
	_RouteTypeLowerName[6:13]:  TypeUnicast,
	_RouteTypeName[13:18]:      TypeLocal,
	_RouteTypeLowerName[13:18]: TypeLocal,
	_RouteTypeName[18:27]:      TypeBroadcast,
	_RouteTypeLowerName[18:27]: TypeBroadcast,
	_RouteTypeName[27:34]:      TypeAnycast,
	_RouteTypeLowerName[27:34]: TypeAnycast,
	_RouteTypeName[34:43]:      TypeMulticast,
	_RouteTypeLowerName[34:43]: TypeMulticast,
	_RouteTypeName[43:52]:      TypeBlackhole,
	_RouteTypeLowerName[43:52]: TypeBlackhole,
	_RouteTypeName[52:63]:      TypeUnreachable,
	_RouteTypeLowerName[52:63]: TypeUnreachable,
	_RouteTypeName[63:71]:      TypeProhibit,
	_RouteTypeLowerName[63:71]: TypeProhibit,
	_RouteTypeName[71:76]:      TypeThrow,
	_RouteTypeLowerName[71:76]: TypeThrow,
	_RouteTypeName[76:79]:      TypeNAT,
	_RouteTypeLowerName[76:79]: TypeNAT,
	_RouteTypeName[79:87]:      TypeXResolve,
	_RouteTypeLowerName[79:87]: TypeXResolve,
}

var _RouteTypeNames = []string{
	_RouteTypeName[0:6],
	_RouteTypeName[6:13],
	_RouteTypeName[13:18],
	_RouteTypeName[18:27],
	_RouteTypeName[27:34],
	_RouteTypeName[34:43],
	_RouteTypeName[43:52],
	_RouteTypeName[52:63],
	_RouteTypeName[63:71],
	_RouteTypeName[71:76],
	_RouteTypeName[76:79],
	_RouteTypeName[79:87],
}

// RouteTypeString retrieves an enum value from the enum constants string name.
// Throws an error if the param is not part of the enum.
func RouteTypeString(s string) (RouteType, error) {
	if val, ok := _RouteTypeNameToValueMap[s]; ok {
		return val, nil
	}

	if val, ok := _RouteTypeNameToValueMap[strings.ToLower(s)]; ok {
		return val, nil
	}
	return 0, fmt.Errorf("%s does not belong to RouteType values", s)
}

// RouteTypeValues returns all values of the enum
func RouteTypeValues() []RouteType {
	return _RouteTypeValues
}

// RouteTypeStrings returns a slice of all String values of the enum
func RouteTypeStrings() []string {
	strs := make([]string, len(_RouteTypeNames))
	copy(strs, _RouteTypeNames)
	return strs
}

// IsARouteType returns "true" if the value is listed in the enum definition. "false" otherwise
func (i RouteType) IsARouteType() bool {
	for _, v := range _RouteTypeValues {
		if i == v {
			return true
		}
	}
	return false
}

// MarshalText implements the encoding.TextMarshaler interface for RouteType
func (i RouteType) MarshalText() ([]byte, error) {
	return []byte(i.String()), nil
}

// UnmarshalText implements the encoding.TextUnmarshaler interface for RouteType
func (i *RouteType) UnmarshalText(text []byte) error {
	var err error
	*i, err = RouteTypeString(string(text))
	return err
}

const (
	_RoutingRuleActionName_0      = "unspecunicast"
	_RoutingRuleActionLowerName_0 = "unspecunicast"
	_RoutingRuleActionName_1      = "blackholeunreachableprohibit"
	_RoutingRuleActionLowerName_1 = "blackholeunreachableprohibit"
)

var (
	_RoutingRuleActionIndex_0 = [...]uint8{0, 6, 13}
	_RoutingRuleActionIndex_1 = [...]uint8{0, 9, 20, 28}
)

func (i RoutingRuleAction) String() string {
	switch {
	case 0 <= i && i <= 1:
		return _RoutingRuleActionName_0[_RoutingRuleActionIndex_0[i]:_RoutingRuleActionIndex_0[i+1]]
	case 6 <= i && i <= 8:
		i -= 6
		return _RoutingRuleActionName_1[_RoutingRuleActionIndex_1[i]:_RoutingRuleActionIndex_1[i+1]]
	default:
		return fmt.Sprintf("RoutingRuleAction(%d)", i)
	}
}

// An "invalid array index" compiler error signifies that the constant values have changed.
// Re-run the stringer command to generate them again.
func _RoutingRuleActionNoOp() {
	var x [1]struct{}
	_ = x[RoutingRuleActionUnspec-(0)]
	_ = x[RoutingRuleActionUnicast-(1)]
	_ = x[RoutingRuleActionBlackhole-(6)]
	_ = x[RoutingRuleActionUnreachable-(7)]
	_ = x[RoutingRuleActionProhibit-(8)]
}

var _RoutingRuleActionValues = []RoutingRuleAction{RoutingRuleActionUnspec, RoutingRuleActionUnicast, RoutingRuleActionBlackhole, RoutingRuleActionUnreachable, RoutingRuleActionProhibit}

var _RoutingRuleActionNameToValueMap = map[string]RoutingRuleAction{
	_RoutingRuleActionName_0[0:6]:        RoutingRuleActionUnspec,
	_RoutingRuleActionLowerName_0[0:6]:   RoutingRuleActionUnspec,
	_RoutingRuleActionName_0[6:13]:       RoutingRuleActionUnicast,
	_RoutingRuleActionLowerName_0[6:13]:  RoutingRuleActionUnicast,
	_RoutingRuleActionName_1[0:9]:        RoutingRuleActionBlackhole,
	_RoutingRuleActionLowerName_1[0:9]:   RoutingRuleActionBlackhole,
	_RoutingRuleActionName_1[9:20]:       RoutingRuleActionUnreachable,
	_RoutingRuleActionLowerName_1[9:20]:  RoutingRuleActionUnreachable,
	_RoutingRuleActionName_1[20:28]:      RoutingRuleActionProhibit,
	_RoutingRuleActionLowerName_1[20:28]: RoutingRuleActionProhibit,
}

var _RoutingRuleActionNames = []string{
	_RoutingRuleActionName_0[0:6],
	_RoutingRuleActionName_0[6:13],
	_RoutingRuleActionName_1[0:9],
	_RoutingRuleActionName_1[9:20],
	_RoutingRuleActionName_1[20:28],
}

// RoutingRuleActionString retrieves an enum value from the enum constants string name.
// Throws an error if the param is not part of the enum.
func RoutingRuleActionString(s string) (RoutingRuleAction, error) {
	if val, ok := _RoutingRuleActionNameToValueMap[s]; ok {
		return val, nil
	}

	if val, ok := _RoutingRuleActionNameToValueMap[strings.ToLower(s)]; ok {
		return val, nil
	}
	return 0, fmt.Errorf("%s does not belong to RoutingRuleAction values", s)
}

// RoutingRuleActionValues returns all values of the enum
func RoutingRuleActionValues() []RoutingRuleAction {
	return _RoutingRuleActionValues
}

// RoutingRuleActionStrings returns a slice of all String values of the enum
func RoutingRuleActionStrings() []string {
	strs := make([]string, len(_RoutingRuleActionNames))
	copy(strs, _RoutingRuleActionNames)
	return strs
}

// IsARoutingRuleAction returns "true" if the value is listed in the enum definition. "false" otherwise
func (i RoutingRuleAction) IsARoutingRuleAction() bool {
	for _, v := range _RoutingRuleActionValues {
		if i == v {
			return true
		}
	}
	return false
}

// MarshalText implements the encoding.TextMarshaler interface for RoutingRuleAction
func (i RoutingRuleAction) MarshalText() ([]byte, error) {
	return []byte(i.String()), nil
}

// UnmarshalText implements the encoding.TextUnmarshaler interface for RoutingRuleAction
func (i *RoutingRuleAction) UnmarshalText(text []byte) error {
	var err error
	*i, err = RoutingRuleActionString(string(text))
	return err
}

const _RoutingTableName = "unspec123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252defaultmainlocal"

var _RoutingTableIndex = [...]uint16{0, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 17, 19, 21, 23, 25, 27, 29, 31, 33, 35, 37, 39, 41, 43, 45, 47, 49, 51, 53, 55, 57, 59, 61, 63, 65, 67, 69, 71, 73, 75, 77, 79, 81, 83, 85, 87, 89, 91, 93, 95, 97, 99, 101, 103, 105, 107, 109, 111, 113, 115, 117, 119, 121, 123, 125, 127, 129, 131, 133, 135, 137, 139, 141, 143, 145, 147, 149, 151, 153, 155, 157, 159, 161, 163, 165, 167, 169, 171, 173, 175, 177, 179, 181, 183, 185, 187, 189, 191, 193, 195, 198, 201, 204, 207, 210, 213, 216, 219, 222, 225, 228, 231, 234, 237, 240, 243, 246, 249, 252, 255, 258, 261, 264, 267, 270, 273, 276, 279, 282, 285, 288, 291, 294, 297, 300, 303, 306, 309, 312, 315, 318, 321, 324, 327, 330, 333, 336, 339, 342, 345, 348, 351, 354, 357, 360, 363, 366, 369, 372, 375, 378, 381, 384, 387, 390, 393, 396, 399, 402, 405, 408, 411, 414, 417, 420, 423, 426, 429, 432, 435, 438, 441, 444, 447, 450, 453, 456, 459, 462, 465, 468, 471, 474, 477, 480, 483, 486, 489, 492, 495, 498, 501, 504, 507, 510, 513, 516, 519, 522, 525, 528, 531, 534, 537, 540, 543, 546, 549, 552, 555, 558, 561, 564, 567, 570, 573, 576, 579, 582, 585, 588, 591, 594, 597, 600, 603, 606, 609, 612, 615, 618, 621, 624, 627, 630, 633, 636, 639, 642, 645, 648, 651, 654, 661, 665, 670}

const _RoutingTableLowerName = "unspec123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252defaultmainlocal"

func (i RoutingTable) String() string {
	if i >= RoutingTable(len(_RoutingTableIndex)-1) {
		return fmt.Sprintf("RoutingTable(%d)", i)
	}
	return _RoutingTableName[_RoutingTableIndex[i]:_RoutingTableIndex[i+1]]
}

// An "invalid array index" compiler error signifies that the constant values have changed.
// Re-run the stringer command to generate them again.
func _RoutingTableNoOp() {
	var x [1]struct{}
	_ = x[TableUnspec-(0)]
	_ = x[Table1-(1)]
	_ = x[Table2-(2)]
	_ = x[Table3-(3)]
	_ = x[Table4-(4)]
	_ = x[Table5-(5)]
	_ = x[Table6-(6)]
	_ = x[Table7-(7)]
	_ = x[Table8-(8)]
	_ = x[Table9-(9)]
	_ = x[Table10-(10)]
	_ = x[Table11-(11)]
	_ = x[Table12-(12)]
	_ = x[Table13-(13)]
	_ = x[Table14-(14)]
	_ = x[Table15-(15)]
	_ = x[Table16-(16)]
	_ = x[Table17-(17)]
	_ = x[Table18-(18)]
	_ = x[Table19-(19)]
	_ = x[Table20-(20)]
	_ = x[Table21-(21)]
	_ = x[Table22-(22)]
	_ = x[Table23-(23)]
	_ = x[Table24-(24)]
	_ = x[Table25-(25)]
	_ = x[Table26-(26)]
	_ = x[Table27-(27)]
	_ = x[Table28-(28)]
	_ = x[Table29-(29)]
	_ = x[Table30-(30)]
	_ = x[Table31-(31)]
	_ = x[Table32-(32)]
	_ = x[Table33-(33)]
	_ = x[Table34-(34)]
	_ = x[Table35-(35)]
	_ = x[Table36-(36)]
	_ = x[Table37-(37)]
	_ = x[Table38-(38)]
	_ = x[Table39-(39)]
	_ = x[Table40-(40)]
	_ = x[Table41-(41)]
	_ = x[Table42-(42)]
	_ = x[Table43-(43)]
	_ = x[Table44-(44)]
	_ = x[Table45-(45)]
	_ = x[Table46-(46)]
	_ = x[Table47-(47)]
	_ = x[Table48-(48)]
	_ = x[Table49-(49)]
	_ = x[Table50-(50)]
	_ = x[Table51-(51)]
	_ = x[Table52-(52)]
	_ = x[Table53-(53)]
	_ = x[Table54-(54)]
	_ = x[Table55-(55)]
	_ = x[Table56-(56)]
	_ = x[Table57-(57)]
	_ = x[Table58-(58)]
	_ = x[Table59-(59)]
	_ = x[Table60-(60)]
	_ = x[Table61-(61)]
	_ = x[Table62-(62)]
	_ = x[Table63-(63)]
	_ = x[Table64-(64)]
	_ = x[Table65-(65)]
	_ = x[Table66-(66)]
	_ = x[Table67-(67)]
	_ = x[Table68-(68)]
	_ = x[Table69-(69)]
	_ = x[Table70-(70)]
	_ = x[Table71-(71)]
	_ = x[Table72-(72)]
	_ = x[Table73-(73)]
	_ = x[Table74-(74)]
	_ = x[Table75-(75)]
	_ = x[Table76-(76)]
	_ = x[Table77-(77)]
	_ = x[Table78-(78)]
	_ = x[Table79-(79)]
	_ = x[Table80-(80)]
	_ = x[Table81-(81)]
	_ = x[Table82-(82)]
	_ = x[Table83-(83)]
	_ = x[Table84-(84)]
	_ = x[Table85-(85)]
	_ = x[Table86-(86)]
	_ = x[Table87-(87)]
	_ = x[Table88-(88)]
	_ = x[Table89-(89)]
	_ = x[Table90-(90)]
	_ = x[Table91-(91)]
	_ = x[Table92-(92)]
	_ = x[Table93-(93)]
	_ = x[Table94-(94)]
	_ = x[Table95-(95)]
	_ = x[Table96-(96)]
	_ = x[Table97-(97)]
	_ = x[Table98-(98)]
	_ = x[Table99-(99)]
	_ = x[Table100-(100)]
	_ = x[Table101-(101)]
	_ = x[Table102-(102)]
	_ = x[Table103-(103)]
	_ = x[Table104-(104)]
	_ = x[Table105-(105)]
	_ = x[Table106-(106)]
	_ = x[Table107-(107)]
	_ = x[Table108-(108)]
	_ = x[Table109-(109)]
	_ = x[Table110-(110)]
	_ = x[Table111-(111)]
	_ = x[Table112-(112)]
	_ = x[Table113-(113)]
	_ = x[Table114-(114)]
	_ = x[Table115-(115)]
	_ = x[Table116-(116)]
	_ = x[Table117-(117)]
	_ = x[Table118-(118)]
	_ = x[Table119-(119)]
	_ = x[Table120-(120)]
	_ = x[Table121-(121)]
	_ = x[Table122-(122)]
	_ = x[Table123-(123)]
	_ = x[Table124-(124)]
	_ = x[Table125-(125)]
	_ = x[Table126-(126)]
	_ = x[Table127-(127)]
	_ = x[Table128-(128)]
	_ = x[Table129-(129)]
	_ = x[Table130-(130)]
	_ = x[Table131-(131)]
	_ = x[Table132-(132)]
	_ = x[Table133-(133)]
	_ = x[Table134-(134)]
	_ = x[Table135-(135)]
	_ = x[Table136-(136)]
	_ = x[Table137-(137)]
	_ = x[Table138-(138)]
	_ = x[Table139-(139)]
	_ = x[Table140-(140)]
	_ = x[Table141-(141)]
	_ = x[Table142-(142)]
	_ = x[Table143-(143)]
	_ = x[Table144-(144)]
	_ = x[Table145-(145)]
	_ = x[Table146-(146)]
	_ = x[Table147-(147)]
	_ = x[Table148-(148)]
	_ = x[Table149-(149)]
	_ = x[Table150-(150)]
	_ = x[Table151-(151)]
	_ = x[Table152-(152)]
	_ = x[Table153-(153)]
	_ = x[Table154-(154)]
	_ = x[Table155-(155)]
	_ = x[Table156-(156)]
	_ = x[Table157-(157)]
	_ = x[Table158-(158)]
	_ = x[Table159-(159)]
	_ = x[Table160-(160)]
	_ = x[Table161-(161)]
	_ = x[Table162-(162)]
	_ = x[Table163-(163)]
	_ = x[Table164-(164)]
	_ = x[Table165-(165)]
	_ = x[Table166-(166)]
	_ = x[Table167-(167)]
	_ = x[Table168-(168)]
	_ = x[Table169-(169)]
	_ = x[Table170-(170)]
	_ = x[Table171-(171)]
	_ = x[Table172-(172)]
	_ = x[Table173-(173)]
	_ = x[Table174-(174)]
	_ = x[Table175-(175)]
	_ = x[Table176-(176)]
	_ = x[Table177-(177)]
	_ = x[Table178-(178)]
	_ = x[Table179-(179)]
	_ = x[Table180-(180)]
	_ = x[Table181-(181)]
	_ = x[Table182-(182)]
	_ = x[Table183-(183)]
	_ = x[Table184-(184)]
	_ = x[Table185-(185)]
	_ = x[Table186-(186)]
	_ = x[Table187-(187)]
	_ = x[Table188-(188)]
	_ = x[Table189-(189)]
	_ = x[Table190-(190)]
	_ = x[Table191-(191)]
	_ = x[Table192-(192)]
	_ = x[Table193-(193)]
	_ = x[Table194-(194)]
	_ = x[Table195-(195)]
	_ = x[Table196-(196)]
	_ = x[Table197-(197)]
	_ = x[Table198-(198)]
	_ = x[Table199-(199)]
	_ = x[Table200-(200)]
	_ = x[Table201-(201)]
	_ = x[Table202-(202)]
	_ = x[Table203-(203)]
	_ = x[Table204-(204)]
	_ = x[Table205-(205)]
	_ = x[Table206-(206)]
	_ = x[Table207-(207)]
	_ = x[Table208-(208)]
	_ = x[Table209-(209)]
	_ = x[Table210-(210)]
	_ = x[Table211-(211)]
	_ = x[Table212-(212)]
	_ = x[Table213-(213)]
	_ = x[Table214-(214)]
	_ = x[Table215-(215)]
	_ = x[Table216-(216)]
	_ = x[Table217-(217)]
	_ = x[Table218-(218)]
	_ = x[Table219-(219)]
	_ = x[Table220-(220)]
	_ = x[Table221-(221)]
	_ = x[Table222-(222)]
	_ = x[Table223-(223)]
	_ = x[Table224-(224)]
	_ = x[Table225-(225)]
	_ = x[Table226-(226)]
	_ = x[Table227-(227)]
	_ = x[Table228-(228)]
	_ = x[Table229-(229)]
	_ = x[Table230-(230)]
	_ = x[Table231-(231)]
	_ = x[Table232-(232)]
	_ = x[Table233-(233)]
	_ = x[Table234-(234)]
	_ = x[Table235-(235)]
	_ = x[Table236-(236)]
	_ = x[Table237-(237)]
	_ = x[Table238-(238)]
	_ = x[Table239-(239)]
	_ = x[Table240-(240)]
	_ = x[Table241-(241)]
	_ = x[Table242-(242)]
	_ = x[Table243-(243)]
	_ = x[Table244-(244)]
	_ = x[Table245-(245)]
	_ = x[Table246-(246)]
	_ = x[Table247-(247)]
	_ = x[Table248-(248)]
	_ = x[Table249-(249)]
	_ = x[Table250-(250)]
	_ = x[Table251-(251)]
	_ = x[Table252-(252)]
	_ = x[TableDefault-(253)]
	_ = x[TableMain-(254)]
	_ = x[TableLocal-(255)]
}

var _RoutingTableValues = []RoutingTable{TableUnspec, Table1, Table2, Table3, Table4, Table5, Table6, Table7, Table8, Table9, Table10, Table11, Table12, Table13, Table14, Table15, Table16, Table17, Table18, Table19, Table20, Table21, Table22, Table23, Table24, Table25, Table26, Table27, Table28, Table29, Table30, Table31, Table32, Table33, Table34, Table35, Table36, Table37, Table38, Table39, Table40, Table41, Table42, Table43, Table44, Table45, Table46, Table47, Table48, Table49, Table50, Table51, Table52, Table53, Table54, Table55, Table56, Table57, Table58, Table59, Table60, Table61, Table62, Table63, Table64, Table65, Table66, Table67, Table68, Table69, Table70, Table71, Table72, Table73, Table74, Table75, Table76, Table77, Table78, Table79, Table80, Table81, Table82, Table83, Table84, Table85, Table86, Table87, Table88, Table89, Table90, Table91, Table92, Table93, Table94, Table95, Table96, Table97, Table98, Table99, Table100, Table101, Table102, Table103, Table104, Table105, Table106, Table107, Table108, Table109, Table110, Table111, Table112, Table113, Table114, Table115, Table116, Table117, Table118, Table119, Table120, Table121, Table122, Table123, Table124, Table125, Table126, Table127, Table128, Table129, Table130, Table131, Table132, Table133, Table134, Table135, Table136, Table137, Table138, Table139, Table140, Table141, Table142, Table143, Table144, Table145, Table146, Table147, Table148, Table149, Table150, Table151, Table152, Table153, Table154, Table155, Table156, Table157, Table158, Table159, Table160, Table161, Table162, Table163, Table164, Table165, Table166, Table167, Table168, Table169, Table170, Table171, Table172, Table173, Table174, Table175, Table176, Table177, Table178, Table179, Table180, Table181, Table182, Table183, Table184, Table185, Table186, Table187, Table188, Table189, Table190, Table191, Table192, Table193, Table194, Table195, Table196, Table197, Table198, Table199, Table200, Table201, Table202, Table203, Table204, Table205, Table206, Table207, Table208, Table209, Table210, Table211, Table212, Table213, Table214, Table215, Table216, Table217, Table218, Table219, Table220, Table221, Table222, Table223, Table224, Table225, Table226, Table227, Table228, Table229, Table230, Table231, Table232, Table233, Table234, Table235, Table236, Table237, Table238, Table239, Table240, Table241, Table242, Table243, Table244, Table245, Table246, Table247, Table248, Table249, Table250, Table251, Table252, TableDefault, TableMain, TableLocal}

var _RoutingTableNameToValueMap = map[string]RoutingTable{
	_RoutingTableName[0:6]:          TableUnspec,
	_RoutingTableLowerName[0:6]:     TableUnspec,
	_RoutingTableName[6:7]:          Table1,
	_RoutingTableLowerName[6:7]:     Table1,
	_RoutingTableName[7:8]:          Table2,
	_RoutingTableLowerName[7:8]:     Table2,
	_RoutingTableName[8:9]:          Table3,
	_RoutingTableLowerName[8:9]:     Table3,
	_RoutingTableName[9:10]:         Table4,
	_RoutingTableLowerName[9:10]:    Table4,
	_RoutingTableName[10:11]:        Table5,
	_RoutingTableLowerName[10:11]:   Table5,
	_RoutingTableName[11:12]:        Table6,
	_RoutingTableLowerName[11:12]:   Table6,
	_RoutingTableName[12:13]:        Table7,
	_RoutingTableLowerName[12:13]:   Table7,
	_RoutingTableName[13:14]:        Table8,
	_RoutingTableLowerName[13:14]:   Table8,
	_RoutingTableName[14:15]:        Table9,
	_RoutingTableLowerName[14:15]:   Table9,
	_RoutingTableName[15:17]:        Table10,
	_RoutingTableLowerName[15:17]:   Table10,
	_RoutingTableName[17:19]:        Table11,
	_RoutingTableLowerName[17:19]:   Table11,
	_RoutingTableName[19:21]:        Table12,
	_RoutingTableLowerName[19:21]:   Table12,
	_RoutingTableName[21:23]:        Table13,
	_RoutingTableLowerName[21:23]:   Table13,
	_RoutingTableName[23:25]:        Table14,
	_RoutingTableLowerName[23:25]:   Table14,
	_RoutingTableName[25:27]:        Table15,
	_RoutingTableLowerName[25:27]:   Table15,
	_RoutingTableName[27:29]:        Table16,
	_RoutingTableLowerName[27:29]:   Table16,
	_RoutingTableName[29:31]:        Table17,
	_RoutingTableLowerName[29:31]:   Table17,
	_RoutingTableName[31:33]:        Table18,
	_RoutingTableLowerName[31:33]:   Table18,
	_RoutingTableName[33:35]:        Table19,
	_RoutingTableLowerName[33:35]:   Table19,
	_RoutingTableName[35:37]:        Table20,
	_RoutingTableLowerName[35:37]:   Table20,
	_RoutingTableName[37:39]:        Table21,
	_RoutingTableLowerName[37:39]:   Table21,
	_RoutingTableName[39:41]:        Table22,
	_RoutingTableLowerName[39:41]:   Table22,
	_RoutingTableName[41:43]:        Table23,
	_RoutingTableLowerName[41:43]:   Table23,
	_RoutingTableName[43:45]:        Table24,
	_RoutingTableLowerName[43:45]:   Table24,
	_RoutingTableName[45:47]:        Table25,
	_RoutingTableLowerName[45:47]:   Table25,
	_RoutingTableName[47:49]:        Table26,
	_RoutingTableLowerName[47:49]:   Table26,
	_RoutingTableName[49:51]:        Table27,
	_RoutingTableLowerName[49:51]:   Table27,
	_RoutingTableName[51:53]:        Table28,
	_RoutingTableLowerName[51:53]:   Table28,
	_RoutingTableName[53:55]:        Table29,
	_RoutingTableLowerName[53:55]:   Table29,
	_RoutingTableName[55:57]:        Table30,
	_RoutingTableLowerName[55:57]:   Table30,
	_RoutingTableName[57:59]:        Table31,
	_RoutingTableLowerName[57:59]:   Table31,
	_RoutingTableName[59:61]:        Table32,
	_RoutingTableLowerName[59:61]:   Table32,
	_RoutingTableName[61:63]:        Table33,
	_RoutingTableLowerName[61:63]:   Table33,
	_RoutingTableName[63:65]:        Table34,
	_RoutingTableLowerName[63:65]:   Table34,
	_RoutingTableName[65:67]:        Table35,
	_RoutingTableLowerName[65:67]:   Table35,
	_RoutingTableName[67:69]:        Table36,
	_RoutingTableLowerName[67:69]:   Table36,
	_RoutingTableName[69:71]:        Table37,
	_RoutingTableLowerName[69:71]:   Table37,
	_RoutingTableName[71:73]:        Table38,
	_RoutingTableLowerName[71:73]:   Table38,
	_RoutingTableName[73:75]:        Table39,
	_RoutingTableLowerName[73:75]:   Table39,
	_RoutingTableName[75:77]:        Table40,
	_RoutingTableLowerName[75:77]:   Table40,
	_RoutingTableName[77:79]:        Table41,
	_RoutingTableLowerName[77:79]:   Table41,
	_RoutingTableName[79:81]:        Table42,
	_RoutingTableLowerName[79:81]:   Table42,
	_RoutingTableName[81:83]:        Table43,
	_RoutingTableLowerName[81:83]:   Table43,
	_RoutingTableName[83:85]:        Table44,
	_RoutingTableLowerName[83:85]:   Table44,
	_RoutingTableName[85:87]:        Table45,
	_RoutingTableLowerName[85:87]:   Table45,
	_RoutingTableName[87:89]:        Table46,
	_RoutingTableLowerName[87:89]:   Table46,
	_RoutingTableName[89:91]:        Table47,
	_RoutingTableLowerName[89:91]:   Table47,
	_RoutingTableName[91:93]:        Table48,
	_RoutingTableLowerName[91:93]:   Table48,
	_RoutingTableName[93:95]:        Table49,
	_RoutingTableLowerName[93:95]:   Table49,
	_RoutingTableName[95:97]:        Table50,
	_RoutingTableLowerName[95:97]:   Table50,
	_RoutingTableName[97:99]:        Table51,
	_RoutingTableLowerName[97:99]:   Table51,
	_RoutingTableName[99:101]:       Table52,
	_RoutingTableLowerName[99:101]:  Table52,
	_RoutingTableName[101:103]:      Table53,
	_RoutingTableLowerName[101:103]: Table53,
	_RoutingTableName[103:105]:      Table54,
	_RoutingTableLowerName[103:105]: Table54,
	_RoutingTableName[105:107]:      Table55,
	_RoutingTableLowerName[105:107]: Table55,
	_RoutingTableName[107:109]:      Table56,
	_RoutingTableLowerName[107:109]: Table56,
	_RoutingTableName[109:111]:      Table57,
	_RoutingTableLowerName[109:111]: Table57,
	_RoutingTableName[111:113]:      Table58,
	_RoutingTableLowerName[111:113]: Table58,
	_RoutingTableName[113:115]:      Table59,
	_RoutingTableLowerName[113:115]: Table59,
	_RoutingTableName[115:117]:      Table60,
	_RoutingTableLowerName[115:117]: Table60,
	_RoutingTableName[117:119]:      Table61,
	_RoutingTableLowerName[117:119]: Table61,
	_RoutingTableName[119:121]:      Table62,
	_RoutingTableLowerName[119:121]: Table62,
	_RoutingTableName[121:123]:      Table63,
	_RoutingTableLowerName[121:123]: Table63,
	_RoutingTableName[123:125]:      Table64,
	_RoutingTableLowerName[123:125]: Table64,
	_RoutingTableName[125:127]:      Table65,
	_RoutingTableLowerName[125:127]: Table65,
	_RoutingTableName[127:129]:      Table66,
	_RoutingTableLowerName[127:129]: Table66,
	_RoutingTableName[129:131]:      Table67,
	_RoutingTableLowerName[129:131]: Table67,
	_RoutingTableName[131:133]:      Table68,
	_RoutingTableLowerName[131:133]: Table68,
	_RoutingTableName[133:135]:      Table69,
	_RoutingTableLowerName[133:135]: Table69,
	_RoutingTableName[135:137]:      Table70,
	_RoutingTableLowerName[135:137]: Table70,
	_RoutingTableName[137:139]:      Table71,
	_RoutingTableLowerName[137:139]: Table71,
	_RoutingTableName[139:141]:      Table72,
	_RoutingTableLowerName[139:141]: Table72,
	_RoutingTableName[141:143]:      Table73,
	_RoutingTableLowerName[141:143]: Table73,
	_RoutingTableName[143:145]:      Table74,
	_RoutingTableLowerName[143:145]: Table74,
	_RoutingTableName[145:147]:      Table75,
	_RoutingTableLowerName[145:147]: Table75,
	_RoutingTableName[147:149]:      Table76,
	_RoutingTableLowerName[147:149]: Table76,
	_RoutingTableName[149:151]:      Table77,
	_RoutingTableLowerName[149:151]: Table77,
	_RoutingTableName[151:153]:      Table78,
	_RoutingTableLowerName[151:153]: Table78,
	_RoutingTableName[153:155]:      Table79,
	_RoutingTableLowerName[153:155]: Table79,
	_RoutingTableName[155:157]:      Table80,
	_RoutingTableLowerName[155:157]: Table80,
	_RoutingTableName[157:159]:      Table81,
	_RoutingTableLowerName[157:159]: Table81,
	_RoutingTableName[159:161]:      Table82,
	_RoutingTableLowerName[159:161]: Table82,
	_RoutingTableName[161:163]:      Table83,
	_RoutingTableLowerName[161:163]: Table83,
	_RoutingTableName[163:165]:      Table84,
	_RoutingTableLowerName[163:165]: Table84,
	_RoutingTableName[165:167]:      Table85,
	_RoutingTableLowerName[165:167]: Table85,
	_RoutingTableName[167:169]:      Table86,
	_RoutingTableLowerName[167:169]: Table86,
	_RoutingTableName[169:171]:      Table87,
	_RoutingTableLowerName[169:171]: Table87,
	_RoutingTableName[171:173]:      Table88,
	_RoutingTableLowerName[171:173]: Table88,
	_RoutingTableName[173:175]:      Table89,
	_RoutingTableLowerName[173:175]: Table89,
	_RoutingTableName[175:177]:      Table90,
	_RoutingTableLowerName[175:177]: Table90,
	_RoutingTableName[177:179]:      Table91,
	_RoutingTableLowerName[177:179]: Table91,
	_RoutingTableName[179:181]:      Table92,
	_RoutingTableLowerName[179:181]: Table92,
	_RoutingTableName[181:183]:      Table93,
	_RoutingTableLowerName[181:183]: Table93,
	_RoutingTableName[183:185]:      Table94,
	_RoutingTableLowerName[183:185]: Table94,
	_RoutingTableName[185:187]:      Table95,
	_RoutingTableLowerName[185:187]: Table95,
	_RoutingTableName[187:189]:      Table96,
	_RoutingTableLowerName[187:189]: Table96,
	_RoutingTableName[189:191]:      Table97,
	_RoutingTableLowerName[189:191]: Table97,
	_RoutingTableName[191:193]:      Table98,
	_RoutingTableLowerName[191:193]: Table98,
	_RoutingTableName[193:195]:      Table99,
	_RoutingTableLowerName[193:195]: Table99,
	_RoutingTableName[195:198]:      Table100,
	_RoutingTableLowerName[195:198]: Table100,
	_RoutingTableName[198:201]:      Table101,
	_RoutingTableLowerName[198:201]: Table101,
	_RoutingTableName[201:204]:      Table102,
	_RoutingTableLowerName[201:204]: Table102,
	_RoutingTableName[204:207]:      Table103,
	_RoutingTableLowerName[204:207]: Table103,
	_RoutingTableName[207:210]:      Table104,
	_RoutingTableLowerName[207:210]: Table104,
	_RoutingTableName[210:213]:      Table105,
	_RoutingTableLowerName[210:213]: Table105,
	_RoutingTableName[213:216]:      Table106,
	_RoutingTableLowerName[213:216]: Table106,
	_RoutingTableName[216:219]:      Table107,
	_RoutingTableLowerName[216:219]: Table107,
	_RoutingTableName[219:222]:      Table108,
	_RoutingTableLowerName[219:222]: Table108,
	_RoutingTableName[222:225]:      Table109,
	_RoutingTableLowerName[222:225]: Table109,
	_RoutingTableName[225:228]:      Table110,
	_RoutingTableLowerName[225:228]: Table110,
	_RoutingTableName[228:231]:      Table111,
	_RoutingTableLowerName[228:231]: Table111,
	_RoutingTableName[231:234]:      Table112,
	_RoutingTableLowerName[231:234]: Table112,
	_RoutingTableName[234:237]:      Table113,
	_RoutingTableLowerName[234:237]: Table113,
	_RoutingTableName[237:240]:      Table114,
	_RoutingTableLowerName[237:240]: Table114,
	_RoutingTableName[240:243]:      Table115,
	_RoutingTableLowerName[240:243]: Table115,
	_RoutingTableName[243:246]:      Table116,
	_RoutingTableLowerName[243:246]: Table116,
	_RoutingTableName[246:249]:      Table117,
	_RoutingTableLowerName[246:249]: Table117,
	_RoutingTableName[249:252]:      Table118,
	_RoutingTableLowerName[249:252]: Table118,
	_RoutingTableName[252:255]:      Table119,
	_RoutingTableLowerName[252:255]: Table119,
	_RoutingTableName[255:258]:      Table120,
	_RoutingTableLowerName[255:258]: Table120,
	_RoutingTableName[258:261]:      Table121,
	_RoutingTableLowerName[258:261]: Table121,
	_RoutingTableName[261:264]:      Table122,
	_RoutingTableLowerName[261:264]: Table122,
	_RoutingTableName[264:267]:      Table123,
	_RoutingTableLowerName[264:267]: Table123,
	_RoutingTableName[267:270]:      Table124,
	_RoutingTableLowerName[267:270]: Table124,
	_RoutingTableName[270:273]:      Table125,
	_RoutingTableLowerName[270:273]: Table125,
	_RoutingTableName[273:276]:      Table126,
	_RoutingTableLowerName[273:276]: Table126,
	_RoutingTableName[276:279]:      Table127,
	_RoutingTableLowerName[276:279]: Table127,
	_RoutingTableName[279:282]:      Table128,
	_RoutingTableLowerName[279:282]: Table128,
	_RoutingTableName[282:285]:      Table129,
	_RoutingTableLowerName[282:285]: Table129,
	_RoutingTableName[285:288]:      Table130,
	_RoutingTableLowerName[285:288]: Table130,
	_RoutingTableName[288:291]:      Table131,
	_RoutingTableLowerName[288:291]: Table131,
	_RoutingTableName[291:294]:      Table132,
	_RoutingTableLowerName[291:294]: Table132,
	_RoutingTableName[294:297]:      Table133,
	_RoutingTableLowerName[294:297]: Table133,
	_RoutingTableName[297:300]:      Table134,
	_RoutingTableLowerName[297:300]: Table134,
	_RoutingTableName[300:303]:      Table135,
	_RoutingTableLowerName[300:303]: Table135,
	_RoutingTableName[303:306]:      Table136,
	_RoutingTableLowerName[303:306]: Table136,
	_RoutingTableName[306:309]:      Table137,
	_RoutingTableLowerName[306:309]: Table137,
	_RoutingTableName[309:312]:      Table138,
	_RoutingTableLowerName[309:312]: Table138,
	_RoutingTableName[312:315]:      Table139,
	_RoutingTableLowerName[312:315]: Table139,
	_RoutingTableName[315:318]:      Table140,
	_RoutingTableLowerName[315:318]: Table140,
	_RoutingTableName[318:321]:      Table141,
	_RoutingTableLowerName[318:321]: Table141,
	_RoutingTableName[321:324]:      Table142,
	_RoutingTableLowerName[321:324]: Table142,
	_RoutingTableName[324:327]:      Table143,
	_RoutingTableLowerName[324:327]: Table143,
	_RoutingTableName[327:330]:      Table144,
	_RoutingTableLowerName[327:330]: Table144,
	_RoutingTableName[330:333]:      Table145,
	_RoutingTableLowerName[330:333]: Table145,
	_RoutingTableName[333:336]:      Table146,
	_RoutingTableLowerName[333:336]: Table146,
	_RoutingTableName[336:339]:      Table147,
	_RoutingTableLowerName[336:339]: Table147,
	_RoutingTableName[339:342]:      Table148,
	_RoutingTableLowerName[339:342]: Table148,
	_RoutingTableName[342:345]:      Table149,
	_RoutingTableLowerName[342:345]: Table149,
	_RoutingTableName[345:348]:      Table150,
	_RoutingTableLowerName[345:348]: Table150,
	_RoutingTableName[348:351]:      Table151,
	_RoutingTableLowerName[348:351]: Table151,
	_RoutingTableName[351:354]:      Table152,
	_RoutingTableLowerName[351:354]: Table152,
	_RoutingTableName[354:357]:      Table153,
	_RoutingTableLowerName[354:357]: Table153,
	_RoutingTableName[357:360]:      Table154,
	_RoutingTableLowerName[357:360]: Table154,
	_RoutingTableName[360:363]:      Table155,
	_RoutingTableLowerName[360:363]: Table155,
	_RoutingTableName[363:366]:      Table156,
	_RoutingTableLowerName[363:366]: Table156,
	_RoutingTableName[366:369]:      Table157,
	_RoutingTableLowerName[366:369]: Table157,
	_RoutingTableName[369:372]:      Table158,
	_RoutingTableLowerName[369:372]: Table158,
	_RoutingTableName[372:375]:      Table159,
	_RoutingTableLowerName[372:375]: Table159,
	_RoutingTableName[375:378]:      Table160,
	_RoutingTableLowerName[375:378]: Table160,
	_RoutingTableName[378:381]:      Table161,
	_RoutingTableLowerName[378:381]: Table161,
	_RoutingTableName[381:384]:      Table162,
	_RoutingTableLowerName[381:384]: Table162,
	_RoutingTableName[384:387]:      Table163,
	_RoutingTableLowerName[384:387]: Table163,
	_RoutingTableName[387:390]:      Table164,
	_RoutingTableLowerName[387:390]: Table164,
	_RoutingTableName[390:393]:      Table165,
	_RoutingTableLowerName[390:393]: Table165,
	_RoutingTableName[393:396]:      Table166,
	_RoutingTableLowerName[393:396]: Table166,
	_RoutingTableName[396:399]:      Table167,
	_RoutingTableLowerName[396:399]: Table167,
	_RoutingTableName[399:402]:      Table168,
	_RoutingTableLowerName[399:402]: Table168,
	_RoutingTableName[402:405]:      Table169,
	_RoutingTableLowerName[402:405]: Table169,
	_RoutingTableName[405:408]:      Table170,
	_RoutingTableLowerName[405:408]: Table170,
	_RoutingTableName[408:411]:      Table171,
	_RoutingTableLowerName[408:411]: Table171,
	_RoutingTableName[411:414]:      Table172,
	_RoutingTableLowerName[411:414]: Table172,
	_RoutingTableName[414:417]:      Table173,
	_RoutingTableLowerName[414:417]: Table173,
	_RoutingTableName[417:420]:      Table174,
	_RoutingTableLowerName[417:420]: Table174,
	_RoutingTableName[420:423]:      Table175,
	_RoutingTableLowerName[420:423]: Table175,
	_RoutingTableName[423:426]:      Table176,
	_RoutingTableLowerName[423:426]: Table176,
	_RoutingTableName[426:429]:      Table177,
	_RoutingTableLowerName[426:429]: Table177,
	_RoutingTableName[429:432]:      Table178,
	_RoutingTableLowerName[429:432]: Table178,
	_RoutingTableName[432:435]:      Table179,
	_RoutingTableLowerName[432:435]: Table179,
	_RoutingTableName[435:438]:      Table180,
	_RoutingTableLowerName[435:438]: Table180,
	_RoutingTableName[438:441]:      Table181,
	_RoutingTableLowerName[438:441]: Table181,
	_RoutingTableName[441:444]:      Table182,
	_RoutingTableLowerName[441:444]: Table182,
	_RoutingTableName[444:447]:      Table183,
	_RoutingTableLowerName[444:447]: Table183,
	_RoutingTableName[447:450]:      Table184,
	_RoutingTableLowerName[447:450]: Table184,
	_RoutingTableName[450:453]:      Table185,
	_RoutingTableLowerName[450:453]: Table185,
	_RoutingTableName[453:456]:      Table186,
	_RoutingTableLowerName[453:456]: Table186,
	_RoutingTableName[456:459]:      Table187,
	_RoutingTableLowerName[456:459]: Table187,
	_RoutingTableName[459:462]:      Table188,
	_RoutingTableLowerName[459:462]: Table188,
	_RoutingTableName[462:465]:      Table189,
	_RoutingTableLowerName[462:465]: Table189,
	_RoutingTableName[465:468]:      Table190,
	_RoutingTableLowerName[465:468]: Table190,
	_RoutingTableName[468:471]:      Table191,
	_RoutingTableLowerName[468:471]: Table191,
	_RoutingTableName[471:474]:      Table192,
	_RoutingTableLowerName[471:474]: Table192,
	_RoutingTableName[474:477]:      Table193,
	_RoutingTableLowerName[474:477]: Table193,
	_RoutingTableName[477:480]:      Table194,
	_RoutingTableLowerName[477:480]: Table194,
	_RoutingTableName[480:483]:      Table195,
	_RoutingTableLowerName[480:483]: Table195,
	_RoutingTableName[483:486]:      Table196,
	_RoutingTableLowerName[483:486]: Table196,
	_RoutingTableName[486:489]:      Table197,
	_RoutingTableLowerName[486:489]: Table197,
	_RoutingTableName[489:492]:      Table198,
	_RoutingTableLowerName[489:492]: Table198,
	_RoutingTableName[492:495]:      Table199,
	_RoutingTableLowerName[492:495]: Table199,
	_RoutingTableName[495:498]:      Table200,
	_RoutingTableLowerName[495:498]: Table200,
	_RoutingTableName[498:501]:      Table201,
	_RoutingTableLowerName[498:501]: Table201,
	_RoutingTableName[501:504]:      Table202,
	_RoutingTableLowerName[501:504]: Table202,
	_RoutingTableName[504:507]:      Table203,
	_RoutingTableLowerName[504:507]: Table203,
	_RoutingTableName[507:510]:      Table204,
	_RoutingTableLowerName[507:510]: Table204,
	_RoutingTableName[510:513]:      Table205,
	_RoutingTableLowerName[510:513]: Table205,
	_RoutingTableName[513:516]:      Table206,
	_RoutingTableLowerName[513:516]: Table206,
	_RoutingTableName[516:519]:      Table207,
	_RoutingTableLowerName[516:519]: Table207,
	_RoutingTableName[519:522]:      Table208,
	_RoutingTableLowerName[519:522]: Table208,
	_RoutingTableName[522:525]:      Table209,
	_RoutingTableLowerName[522:525]: Table209,
	_RoutingTableName[525:528]:      Table210,
	_RoutingTableLowerName[525:528]: Table210,
	_RoutingTableName[528:531]:      Table211,
	_RoutingTableLowerName[528:531]: Table211,
	_RoutingTableName[531:534]:      Table212,
	_RoutingTableLowerName[531:534]: Table212,
	_RoutingTableName[534:537]:      Table213,
	_RoutingTableLowerName[534:537]: Table213,
	_RoutingTableName[537:540]:      Table214,
	_RoutingTableLowerName[537:540]: Table214,
	_RoutingTableName[540:543]:      Table215,
	_RoutingTableLowerName[540:543]: Table215,
	_RoutingTableName[543:546]:      Table216,
	_RoutingTableLowerName[543:546]: Table216,
	_RoutingTableName[546:549]:      Table217,
	_RoutingTableLowerName[546:549]: Table217,
	_RoutingTableName[549:552]:      Table218,
	_RoutingTableLowerName[549:552]: Table218,
	_RoutingTableName[552:555]:      Table219,
	_RoutingTableLowerName[552:555]: Table219,
	_RoutingTableName[555:558]:      Table220,
	_RoutingTableLowerName[555:558]: Table220,
	_RoutingTableName[558:561]:      Table221,
	_RoutingTableLowerName[558:561]: Table221,
	_RoutingTableName[561:564]:      Table222,
	_RoutingTableLowerName[561:564]: Table222,
	_RoutingTableName[564:567]:      Table223,
	_RoutingTableLowerName[564:567]: Table223,
	_RoutingTableName[567:570]:      Table224,
	_RoutingTableLowerName[567:570]: Table224,
	_RoutingTableName[570:573]:      Table225,
	_RoutingTableLowerName[570:573]: Table225,
	_RoutingTableName[573:576]:      Table226,
	_RoutingTableLowerName[573:576]: Table226,
	_RoutingTableName[576:579]:      Table227,
	_RoutingTableLowerName[576:579]: Table227,
	_RoutingTableName[579:582]:      Table228,
	_RoutingTableLowerName[579:582]: Table228,
	_RoutingTableName[582:585]:      Table229,
	_RoutingTableLowerName[582:585]: Table229,
	_RoutingTableName[585:588]:      Table230,
	_RoutingTableLowerName[585:588]: Table230,
	_RoutingTableName[588:591]:      Table231,
	_RoutingTableLowerName[588:591]: Table231,
	_RoutingTableName[591:594]:      Table232,
	_RoutingTableLowerName[591:594]: Table232,
	_RoutingTableName[594:597]:      Table233,
	_RoutingTableLowerName[594:597]: Table233,
	_RoutingTableName[597:600]:      Table234,
	_RoutingTableLowerName[597:600]: Table234,
	_RoutingTableName[600:603]:      Table235,
	_RoutingTableLowerName[600:603]: Table235,
	_RoutingTableName[603:606]:      Table236,
	_RoutingTableLowerName[603:606]: Table236,
	_RoutingTableName[606:609]:      Table237,
	_RoutingTableLowerName[606:609]: Table237,
	_RoutingTableName[609:612]:      Table238,
	_RoutingTableLowerName[609:612]: Table238,
	_RoutingTableName[612:615]:      Table239,
	_RoutingTableLowerName[612:615]: Table239,
	_RoutingTableName[615:618]:      Table240,
	_RoutingTableLowerName[615:618]: Table240,
	_RoutingTableName[618:621]:      Table241,
	_RoutingTableLowerName[618:621]: Table241,
	_RoutingTableName[621:624]:      Table242,
	_RoutingTableLowerName[621:624]: Table242,
	_RoutingTableName[624:627]:      Table243,
	_RoutingTableLowerName[624:627]: Table243,
	_RoutingTableName[627:630]:      Table244,
	_RoutingTableLowerName[627:630]: Table244,
	_RoutingTableName[630:633]:      Table245,
	_RoutingTableLowerName[630:633]: Table245,
	_RoutingTableName[633:636]:      Table246,
	_RoutingTableLowerName[633:636]: Table246,
	_RoutingTableName[636:639]:      Table247,
	_RoutingTableLowerName[636:639]: Table247,
	_RoutingTableName[639:642]:      Table248,
	_RoutingTableLowerName[639:642]: Table248,
	_RoutingTableName[642:645]:      Table249,
	_RoutingTableLowerName[642:645]: Table249,
	_RoutingTableName[645:648]:      Table250,
	_RoutingTableLowerName[645:648]: Table250,
	_RoutingTableName[648:651]:      Table251,
	_RoutingTableLowerName[648:651]: Table251,
	_RoutingTableName[651:654]:      Table252,
	_RoutingTableLowerName[651:654]: Table252,
	_RoutingTableName[654:661]:      TableDefault,
	_RoutingTableLowerName[654:661]: TableDefault,
	_RoutingTableName[661:665]:      TableMain,
	_RoutingTableLowerName[661:665]: TableMain,
	_RoutingTableName[665:670]:      TableLocal,
	_RoutingTableLowerName[665:670]: TableLocal,
}

var _RoutingTableNames = []string{
	_RoutingTableName[0:6],
	_RoutingTableName[6:7],
	_RoutingTableName[7:8],
	_RoutingTableName[8:9],
	_RoutingTableName[9:10],
	_RoutingTableName[10:11],
	_RoutingTableName[11:12],
	_RoutingTableName[12:13],
	_RoutingTableName[13:14],
	_RoutingTableName[14:15],
	_RoutingTableName[15:17],
	_RoutingTableName[17:19],
	_RoutingTableName[19:21],
	_RoutingTableName[21:23],
	_RoutingTableName[23:25],
	_RoutingTableName[25:27],
	_RoutingTableName[27:29],
	_RoutingTableName[29:31],
	_RoutingTableName[31:33],
	_RoutingTableName[33:35],
	_RoutingTableName[35:37],
	_RoutingTableName[37:39],
	_RoutingTableName[39:41],
	_RoutingTableName[41:43],
	_RoutingTableName[43:45],
	_RoutingTableName[45:47],
	_RoutingTableName[47:49],
	_RoutingTableName[49:51],
	_RoutingTableName[51:53],
	_RoutingTableName[53:55],
	_RoutingTableName[55:57],
	_RoutingTableName[57:59],
	_RoutingTableName[59:61],
	_RoutingTableName[61:63],
	_RoutingTableName[63:65],
	_RoutingTableName[65:67],
	_RoutingTableName[67:69],
	_RoutingTableName[69:71],
	_RoutingTableName[71:73],
	_RoutingTableName[73:75],
	_RoutingTableName[75:77],
	_RoutingTableName[77:79],
	_RoutingTableName[79:81],
	_RoutingTableName[81:83],
	_RoutingTableName[83:85],
	_RoutingTableName[85:87],
	_RoutingTableName[87:89],
	_RoutingTableName[89:91],
	_RoutingTableName[91:93],
	_RoutingTableName[93:95],
	_RoutingTableName[95:97],
	_RoutingTableName[97:99],
	_RoutingTableName[99:101],
	_RoutingTableName[101:103],
	_RoutingTableName[103:105],
	_RoutingTableName[105:107],
	_RoutingTableName[107:109],
	_RoutingTableName[109:111],
	_RoutingTableName[111:113],
	_RoutingTableName[113:115],
	_RoutingTableName[115:117],
	_RoutingTableName[117:119],
	_RoutingTableName[119:121],
	_RoutingTableName[121:123],
	_RoutingTableName[123:125],
	_RoutingTableName[125:127],
	_RoutingTableName[127:129],
	_RoutingTableName[129:131],
	_RoutingTableName[131:133],
	_RoutingTableName[133:135],
	_RoutingTableName[135:137],
	_RoutingTableName[137:139],
	_RoutingTableName[139:141],
	_RoutingTableName[141:143],
	_RoutingTableName[143:145],
	_RoutingTableName[145:147],
	_RoutingTableName[147:149],
	_RoutingTableName[149:151],
	_RoutingTableName[151:153],
	_RoutingTableName[153:155],
	_RoutingTableName[155:157],
	_RoutingTableName[157:159],
	_RoutingTableName[159:161],
	_RoutingTableName[161:163],
	_RoutingTableName[163:165],
	_RoutingTableName[165:167],
	_RoutingTableName[167:169],
	_RoutingTableName[169:171],
	_RoutingTableName[171:173],
	_RoutingTableName[173:175],
	_RoutingTableName[175:177],
	_RoutingTableName[177:179],
	_RoutingTableName[179:181],
	_RoutingTableName[181:183],
	_RoutingTableName[183:185],
	_RoutingTableName[185:187],
	_RoutingTableName[187:189],
	_RoutingTableName[189:191],
	_RoutingTableName[191:193],
	_RoutingTableName[193:195],
	_RoutingTableName[195:198],
	_RoutingTableName[198:201],
	_RoutingTableName[201:204],
	_RoutingTableName[204:207],
	_RoutingTableName[207:210],
	_RoutingTableName[210:213],
	_RoutingTableName[213:216],
	_RoutingTableName[216:219],
	_RoutingTableName[219:222],
	_RoutingTableName[222:225],
	_RoutingTableName[225:228],
	_RoutingTableName[228:231],
	_RoutingTableName[231:234],
	_RoutingTableName[234:237],
	_RoutingTableName[237:240],
	_RoutingTableName[240:243],
	_RoutingTableName[243:246],
	_RoutingTableName[246:249],
	_RoutingTableName[249:252],
	_RoutingTableName[252:255],
	_RoutingTableName[255:258],
	_RoutingTableName[258:261],
	_RoutingTableName[261:264],
	_RoutingTableName[264:267],
	_RoutingTableName[267:270],
	_RoutingTableName[270:273],
	_RoutingTableName[273:276],
	_RoutingTableName[276:279],
	_RoutingTableName[279:282],
	_RoutingTableName[282:285],
	_RoutingTableName[285:288],
	_RoutingTableName[288:291],
	_RoutingTableName[291:294],
	_RoutingTableName[294:297],
	_RoutingTableName[297:300],
	_RoutingTableName[300:303],
	_RoutingTableName[303:306],
	_RoutingTableName[306:309],
	_RoutingTableName[309:312],
	_RoutingTableName[312:315],
	_RoutingTableName[315:318],
	_RoutingTableName[318:321],
	_RoutingTableName[321:324],
	_RoutingTableName[324:327],
	_RoutingTableName[327:330],
	_RoutingTableName[330:333],
	_RoutingTableName[333:336],
	_RoutingTableName[336:339],
	_RoutingTableName[339:342],
	_RoutingTableName[342:345],
	_RoutingTableName[345:348],
	_RoutingTableName[348:351],
	_RoutingTableName[351:354],
	_RoutingTableName[354:357],
	_RoutingTableName[357:360],
	_RoutingTableName[360:363],
	_RoutingTableName[363:366],
	_RoutingTableName[366:369],
	_RoutingTableName[369:372],
	_RoutingTableName[372:375],
	_RoutingTableName[375:378],
	_RoutingTableName[378:381],
	_RoutingTableName[381:384],
	_RoutingTableName[384:387],
	_RoutingTableName[387:390],
	_RoutingTableName[390:393],
	_RoutingTableName[393:396],
	_RoutingTableName[396:399],
	_RoutingTableName[399:402],
	_RoutingTableName[402:405],
	_RoutingTableName[405:408],
	_RoutingTableName[408:411],
	_RoutingTableName[411:414],
	_RoutingTableName[414:417],
	_RoutingTableName[417:420],
	_RoutingTableName[420:423],
	_RoutingTableName[423:426],
	_RoutingTableName[426:429],
	_RoutingTableName[429:432],
	_RoutingTableName[432:435],
	_RoutingTableName[435:438],
	_RoutingTableName[438:441],
	_RoutingTableName[441:444],
	_RoutingTableName[444:447],
	_RoutingTableName[447:450],
	_RoutingTableName[450:453],
	_RoutingTableName[453:456],
	_RoutingTableName[456:459],
	_RoutingTableName[459:462],
	_RoutingTableName[462:465],
	_RoutingTableName[465:468],
	_RoutingTableName[468:471],
	_RoutingTableName[471:474],
	_RoutingTableName[474:477],
	_RoutingTableName[477:480],
	_RoutingTableName[480:483],
	_RoutingTableName[483:486],
	_RoutingTableName[486:489],
	_RoutingTableName[489:492],
	_RoutingTableName[492:495],
	_RoutingTableName[495:498],
	_RoutingTableName[498:501],
	_RoutingTableName[501:504],
	_RoutingTableName[504:507],
	_RoutingTableName[507:510],
	_RoutingTableName[510:513],
	_RoutingTableName[513:516],
	_RoutingTableName[516:519],
	_RoutingTableName[519:522],
	_RoutingTableName[522:525],
	_RoutingTableName[525:528],
	_RoutingTableName[528:531],
	_RoutingTableName[531:534],
	_RoutingTableName[534:537],
	_RoutingTableName[537:540],
	_RoutingTableName[540:543],
	_RoutingTableName[543:546],
	_RoutingTableName[546:549],
	_RoutingTableName[549:552],
	_RoutingTableName[552:555],
	_RoutingTableName[555:558],
	_RoutingTableName[558:561],
	_RoutingTableName[561:564],
	_RoutingTableName[564:567],
	_RoutingTableName[567:570],
	_RoutingTableName[570:573],
	_RoutingTableName[573:576],
	_RoutingTableName[576:579],
	_RoutingTableName[579:582],
	_RoutingTableName[582:585],
	_RoutingTableName[585:588],
	_RoutingTableName[588:591],
	_RoutingTableName[591:594],
	_RoutingTableName[594:597],
	_RoutingTableName[597:600],
	_RoutingTableName[600:603],
	_RoutingTableName[603:606],
	_RoutingTableName[606:609],
	_RoutingTableName[609:612],
	_RoutingTableName[612:615],
	_RoutingTableName[615:618],
	_RoutingTableName[618:621],
	_RoutingTableName[621:624],
	_RoutingTableName[624:627],
	_RoutingTableName[627:630],
	_RoutingTableName[630:633],
	_RoutingTableName[633:636],
	_RoutingTableName[636:639],
	_RoutingTableName[639:642],
	_RoutingTableName[642:645],
	_RoutingTableName[645:648],
	_RoutingTableName[648:651],
	_RoutingTableName[651:654],
	_RoutingTableName[654:661],
	_RoutingTableName[661:665],
	_RoutingTableName[665:670],
}

// RoutingTableString retrieves an enum value from the enum constants string name.
// Throws an error if the param is not part of the enum.
func RoutingTableString(s string) (RoutingTable, error) {
	if val, ok := _RoutingTableNameToValueMap[s]; ok {
		return val, nil
	}

	if val, ok := _RoutingTableNameToValueMap[strings.ToLower(s)]; ok {
		return val, nil
	}
	return 0, fmt.Errorf("%s does not belong to RoutingTable values", s)
}

// RoutingTableValues returns all values of the enum
func RoutingTableValues() []RoutingTable {
	return _RoutingTableValues
}

// RoutingTableStrings returns a slice of all String values of the enum
func RoutingTableStrings() []string {
	strs := make([]string, len(_RoutingTableNames))
	copy(strs, _RoutingTableNames)
	return strs
}

// IsARoutingTable returns "true" if the value is listed in the enum definition. "false" otherwise
func (i RoutingTable) IsARoutingTable() bool {
	for _, v := range _RoutingTableValues {
		if i == v {
			return true
		}
	}
	return false
}

// MarshalText implements the encoding.TextMarshaler interface for RoutingTable
func (i RoutingTable) MarshalText() ([]byte, error) {
	return []byte(i.String()), nil
}

// UnmarshalText implements the encoding.TextUnmarshaler interface for RoutingTable
func (i *RoutingTable) UnmarshalText(text []byte) error {
	var err error
	*i, err = RoutingTableString(string(text))
	return err
}

const (
	_ScopeName_0      = "global"
	_ScopeLowerName_0 = "global"
	_ScopeName_1      = "site"
	_ScopeLowerName_1 = "site"
	_ScopeName_2      = "linkhostnowhere"
	_ScopeLowerName_2 = "linkhostnowhere"
)

var (
	_ScopeIndex_0 = [...]uint8{0, 6}
	_ScopeIndex_1 = [...]uint8{0, 4}
	_ScopeIndex_2 = [...]uint8{0, 4, 8, 15}
)

func (i Scope) String() string {
	switch {
	case i == 0:
		return _ScopeName_0
	case i == 200:
		return _ScopeName_1
	case 253 <= i && i <= 255:
		i -= 253
		return _ScopeName_2[_ScopeIndex_2[i]:_ScopeIndex_2[i+1]]
	default:
		return fmt.Sprintf("Scope(%d)", i)
	}
}

// An "invalid array index" compiler error signifies that the constant values have changed.
// Re-run the stringer command to generate them again.
func _ScopeNoOp() {
	var x [1]struct{}
	_ = x[ScopeGlobal-(0)]
	_ = x[ScopeSite-(200)]
	_ = x[ScopeLink-(253)]
	_ = x[ScopeHost-(254)]
	_ = x[ScopeNowhere-(255)]
}

var _ScopeValues = []Scope{ScopeGlobal, ScopeSite, ScopeLink, ScopeHost, ScopeNowhere}

var _ScopeNameToValueMap = map[string]Scope{
	_ScopeName_0[0:6]:       ScopeGlobal,
	_ScopeLowerName_0[0:6]:  ScopeGlobal,
	_ScopeName_1[0:4]:       ScopeSite,
	_ScopeLowerName_1[0:4]:  ScopeSite,
	_ScopeName_2[0:4]:       ScopeLink,
	_ScopeLowerName_2[0:4]:  ScopeLink,
	_ScopeName_2[4:8]:       ScopeHost,
	_ScopeLowerName_2[4:8]:  ScopeHost,
	_ScopeName_2[8:15]:      ScopeNowhere,
	_ScopeLowerName_2[8:15]: ScopeNowhere,
}

var _ScopeNames = []string{
	_ScopeName_0[0:6],
	_ScopeName_1[0:4],
	_ScopeName_2[0:4],
	_ScopeName_2[4:8],
	_ScopeName_2[8:15],
}

// ScopeString retrieves an enum value from the enum constants string name.
// Throws an error if the param is not part of the enum.
func ScopeString(s string) (Scope, error) {
	if val, ok := _ScopeNameToValueMap[s]; ok {
		return val, nil
	}

	if val, ok := _ScopeNameToValueMap[strings.ToLower(s)]; ok {
		return val, nil
	}
	return 0, fmt.Errorf("%s does not belong to Scope values", s)
}

// ScopeValues returns all values of the enum
func ScopeValues() []Scope {
	return _ScopeValues
}

// ScopeStrings returns a slice of all String values of the enum
func ScopeStrings() []string {
	strs := make([]string, len(_ScopeNames))
	copy(strs, _ScopeNames)
	return strs
}

// IsAScope returns "true" if the value is listed in the enum definition. "false" otherwise
func (i Scope) IsAScope() bool {
	for _, v := range _ScopeValues {
		if i == v {
			return true
		}
	}
	return false
}

// MarshalText implements the encoding.TextMarshaler interface for Scope
func (i Scope) MarshalText() ([]byte, error) {
	return []byte(i.String()), nil
}

// UnmarshalText implements the encoding.TextUnmarshaler interface for Scope
func (i *Scope) UnmarshalText(text []byte) error {
	var err error
	*i, err = ScopeString(string(text))
	return err
}

const _StatusName = "addressesconnectivityhostnameetcfiles"

var _StatusIndex = [...]uint8{0, 9, 21, 29, 37}

const _StatusLowerName = "addressesconnectivityhostnameetcfiles"

func (i Status) String() string {
	i -= 1
	if i < 0 || i >= Status(len(_StatusIndex)-1) {
		return fmt.Sprintf("Status(%d)", i+1)
	}
	return _StatusName[_StatusIndex[i]:_StatusIndex[i+1]]
}

// An "invalid array index" compiler error signifies that the constant values have changed.
// Re-run the stringer command to generate them again.
func _StatusNoOp() {
	var x [1]struct{}
	_ = x[StatusAddresses-(1)]
	_ = x[StatusConnectivity-(2)]
	_ = x[StatusHostname-(3)]
	_ = x[StatusEtcFiles-(4)]
}

var _StatusValues = []Status{StatusAddresses, StatusConnectivity, StatusHostname, StatusEtcFiles}

var _StatusNameToValueMap = map[string]Status{
	_StatusName[0:9]:        StatusAddresses,
	_StatusLowerName[0:9]:   StatusAddresses,
	_StatusName[9:21]:       StatusConnectivity,
	_StatusLowerName[9:21]:  StatusConnectivity,
	_StatusName[21:29]:      StatusHostname,
	_StatusLowerName[21:29]: StatusHostname,
	_StatusName[29:37]:      StatusEtcFiles,
	_StatusLowerName[29:37]: StatusEtcFiles,
}

var _StatusNames = []string{
	_StatusName[0:9],
	_StatusName[9:21],
	_StatusName[21:29],
	_StatusName[29:37],
}

// StatusString retrieves an enum value from the enum constants string name.
// Throws an error if the param is not part of the enum.
func StatusString(s string) (Status, error) {
	if val, ok := _StatusNameToValueMap[s]; ok {
		return val, nil
	}

	if val, ok := _StatusNameToValueMap[strings.ToLower(s)]; ok {
		return val, nil
	}
	return 0, fmt.Errorf("%s does not belong to Status values", s)
}

// StatusValues returns all values of the enum
func StatusValues() []Status {
	return _StatusValues
}

// StatusStrings returns a slice of all String values of the enum
func StatusStrings() []string {
	strs := make([]string, len(_StatusNames))
	copy(strs, _StatusNames)
	return strs
}

// IsAStatus returns "true" if the value is listed in the enum definition. "false" otherwise
func (i Status) IsAStatus() bool {
	for _, v := range _StatusValues {
		if i == v {
			return true
		}
	}
	return false
}

// MarshalText implements the encoding.TextMarshaler interface for Status
func (i Status) MarshalText() ([]byte, error) {
	return []byte(i.String()), nil
}

// UnmarshalText implements the encoding.TextUnmarshaler interface for Status
func (i *Status) UnmarshalText(text []byte) error {
	var err error
	*i, err = StatusString(string(text))
	return err
}

const (
	_VLANProtocolName_0      = "802.1q"
	_VLANProtocolLowerName_0 = "802.1q"
	_VLANProtocolName_1      = "802.1ad"
	_VLANProtocolLowerName_1 = "802.1ad"
)

var (
	_VLANProtocolIndex_0 = [...]uint8{0, 6}
	_VLANProtocolIndex_1 = [...]uint8{0, 7}
)

func (i VLANProtocol) String() string {
	switch {
	case i == 33024:
		return _VLANProtocolName_0
	case i == 34984:
		return _VLANProtocolName_1
	default:
		return fmt.Sprintf("VLANProtocol(%d)", i)
	}
}

// An "invalid array index" compiler error signifies that the constant values have changed.
// Re-run the stringer command to generate them again.
func _VLANProtocolNoOp() {
	var x [1]struct{}
	_ = x[VLANProtocol8021Q-(33024)]
	_ = x[VLANProtocol8021AD-(34984)]
}

var _VLANProtocolValues = []VLANProtocol{VLANProtocol8021Q, VLANProtocol8021AD}

var _VLANProtocolNameToValueMap = map[string]VLANProtocol{
	_VLANProtocolName_0[0:6]:      VLANProtocol8021Q,
	_VLANProtocolLowerName_0[0:6]: VLANProtocol8021Q,
	_VLANProtocolName_1[0:7]:      VLANProtocol8021AD,
	_VLANProtocolLowerName_1[0:7]: VLANProtocol8021AD,
}

var _VLANProtocolNames = []string{
	_VLANProtocolName_0[0:6],
	_VLANProtocolName_1[0:7],
}

// VLANProtocolString retrieves an enum value from the enum constants string name.
// Throws an error if the param is not part of the enum.
func VLANProtocolString(s string) (VLANProtocol, error) {
	if val, ok := _VLANProtocolNameToValueMap[s]; ok {
		return val, nil
	}

	if val, ok := _VLANProtocolNameToValueMap[strings.ToLower(s)]; ok {
		return val, nil
	}
	return 0, fmt.Errorf("%s does not belong to VLANProtocol values", s)
}

// VLANProtocolValues returns all values of the enum
func VLANProtocolValues() []VLANProtocol {
	return _VLANProtocolValues
}

// VLANProtocolStrings returns a slice of all String values of the enum
func VLANProtocolStrings() []string {
	strs := make([]string, len(_VLANProtocolNames))
	copy(strs, _VLANProtocolNames)
	return strs
}

// IsAVLANProtocol returns "true" if the value is listed in the enum definition. "false" otherwise
func (i VLANProtocol) IsAVLANProtocol() bool {
	for _, v := range _VLANProtocolValues {
		if i == v {
			return true
		}
	}
	return false
}

// MarshalText implements the encoding.TextMarshaler interface for VLANProtocol
func (i VLANProtocol) MarshalText() ([]byte, error) {
	return []byte(i.String()), nil
}

// UnmarshalText implements the encoding.TextUnmarshaler interface for VLANProtocol
func (i *VLANProtocol) UnmarshalText(text []byte) error {
	var err error
	*i, err = VLANProtocolString(string(text))
	return err
}

const (
	_WOLModeName_0      = "phyunicast"
	_WOLModeLowerName_0 = "phyunicast"
	_WOLModeName_1      = "multicast"
	_WOLModeLowerName_1 = "multicast"
	_WOLModeName_2      = "broadcast"
	_WOLModeLowerName_2 = "broadcast"
	_WOLModeName_3      = "magic"
	_WOLModeLowerName_3 = "magic"
	_WOLModeName_4      = "magicsecure"
	_WOLModeLowerName_4 = "magicsecure"
	_WOLModeName_5      = "filter"
	_WOLModeLowerName_5 = "filter"
)

var (
	_WOLModeIndex_0 = [...]uint8{0, 3, 10}
	_WOLModeIndex_1 = [...]uint8{0, 9}
	_WOLModeIndex_2 = [...]uint8{0, 9}
	_WOLModeIndex_3 = [...]uint8{0, 5}
	_WOLModeIndex_4 = [...]uint8{0, 11}
	_WOLModeIndex_5 = [...]uint8{0, 6}
)

func (i WOLMode) String() string {
	switch {
	case 1 <= i && i <= 2:
		i -= 1
		return _WOLModeName_0[_WOLModeIndex_0[i]:_WOLModeIndex_0[i+1]]
	case i == 4:
		return _WOLModeName_1
	case i == 8:
		return _WOLModeName_2
	case i == 32:
		return _WOLModeName_3
	case i == 64:
		return _WOLModeName_4
	case i == 128:
		return _WOLModeName_5
	default:
		return fmt.Sprintf("WOLMode(%d)", i)
	}
}

// An "invalid array index" compiler error signifies that the constant values have changed.
// Re-run the stringer command to generate them again.
func _WOLModeNoOp() {
	var x [1]struct{}
	_ = x[WOLModePhy-(1)]
	_ = x[WOLModeUnicast-(2)]
	_ = x[WOLModeMulticast-(4)]
	_ = x[WOLModeBroadcast-(8)]
	_ = x[WOLModeMagic-(32)]
	_ = x[WOLModeMagicSecure-(64)]
	_ = x[WOLModeFilter-(128)]
}

var _WOLModeValues = []WOLMode{WOLModePhy, WOLModeUnicast, WOLModeMulticast, WOLModeBroadcast, WOLModeMagic, WOLModeMagicSecure, WOLModeFilter}

var _WOLModeNameToValueMap = map[string]WOLMode{
	_WOLModeName_0[0:3]:       WOLModePhy,
	_WOLModeLowerName_0[0:3]:  WOLModePhy,
	_WOLModeName_0[3:10]:      WOLModeUnicast,
	_WOLModeLowerName_0[3:10]: WOLModeUnicast,
	_WOLModeName_1[0:9]:       WOLModeMulticast,
	_WOLModeLowerName_1[0:9]:  WOLModeMulticast,
	_WOLModeName_2[0:9]:       WOLModeBroadcast,
	_WOLModeLowerName_2[0:9]:  WOLModeBroadcast,
	_WOLModeName_3[0:5]:       WOLModeMagic,
	_WOLModeLowerName_3[0:5]:  WOLModeMagic,
	_WOLModeName_4[0:11]:      WOLModeMagicSecure,
	_WOLModeLowerName_4[0:11]: WOLModeMagicSecure,
	_WOLModeName_5[0:6]:       WOLModeFilter,
	_WOLModeLowerName_5[0:6]:  WOLModeFilter,
}

var _WOLModeNames = []string{
	_WOLModeName_0[0:3],
	_WOLModeName_0[3:10],
	_WOLModeName_1[0:9],
	_WOLModeName_2[0:9],
	_WOLModeName_3[0:5],
	_WOLModeName_4[0:11],
	_WOLModeName_5[0:6],
}

// WOLModeString retrieves an enum value from the enum constants string name.
// Throws an error if the param is not part of the enum.
func WOLModeString(s string) (WOLMode, error) {
	if val, ok := _WOLModeNameToValueMap[s]; ok {
		return val, nil
	}

	if val, ok := _WOLModeNameToValueMap[strings.ToLower(s)]; ok {
		return val, nil
	}
	return 0, fmt.Errorf("%s does not belong to WOLMode values", s)
}

// WOLModeValues returns all values of the enum
func WOLModeValues() []WOLMode {
	return _WOLModeValues
}

// WOLModeStrings returns a slice of all String values of the enum
func WOLModeStrings() []string {
	strs := make([]string, len(_WOLModeNames))
	copy(strs, _WOLModeNames)
	return strs
}

// IsAWOLMode returns "true" if the value is listed in the enum definition. "false" otherwise
func (i WOLMode) IsAWOLMode() bool {
	for _, v := range _WOLModeValues {
		if i == v {
			return true
		}
	}
	return false
}

// MarshalText implements the encoding.TextMarshaler interface for WOLMode
func (i WOLMode) MarshalText() ([]byte, error) {
	return []byte(i.String()), nil
}

// UnmarshalText implements the encoding.TextUnmarshaler interface for WOLMode
func (i *WOLMode) UnmarshalText(text []byte) error {
	var err error
	*i, err = WOLModeString(string(text))
	return err
}
