config.pb.go

// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: mesh/v1alpha1/config.proto

/*
	Package v1alpha1 is a generated protocol buffer package.

	It is generated from these files:
		mesh/v1alpha1/config.proto
		mesh/v1alpha1/network.proto
		mesh/v1alpha1/proxy.proto

	It has these top-level messages:
		MeshConfig
		ConfigSource
		Network
		MeshNetworks
		Tracing
		ProxyConfig
*/
package v1alpha1

import proto "github.com/gogo/protobuf/proto"
import fmt "fmt"
import math "math"
import google_protobuf "github.com/gogo/protobuf/types"
import istio_networking_v1alpha33 "istio.io/api/networking/v1alpha3"

import io "io"

// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf

// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.GoGoProtoPackageIsVersion2 // please upgrade the proto package

type MeshConfig_IngressControllerMode int32

const (
	// Disables Istio ingress controller.
	MeshConfig_OFF MeshConfig_IngressControllerMode = 0
	// Istio ingress controller will act on ingress resources that do not
	// contain any annotation or whose annotations match the value
	// specified in the ingress_class parameter described earlier. Use this
	// mode if Istio ingress controller will be the default ingress
	// controller for the entire kubernetes cluster.
	MeshConfig_DEFAULT MeshConfig_IngressControllerMode = 1
	// Istio ingress controller will only act on ingress resources whose
	// annotations match the value specified in the ingress_class parameter
	// described earlier. Use this mode if Istio ingress controller will be
	// a secondary ingress controller (e.g., in addition to a
	// cloud-provided ingress controller).
	MeshConfig_STRICT MeshConfig_IngressControllerMode = 2
)

var MeshConfig_IngressControllerMode_name = map[int32]string{
	0: "OFF",
	1: "DEFAULT",
	2: "STRICT",
}
var MeshConfig_IngressControllerMode_value = map[string]int32{
	"OFF":     0,
	"DEFAULT": 1,
	"STRICT":  2,
}

func (x MeshConfig_IngressControllerMode) String() string {
	return proto.EnumName(MeshConfig_IngressControllerMode_name, int32(x))
}
func (MeshConfig_IngressControllerMode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptorConfig, []int{0, 0}
}

// $hide_from_docs
type MeshConfig_AuthPolicy int32

const (
	MeshConfig_NONE       MeshConfig_AuthPolicy = 0
	MeshConfig_MUTUAL_TLS MeshConfig_AuthPolicy = 1
)

var MeshConfig_AuthPolicy_name = map[int32]string{
	0: "NONE",
	1: "MUTUAL_TLS",
}
var MeshConfig_AuthPolicy_value = map[string]int32{
	"NONE":       0,
	"MUTUAL_TLS": 1,
}

func (x MeshConfig_AuthPolicy) String() string {
	return proto.EnumName(MeshConfig_AuthPolicy_name, int32(x))
}
func (MeshConfig_AuthPolicy) EnumDescriptor() ([]byte, []int) {
	return fileDescriptorConfig, []int{0, 1}
}

type MeshConfig_AccessLogEncoding int32

const (
	MeshConfig_TEXT MeshConfig_AccessLogEncoding = 0
	MeshConfig_JSON MeshConfig_AccessLogEncoding = 1
)

var MeshConfig_AccessLogEncoding_name = map[int32]string{
	0: "TEXT",
	1: "JSON",
}
var MeshConfig_AccessLogEncoding_value = map[string]int32{
	"TEXT": 0,
	"JSON": 1,
}

func (x MeshConfig_AccessLogEncoding) String() string {
	return proto.EnumName(MeshConfig_AccessLogEncoding_name, int32(x))
}
func (MeshConfig_AccessLogEncoding) EnumDescriptor() ([]byte, []int) {
	return fileDescriptorConfig, []int{0, 2}
}

type MeshConfig_OutboundTrafficPolicy_Mode int32

const (
	// outbound traffic will be restricted to services defined in the
	// service registry as well as those defined through ServiceEntries
	MeshConfig_OutboundTrafficPolicy_REGISTRY_ONLY MeshConfig_OutboundTrafficPolicy_Mode = 0
	// outbound traffic to unknown destinations will be allowed, in case
	// there are no services or ServiceEntries for the destination port
	MeshConfig_OutboundTrafficPolicy_ALLOW_ANY MeshConfig_OutboundTrafficPolicy_Mode = 1
)

var MeshConfig_OutboundTrafficPolicy_Mode_name = map[int32]string{
	0: "REGISTRY_ONLY",
	1: "ALLOW_ANY",
}
var MeshConfig_OutboundTrafficPolicy_Mode_value = map[string]int32{
	"REGISTRY_ONLY": 0,
	"ALLOW_ANY":     1,
}

func (x MeshConfig_OutboundTrafficPolicy_Mode) String() string {
	return proto.EnumName(MeshConfig_OutboundTrafficPolicy_Mode_name, int32(x))
}
func (MeshConfig_OutboundTrafficPolicy_Mode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptorConfig, []int{0, 0, 0}
}

// MeshConfig defines mesh-wide variables shared by all Envoy instances in the
// Istio service mesh.
//
// NOTE: This configuration type should be used for the low-level global
// configuration, such as component addresses and port numbers. It should not
// be used for the features of the mesh that can be scoped by service or by
// namespace. Some of the fields in the mesh config are going to be deprecated
// and replaced with several individual configuration types (for example,
// tracing configuration).
type MeshConfig struct {
	// Address of the server that will be used by the proxies for policy
	// check calls. By using different names for mixerCheckServer and
	// mixerReportServer, it is possible to have one set of mixer servers handle
	// policy check calls while another set of mixer servers handle telemetry
	// calls.
	//
	// NOTE: Omitting mixerCheckServer while specifying mixerReportServer is
	// equivalent to setting disablePolicyChecks to true.
	MixerCheckServer string `protobuf:"bytes,1,opt,name=mixer_check_server,json=mixerCheckServer,proto3" json:"mixer_check_server,omitempty"`
	// Address of the server that will be used by the proxies for policy report
	// calls.
	MixerReportServer string `protobuf:"bytes,2,opt,name=mixer_report_server,json=mixerReportServer,proto3" json:"mixer_report_server,omitempty"`
	// Disable policy checks by the mixer service. Default
	// is false, i.e. mixer policy check is enabled by default.
	DisablePolicyChecks bool `protobuf:"varint,3,opt,name=disable_policy_checks,json=disablePolicyChecks,proto3" json:"disable_policy_checks,omitempty"`
	// Allow all traffic in cases when the mixer policy service cannot be reached.
	// Default is false which means the traffic is denied when the client is unable
	// to connect to Mixer.
	PolicyCheckFailOpen bool `protobuf:"varint,25,opt,name=policy_check_fail_open,json=policyCheckFailOpen,proto3" json:"policy_check_fail_open,omitempty"`
	// Enable session affinity for envoy mixer reports so that calls from a proxy will
	// always target the same mixer instance.
	SidecarToTelemetrySessionAffinity bool `protobuf:"varint,30,opt,name=sidecar_to_telemetry_session_affinity,json=sidecarToTelemetrySessionAffinity,proto3" json:"sidecar_to_telemetry_session_affinity,omitempty"`
	// Port on which Envoy should listen for incoming connections from
	// other services.
	ProxyListenPort int32 `protobuf:"varint,4,opt,name=proxy_listen_port,json=proxyListenPort,proto3" json:"proxy_listen_port,omitempty"`
	// Port on which Envoy should listen for HTTP PROXY requests if set.
	ProxyHttpPort int32 `protobuf:"varint,5,opt,name=proxy_http_port,json=proxyHttpPort,proto3" json:"proxy_http_port,omitempty"`
	// Connection timeout used by Envoy. (MUST BE >=1ms)
	ConnectTimeout *google_protobuf.Duration `protobuf:"bytes,6,opt,name=connect_timeout,json=connectTimeout" json:"connect_timeout,omitempty"`
	// If set then set SO_KEEPALIVE on the socket to enable TCP Keepalives.
	TcpKeepalive *istio_networking_v1alpha33.ConnectionPoolSettings_TCPSettings_TcpKeepalive `protobuf:"bytes,28,opt,name=tcp_keepalive,json=tcpKeepalive" json:"tcp_keepalive,omitempty"`
	// Class of ingress resources to be processed by Istio ingress
	// controller.  This corresponds to the value of
	// "kubernetes.io/ingress.class" annotation.
	IngressClass string `protobuf:"bytes,7,opt,name=ingress_class,json=ingressClass,proto3" json:"ingress_class,omitempty"`
	// Name of the kubernetes service used for the istio ingress controller.
	IngressService string `protobuf:"bytes,8,opt,name=ingress_service,json=ingressService,proto3" json:"ingress_service,omitempty"`
	// Defines whether to use Istio ingress controller for annotated or all ingress resources.
	IngressControllerMode MeshConfig_IngressControllerMode `protobuf:"varint,9,opt,name=ingress_controller_mode,json=ingressControllerMode,proto3,enum=istio.mesh.v1alpha1.MeshConfig_IngressControllerMode" json:"ingress_controller_mode,omitempty"`
	// $hide_from_docs
	AuthPolicy MeshConfig_AuthPolicy `protobuf:"varint,10,opt,name=auth_policy,json=authPolicy,proto3,enum=istio.mesh.v1alpha1.MeshConfig_AuthPolicy" json:"auth_policy,omitempty"`
	// $hide_from_docs
	RdsRefreshDelay *google_protobuf.Duration `protobuf:"bytes,11,opt,name=rds_refresh_delay,json=rdsRefreshDelay" json:"rds_refresh_delay,omitempty"`
	// Flag to control generation of trace spans and request IDs.
	// Requires a trace span collector defined in the proxy configuration.
	EnableTracing bool `protobuf:"varint,12,opt,name=enable_tracing,json=enableTracing,proto3" json:"enable_tracing,omitempty"`
	// File address for the proxy access log (e.g. /dev/stdout).
	// Empty value disables access logging.
	AccessLogFile string `protobuf:"bytes,13,opt,name=access_log_file,json=accessLogFile,proto3" json:"access_log_file,omitempty"`
	// Format for the proxy access log
	// Empty value results in proxy's default access log format
	AccessLogFormat string `protobuf:"bytes,24,opt,name=access_log_format,json=accessLogFormat,proto3" json:"access_log_format,omitempty"`
	// Encoding for the proxy access log (text or json).
	// Default value is text.
	AccessLogEncoding MeshConfig_AccessLogEncoding `protobuf:"varint,27,opt,name=access_log_encoding,json=accessLogEncoding,proto3,enum=istio.mesh.v1alpha1.MeshConfig_AccessLogEncoding" json:"access_log_encoding,omitempty"`
	// Default proxy config used by the proxy injection mechanism operating in the mesh
	// (e.g. Kubernetes admission controller)
	// In case of Kubernetes, the proxy config is applied once during the injection process,
	// and remain constant for the duration of the pod. The rest of the mesh config can be changed
	// at runtime and config gets distributed dynamically.
	DefaultConfig *ProxyConfig `protobuf:"bytes,14,opt,name=default_config,json=defaultConfig" json:"default_config,omitempty"`
	// $hide_from_docs
	MixerAddress string `protobuf:"bytes,16,opt,name=mixer_address,json=mixerAddress,proto3" json:"mixer_address,omitempty"`
	// Set the default behavior of the sidecar for handling outbound traffic
	// from the application.  If your application uses one or more external
	// services that are not known apriori, setting the policy to ALLOW_ANY
	// will cause the sidecars to route any unknown traffic originating from
	// the application to its requested destination.  Users are strongly
	// encouraged to use ServiceEntries to explicitly declare any external
	// dependencies, instead of using allow_any, so that traffic to these
	// services can be monitored.
	OutboundTrafficPolicy *MeshConfig_OutboundTrafficPolicy `protobuf:"bytes,17,opt,name=outbound_traffic_policy,json=outboundTrafficPolicy" json:"outbound_traffic_policy,omitempty"`
	// Enables clide side policy checks.
	EnableClientSidePolicyCheck bool `protobuf:"varint,19,opt,name=enable_client_side_policy_check,json=enableClientSidePolicyCheck,proto3" json:"enable_client_side_policy_check,omitempty"`
	// Unix Domain Socket through which envoy communicates with NodeAgent SDS to get key/cert for mTLS.
	// Use secret-mount files instead of SDS if set to empty.
	SdsUdsPath string `protobuf:"bytes,20,opt,name=sds_uds_path,json=sdsUdsPath,proto3" json:"sds_uds_path,omitempty"`
	// $hide_from_docs
	SdsRefreshDelay *google_protobuf.Duration `protobuf:"bytes,21,opt,name=sds_refresh_delay,json=sdsRefreshDelay" json:"sds_refresh_delay,omitempty"`
	// ConfigSource describes a source of configuration data for networking
	// rules, and other Istio configuration artifacts. Multiple data sources
	// can be configured for a single control plane.
	ConfigSources []*ConfigSource `protobuf:"bytes,22,rep,name=config_sources,json=configSources" json:"config_sources,omitempty"`
	// $hide_from_docs
	// This flag is used by secret discovery service(SDS).
	// If set to true(prerequisite: https://kubernetes.io/docs/concepts/storage/volumes/#projected), Istio will inject volumes mount
	// for k8s service account trustworthy JWT(which is avaialbe for k8s 1.12 or higher), so that K8s API server
	// mounts k8s service account trustworthy JWT to envoy container, which will be used to request key/cert eventually.
	// This isn't supported for non-k8s case.
	EnableSdsTokenMount bool `protobuf:"varint,23,opt,name=enable_sds_token_mount,json=enableSdsTokenMount,proto3" json:"enable_sds_token_mount,omitempty"`
	// $hide_from_docs
	// This flag is used by secret discovery service(SDS).
	// If set to true, envoy will fetch normal k8s service account JWT from '/var/run/secrets/kubernetes.io/serviceaccount/token'
	// (https://kubernetes.io/docs/tasks/access-application-cluster/access-cluster/#accessing-the-api-from-a-pod)
	// and pass to sds server, which will be used to request key/cert eventually.
	// If both enable_sds_token_mount and sds_use_k8s_sa_jwt are set to true, enable_sds_token_mount(trustworthy jwt) takes precedence.
	// This isn't supported for non-k8s case.
	SdsUseK8SSaJwt bool `protobuf:"varint,29,opt,name=sds_use_k8s_sa_jwt,json=sdsUseK8sSaJwt,proto3" json:"sds_use_k8s_sa_jwt,omitempty"`
	// The trust domain corresponds to the trust root of a system.
	// Refer to https://github.com/spiffe/spiffe/blob/master/standards/SPIFFE-ID.md#21-trust-domain
	// Fallback to old identity format(without trust domain) if not set.
	TrustDomain string `protobuf:"bytes,26,opt,name=trust_domain,json=trustDomain,proto3" json:"trust_domain,omitempty"`
}

func (m *MeshConfig) Reset()                    { *m = MeshConfig{} }
func (m *MeshConfig) String() string            { return proto.CompactTextString(m) }
func (*MeshConfig) ProtoMessage()               {}
func (*MeshConfig) Descriptor() ([]byte, []int) { return fileDescriptorConfig, []int{0} }

func (m *MeshConfig) GetMixerCheckServer() string {
	if m != nil {
		return m.MixerCheckServer
	}
	return ""
}

func (m *MeshConfig) GetMixerReportServer() string {
	if m != nil {
		return m.MixerReportServer
	}
	return ""
}

func (m *MeshConfig) GetDisablePolicyChecks() bool {
	if m != nil {
		return m.DisablePolicyChecks
	}
	return false
}

func (m *MeshConfig) GetPolicyCheckFailOpen() bool {
	if m != nil {
		return m.PolicyCheckFailOpen
	}
	return false
}

func (m *MeshConfig) GetSidecarToTelemetrySessionAffinity() bool {
	if m != nil {
		return m.SidecarToTelemetrySessionAffinity
	}
	return false
}

func (m *MeshConfig) GetProxyListenPort() int32 {
	if m != nil {
		return m.ProxyListenPort
	}
	return 0
}

func (m *MeshConfig) GetProxyHttpPort() int32 {
	if m != nil {
		return m.ProxyHttpPort
	}
	return 0
}

func (m *MeshConfig) GetConnectTimeout() *google_protobuf.Duration {
	if m != nil {
		return m.ConnectTimeout
	}
	return nil
}

func (m *MeshConfig) GetTcpKeepalive() *istio_networking_v1alpha33.ConnectionPoolSettings_TCPSettings_TcpKeepalive {
	if m != nil {
		return m.TcpKeepalive
	}
	return nil
}

func (m *MeshConfig) GetIngressClass() string {
	if m != nil {
		return m.IngressClass
	}
	return ""
}

func (m *MeshConfig) GetIngressService() string {
	if m != nil {
		return m.IngressService
	}
	return ""
}

func (m *MeshConfig) GetIngressControllerMode() MeshConfig_IngressControllerMode {
	if m != nil {
		return m.IngressControllerMode
	}
	return MeshConfig_OFF
}

func (m *MeshConfig) GetAuthPolicy() MeshConfig_AuthPolicy {
	if m != nil {
		return m.AuthPolicy
	}
	return MeshConfig_NONE
}

func (m *MeshConfig) GetRdsRefreshDelay() *google_protobuf.Duration {
	if m != nil {
		return m.RdsRefreshDelay
	}
	return nil
}

func (m *MeshConfig) GetEnableTracing() bool {
	if m != nil {
		return m.EnableTracing
	}
	return false
}

func (m *MeshConfig) GetAccessLogFile() string {
	if m != nil {
		return m.AccessLogFile
	}
	return ""
}

func (m *MeshConfig) GetAccessLogFormat() string {
	if m != nil {
		return m.AccessLogFormat
	}
	return ""
}

func (m *MeshConfig) GetAccessLogEncoding() MeshConfig_AccessLogEncoding {
	if m != nil {
		return m.AccessLogEncoding
	}
	return MeshConfig_TEXT
}

func (m *MeshConfig) GetDefaultConfig() *ProxyConfig {
	if m != nil {
		return m.DefaultConfig
	}
	return nil
}

func (m *MeshConfig) GetMixerAddress() string {
	if m != nil {
		return m.MixerAddress
	}
	return ""
}

func (m *MeshConfig) GetOutboundTrafficPolicy() *MeshConfig_OutboundTrafficPolicy {
	if m != nil {
		return m.OutboundTrafficPolicy
	}
	return nil
}

func (m *MeshConfig) GetEnableClientSidePolicyCheck() bool {
	if m != nil {
		return m.EnableClientSidePolicyCheck
	}
	return false
}

func (m *MeshConfig) GetSdsUdsPath() string {
	if m != nil {
		return m.SdsUdsPath
	}
	return ""
}

func (m *MeshConfig) GetSdsRefreshDelay() *google_protobuf.Duration {
	if m != nil {
		return m.SdsRefreshDelay
	}
	return nil
}

func (m *MeshConfig) GetConfigSources() []*ConfigSource {
	if m != nil {
		return m.ConfigSources
	}
	return nil
}

func (m *MeshConfig) GetEnableSdsTokenMount() bool {
	if m != nil {
		return m.EnableSdsTokenMount
	}
	return false
}

func (m *MeshConfig) GetSdsUseK8SSaJwt() bool {
	if m != nil {
		return m.SdsUseK8SSaJwt
	}
	return false
}

func (m *MeshConfig) GetTrustDomain() string {
	if m != nil {
		return m.TrustDomain
	}
	return ""
}

type MeshConfig_OutboundTrafficPolicy struct {
	Mode MeshConfig_OutboundTrafficPolicy_Mode `protobuf:"varint,1,opt,name=mode,proto3,enum=istio.mesh.v1alpha1.MeshConfig_OutboundTrafficPolicy_Mode" json:"mode,omitempty"`
}

func (m *MeshConfig_OutboundTrafficPolicy) Reset()         { *m = MeshConfig_OutboundTrafficPolicy{} }
func (m *MeshConfig_OutboundTrafficPolicy) String() string { return proto.CompactTextString(m) }
func (*MeshConfig_OutboundTrafficPolicy) ProtoMessage()    {}
func (*MeshConfig_OutboundTrafficPolicy) Descriptor() ([]byte, []int) {
	return fileDescriptorConfig, []int{0, 0}
}

func (m *MeshConfig_OutboundTrafficPolicy) GetMode() MeshConfig_OutboundTrafficPolicy_Mode {
	if m != nil {
		return m.Mode
	}
	return MeshConfig_OutboundTrafficPolicy_REGISTRY_ONLY
}

// ConfigSource describes information about a configuration store inside a
// mesh. A single control plane instance can interact with one or more data
// sources.
type ConfigSource struct {
	// Address of the server implementing the Istio Mesh Configuration
	// protocol (MCP). Can be IP address or a fully qualified DNS name.
	// Use fs:/// to specify a file-based backend with absolute path to the directory.
	Address string `protobuf:"bytes,1,opt,name=address,proto3" json:"address,omitempty"`
	// Use the tls_settings to specify the tls mode to use. If the MCP server
	// uses Istio MTLS and shares the root CA with Pilot, specify the TLS
	// mode as ISTIO_MUTUAL.
	TlsSettings *istio_networking_v1alpha33.TLSSettings `protobuf:"bytes,2,opt,name=tls_settings,json=tlsSettings" json:"tls_settings,omitempty"`
}

func (m *ConfigSource) Reset()                    { *m = ConfigSource{} }
func (m *ConfigSource) String() string            { return proto.CompactTextString(m) }
func (*ConfigSource) ProtoMessage()               {}
func (*ConfigSource) Descriptor() ([]byte, []int) { return fileDescriptorConfig, []int{1} }

func (m *ConfigSource) GetAddress() string {
	if m != nil {
		return m.Address
	}
	return ""
}

func (m *ConfigSource) GetTlsSettings() *istio_networking_v1alpha33.TLSSettings {
	if m != nil {
		return m.TlsSettings
	}
	return nil
}

func init() {
	proto.RegisterType((*MeshConfig)(nil), "istio.mesh.v1alpha1.MeshConfig")
	proto.RegisterType((*MeshConfig_OutboundTrafficPolicy)(nil), "istio.mesh.v1alpha1.MeshConfig.OutboundTrafficPolicy")
	proto.RegisterType((*ConfigSource)(nil), "istio.mesh.v1alpha1.ConfigSource")
	proto.RegisterEnum("istio.mesh.v1alpha1.MeshConfig_IngressControllerMode", MeshConfig_IngressControllerMode_name, MeshConfig_IngressControllerMode_value)
	proto.RegisterEnum("istio.mesh.v1alpha1.MeshConfig_AuthPolicy", MeshConfig_AuthPolicy_name, MeshConfig_AuthPolicy_value)
	proto.RegisterEnum("istio.mesh.v1alpha1.MeshConfig_AccessLogEncoding", MeshConfig_AccessLogEncoding_name, MeshConfig_AccessLogEncoding_value)
	proto.RegisterEnum("istio.mesh.v1alpha1.MeshConfig_OutboundTrafficPolicy_Mode", MeshConfig_OutboundTrafficPolicy_Mode_name, MeshConfig_OutboundTrafficPolicy_Mode_value)
}
func (m *MeshConfig) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *MeshConfig) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.MixerCheckServer) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintConfig(dAtA, i, uint64(len(m.MixerCheckServer)))
		i += copy(dAtA[i:], m.MixerCheckServer)
	}
	if len(m.MixerReportServer) > 0 {
		dAtA[i] = 0x12
		i++
		i = encodeVarintConfig(dAtA, i, uint64(len(m.MixerReportServer)))
		i += copy(dAtA[i:], m.MixerReportServer)
	}
	if m.DisablePolicyChecks {
		dAtA[i] = 0x18
		i++
		if m.DisablePolicyChecks {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i++
	}
	if m.ProxyListenPort != 0 {
		dAtA[i] = 0x20
		i++
		i = encodeVarintConfig(dAtA, i, uint64(m.ProxyListenPort))
	}
	if m.ProxyHttpPort != 0 {
		dAtA[i] = 0x28
		i++
		i = encodeVarintConfig(dAtA, i, uint64(m.ProxyHttpPort))
	}
	if m.ConnectTimeout != nil {
		dAtA[i] = 0x32
		i++
		i = encodeVarintConfig(dAtA, i, uint64(m.ConnectTimeout.Size()))
		n1, err := m.ConnectTimeout.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n1
	}
	if len(m.IngressClass) > 0 {
		dAtA[i] = 0x3a
		i++
		i = encodeVarintConfig(dAtA, i, uint64(len(m.IngressClass)))
		i += copy(dAtA[i:], m.IngressClass)
	}
	if len(m.IngressService) > 0 {
		dAtA[i] = 0x42
		i++
		i = encodeVarintConfig(dAtA, i, uint64(len(m.IngressService)))
		i += copy(dAtA[i:], m.IngressService)
	}
	if m.IngressControllerMode != 0 {
		dAtA[i] = 0x48
		i++
		i = encodeVarintConfig(dAtA, i, uint64(m.IngressControllerMode))
	}
	if m.AuthPolicy != 0 {
		dAtA[i] = 0x50
		i++
		i = encodeVarintConfig(dAtA, i, uint64(m.AuthPolicy))
	}
	if m.RdsRefreshDelay != nil {
		dAtA[i] = 0x5a
		i++
		i = encodeVarintConfig(dAtA, i, uint64(m.RdsRefreshDelay.Size()))
		n2, err := m.RdsRefreshDelay.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n2
	}
	if m.EnableTracing {
		dAtA[i] = 0x60
		i++
		if m.EnableTracing {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i++
	}
	if len(m.AccessLogFile) > 0 {
		dAtA[i] = 0x6a
		i++
		i = encodeVarintConfig(dAtA, i, uint64(len(m.AccessLogFile)))
		i += copy(dAtA[i:], m.AccessLogFile)
	}
	if m.DefaultConfig != nil {
		dAtA[i] = 0x72
		i++
		i = encodeVarintConfig(dAtA, i, uint64(m.DefaultConfig.Size()))
		n3, err := m.DefaultConfig.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n3
	}
	if len(m.MixerAddress) > 0 {
		dAtA[i] = 0x82
		i++
		dAtA[i] = 0x1
		i++
		i = encodeVarintConfig(dAtA, i, uint64(len(m.MixerAddress)))
		i += copy(dAtA[i:], m.MixerAddress)
	}
	if m.OutboundTrafficPolicy != nil {
		dAtA[i] = 0x8a
		i++
		dAtA[i] = 0x1
		i++
		i = encodeVarintConfig(dAtA, i, uint64(m.OutboundTrafficPolicy.Size()))
		n4, err := m.OutboundTrafficPolicy.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n4
	}
	if m.EnableClientSidePolicyCheck {
		dAtA[i] = 0x98
		i++
		dAtA[i] = 0x1
		i++
		if m.EnableClientSidePolicyCheck {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i++
	}
	if len(m.SdsUdsPath) > 0 {
		dAtA[i] = 0xa2
		i++
		dAtA[i] = 0x1
		i++
		i = encodeVarintConfig(dAtA, i, uint64(len(m.SdsUdsPath)))
		i += copy(dAtA[i:], m.SdsUdsPath)
	}
	if m.SdsRefreshDelay != nil {
		dAtA[i] = 0xaa
		i++
		dAtA[i] = 0x1
		i++
		i = encodeVarintConfig(dAtA, i, uint64(m.SdsRefreshDelay.Size()))
		n5, err := m.SdsRefreshDelay.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n5
	}
	if len(m.ConfigSources) > 0 {
		for _, msg := range m.ConfigSources {
			dAtA[i] = 0xb2
			i++
			dAtA[i] = 0x1
			i++
			i = encodeVarintConfig(dAtA, i, uint64(msg.Size()))
			n, err := msg.MarshalTo(dAtA[i:])
			if err != nil {
				return 0, err
			}
			i += n
		}
	}
	if m.EnableSdsTokenMount {
		dAtA[i] = 0xb8
		i++
		dAtA[i] = 0x1
		i++
		if m.EnableSdsTokenMount {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i++
	}
	if len(m.AccessLogFormat) > 0 {
		dAtA[i] = 0xc2
		i++
		dAtA[i] = 0x1
		i++
		i = encodeVarintConfig(dAtA, i, uint64(len(m.AccessLogFormat)))
		i += copy(dAtA[i:], m.AccessLogFormat)
	}
	if m.PolicyCheckFailOpen {
		dAtA[i] = 0xc8
		i++
		dAtA[i] = 0x1
		i++
		if m.PolicyCheckFailOpen {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i++
	}
	if len(m.TrustDomain) > 0 {
		dAtA[i] = 0xd2
		i++
		dAtA[i] = 0x1
		i++
		i = encodeVarintConfig(dAtA, i, uint64(len(m.TrustDomain)))
		i += copy(dAtA[i:], m.TrustDomain)
	}
	if m.AccessLogEncoding != 0 {
		dAtA[i] = 0xd8
		i++
		dAtA[i] = 0x1
		i++
		i = encodeVarintConfig(dAtA, i, uint64(m.AccessLogEncoding))
	}
	if m.TcpKeepalive != nil {
		dAtA[i] = 0xe2
		i++
		dAtA[i] = 0x1
		i++
		i = encodeVarintConfig(dAtA, i, uint64(m.TcpKeepalive.Size()))
		n6, err := m.TcpKeepalive.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n6
	}
	if m.SdsUseK8SSaJwt {
		dAtA[i] = 0xe8
		i++
		dAtA[i] = 0x1
		i++
		if m.SdsUseK8SSaJwt {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i++
	}
	if m.SidecarToTelemetrySessionAffinity {
		dAtA[i] = 0xf0
		i++
		dAtA[i] = 0x1
		i++
		if m.SidecarToTelemetrySessionAffinity {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i++
	}
	return i, nil
}

func (m *MeshConfig_OutboundTrafficPolicy) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *MeshConfig_OutboundTrafficPolicy) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Mode != 0 {
		dAtA[i] = 0x8
		i++
		i = encodeVarintConfig(dAtA, i, uint64(m.Mode))
	}
	return i, nil
}

func (m *ConfigSource) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *ConfigSource) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Address) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintConfig(dAtA, i, uint64(len(m.Address)))
		i += copy(dAtA[i:], m.Address)
	}
	if m.TlsSettings != nil {
		dAtA[i] = 0x12
		i++
		i = encodeVarintConfig(dAtA, i, uint64(m.TlsSettings.Size()))
		n7, err := m.TlsSettings.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n7
	}
	return i, nil
}

func encodeVarintConfig(dAtA []byte, offset int, v uint64) int {
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return offset + 1
}
func (m *MeshConfig) Size() (n int) {
	var l int
	_ = l
	l = len(m.MixerCheckServer)
	if l > 0 {
		n += 1 + l + sovConfig(uint64(l))
	}
	l = len(m.MixerReportServer)
	if l > 0 {
		n += 1 + l + sovConfig(uint64(l))
	}
	if m.DisablePolicyChecks {
		n += 2
	}
	if m.ProxyListenPort != 0 {
		n += 1 + sovConfig(uint64(m.ProxyListenPort))
	}
	if m.ProxyHttpPort != 0 {
		n += 1 + sovConfig(uint64(m.ProxyHttpPort))
	}
	if m.ConnectTimeout != nil {
		l = m.ConnectTimeout.Size()
		n += 1 + l + sovConfig(uint64(l))
	}
	l = len(m.IngressClass)
	if l > 0 {
		n += 1 + l + sovConfig(uint64(l))
	}
	l = len(m.IngressService)
	if l > 0 {
		n += 1 + l + sovConfig(uint64(l))
	}
	if m.IngressControllerMode != 0 {
		n += 1 + sovConfig(uint64(m.IngressControllerMode))
	}
	if m.AuthPolicy != 0 {
		n += 1 + sovConfig(uint64(m.AuthPolicy))
	}
	if m.RdsRefreshDelay != nil {
		l = m.RdsRefreshDelay.Size()
		n += 1 + l + sovConfig(uint64(l))
	}
	if m.EnableTracing {
		n += 2
	}
	l = len(m.AccessLogFile)
	if l > 0 {
		n += 1 + l + sovConfig(uint64(l))
	}
	if m.DefaultConfig != nil {
		l = m.DefaultConfig.Size()
		n += 1 + l + sovConfig(uint64(l))
	}
	l = len(m.MixerAddress)
	if l > 0 {
		n += 2 + l + sovConfig(uint64(l))
	}
	if m.OutboundTrafficPolicy != nil {
		l = m.OutboundTrafficPolicy.Size()
		n += 2 + l + sovConfig(uint64(l))
	}
	if m.EnableClientSidePolicyCheck {
		n += 3
	}
	l = len(m.SdsUdsPath)
	if l > 0 {
		n += 2 + l + sovConfig(uint64(l))
	}
	if m.SdsRefreshDelay != nil {
		l = m.SdsRefreshDelay.Size()
		n += 2 + l + sovConfig(uint64(l))
	}
	if len(m.ConfigSources) > 0 {
		for _, e := range m.ConfigSources {
			l = e.Size()
			n += 2 + l + sovConfig(uint64(l))
		}
	}
	if m.EnableSdsTokenMount {
		n += 3
	}
	l = len(m.AccessLogFormat)
	if l > 0 {
		n += 2 + l + sovConfig(uint64(l))
	}
	if m.PolicyCheckFailOpen {
		n += 3
	}
	l = len(m.TrustDomain)
	if l > 0 {
		n += 2 + l + sovConfig(uint64(l))
	}
	if m.AccessLogEncoding != 0 {
		n += 2 + sovConfig(uint64(m.AccessLogEncoding))
	}
	if m.TcpKeepalive != nil {
		l = m.TcpKeepalive.Size()
		n += 2 + l + sovConfig(uint64(l))
	}
	if m.SdsUseK8SSaJwt {
		n += 3
	}
	if m.SidecarToTelemetrySessionAffinity {
		n += 3
	}
	return n
}

func (m *MeshConfig_OutboundTrafficPolicy) Size() (n int) {
	var l int
	_ = l
	if m.Mode != 0 {
		n += 1 + sovConfig(uint64(m.Mode))
	}
	return n
}

func (m *ConfigSource) Size() (n int) {
	var l int
	_ = l
	l = len(m.Address)
	if l > 0 {
		n += 1 + l + sovConfig(uint64(l))
	}
	if m.TlsSettings != nil {
		l = m.TlsSettings.Size()
		n += 1 + l + sovConfig(uint64(l))
	}
	return n
}

func sovConfig(x uint64) (n int) {
	for {
		n++
		x >>= 7
		if x == 0 {
			break
		}
	}
	return n
}
func sozConfig(x uint64) (n int) {
	return sovConfig(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *MeshConfig) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowConfig
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: MeshConfig: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MeshConfig: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MixerCheckServer", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowConfig
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthConfig
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.MixerCheckServer = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MixerReportServer", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowConfig
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthConfig
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.MixerReportServer = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field DisablePolicyChecks", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowConfig
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.DisablePolicyChecks = bool(v != 0)
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ProxyListenPort", wireType)
			}
			m.ProxyListenPort = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowConfig
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ProxyListenPort |= (int32(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ProxyHttpPort", wireType)
			}
			m.ProxyHttpPort = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowConfig
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ProxyHttpPort |= (int32(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ConnectTimeout", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowConfig
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthConfig
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ConnectTimeout == nil {
				m.ConnectTimeout = &google_protobuf.Duration{}
			}
			if err := m.ConnectTimeout.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field IngressClass", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowConfig
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthConfig
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.IngressClass = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field IngressService", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowConfig
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthConfig
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.IngressService = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 9:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field IngressControllerMode", wireType)
			}
			m.IngressControllerMode = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowConfig
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.IngressControllerMode |= (MeshConfig_IngressControllerMode(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 10:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field AuthPolicy", wireType)
			}
			m.AuthPolicy = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowConfig
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.AuthPolicy |= (MeshConfig_AuthPolicy(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 11:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RdsRefreshDelay", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowConfig
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthConfig
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.RdsRefreshDelay == nil {
				m.RdsRefreshDelay = &google_protobuf.Duration{}
			}
			if err := m.RdsRefreshDelay.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 12:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field EnableTracing", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowConfig
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.EnableTracing = bool(v != 0)
		case 13:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field AccessLogFile", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowConfig
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthConfig
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.AccessLogFile = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 14:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DefaultConfig", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowConfig
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthConfig
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.DefaultConfig == nil {
				m.DefaultConfig = &ProxyConfig{}
			}
			if err := m.DefaultConfig.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 16:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MixerAddress", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowConfig
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthConfig
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.MixerAddress = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 17:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field OutboundTrafficPolicy", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowConfig
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthConfig
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.OutboundTrafficPolicy == nil {
				m.OutboundTrafficPolicy = &MeshConfig_OutboundTrafficPolicy{}
			}
			if err := m.OutboundTrafficPolicy.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 19:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field EnableClientSidePolicyCheck", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowConfig
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.EnableClientSidePolicyCheck = bool(v != 0)
		case 20:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SdsUdsPath", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowConfig
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthConfig
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.SdsUdsPath = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 21:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SdsRefreshDelay", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowConfig
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthConfig
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.SdsRefreshDelay == nil {
				m.SdsRefreshDelay = &google_protobuf.Duration{}
			}
			if err := m.SdsRefreshDelay.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 22:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ConfigSources", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowConfig
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthConfig
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ConfigSources = append(m.ConfigSources, &ConfigSource{})
			if err := m.ConfigSources[len(m.ConfigSources)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 23:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field EnableSdsTokenMount", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowConfig
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.EnableSdsTokenMount = bool(v != 0)
		case 24:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field AccessLogFormat", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowConfig
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthConfig
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.AccessLogFormat = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 25:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field PolicyCheckFailOpen", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowConfig
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.PolicyCheckFailOpen = bool(v != 0)
		case 26:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TrustDomain", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowConfig
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthConfig
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.TrustDomain = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 27:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field AccessLogEncoding", wireType)
			}
			m.AccessLogEncoding = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowConfig
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.AccessLogEncoding |= (MeshConfig_AccessLogEncoding(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 28:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TcpKeepalive", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowConfig
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthConfig
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.TcpKeepalive == nil {
				m.TcpKeepalive = &istio_networking_v1alpha33.ConnectionPoolSettings_TCPSettings_TcpKeepalive{}
			}
			if err := m.TcpKeepalive.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 29:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field SdsUseK8SSaJwt", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowConfig
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.SdsUseK8SSaJwt = bool(v != 0)
		case 30:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field SidecarToTelemetrySessionAffinity", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowConfig
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.SidecarToTelemetrySessionAffinity = bool(v != 0)
		default:
			iNdEx = preIndex
			skippy, err := skipConfig(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthConfig
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MeshConfig_OutboundTrafficPolicy) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowConfig
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: OutboundTrafficPolicy: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: OutboundTrafficPolicy: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Mode", wireType)
			}
			m.Mode = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowConfig
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Mode |= (MeshConfig_OutboundTrafficPolicy_Mode(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipConfig(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthConfig
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ConfigSource) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowConfig
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ConfigSource: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ConfigSource: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Address", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowConfig
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthConfig
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Address = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TlsSettings", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowConfig
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthConfig
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.TlsSettings == nil {
				m.TlsSettings = &istio_networking_v1alpha33.TLSSettings{}
			}
			if err := m.TlsSettings.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipConfig(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthConfig
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func skipConfig(dAtA []byte) (n int, err error) {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return 0, ErrIntOverflowConfig
			}
			if iNdEx >= l {
				return 0, io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		wireType := int(wire & 0x7)
		switch wireType {
		case 0:
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 0, ErrIntOverflowConfig
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				iNdEx++
				if dAtA[iNdEx-1] < 0x80 {
					break
				}
			}
			return iNdEx, nil
		case 1:
			iNdEx += 8
			return iNdEx, nil
		case 2:
			var length int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 0, ErrIntOverflowConfig
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				length |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			iNdEx += length
			if length < 0 {
				return 0, ErrInvalidLengthConfig
			}
			return iNdEx, nil
		case 3:
			for {
				var innerWire uint64
				var start int = iNdEx
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return 0, ErrIntOverflowConfig
					}
					if iNdEx >= l {
						return 0, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					innerWire |= (uint64(b) & 0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				innerWireType := int(innerWire & 0x7)
				if innerWireType == 4 {
					break
				}
				next, err := skipConfig(dAtA[start:])
				if err != nil {
					return 0, err
				}
				iNdEx = start + next
			}
			return iNdEx, nil
		case 4:
			return iNdEx, nil
		case 5:
			iNdEx += 4
			return iNdEx, nil
		default:
			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
		}
	}
	panic("unreachable")
}

var (
	ErrInvalidLengthConfig = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowConfig   = fmt.Errorf("proto: integer overflow")
)

func init() { proto.RegisterFile("mesh/v1alpha1/config.proto", fileDescriptorConfig) }

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