service.pb.yarpc.go

// The MIT License (MIT)
// 
// Copyright (c) 2021 Uber Technologies, Inc.
// 
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
// 
// The above copyright notice and this permission notice shall be included in all
// copies or substantial portions of the Software.
// 
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
// SOFTWARE.

// Code generated by protoc-gen-yarpc-go. DO NOT EDIT.
// source: uber/cadence/admin/v1/service.proto

package adminv1

import (
	"context"
	"io/ioutil"
	"reflect"

	"github.com/gogo/protobuf/jsonpb"
	"github.com/gogo/protobuf/proto"
	"go.uber.org/fx"
	"go.uber.org/yarpc"
	"go.uber.org/yarpc/api/transport"
	"go.uber.org/yarpc/api/x/restriction"
	"go.uber.org/yarpc/encoding/protobuf"
	"go.uber.org/yarpc/encoding/protobuf/reflection"
)

var _ = ioutil.NopCloser

// AdminAPIYARPCClient is the YARPC client-side interface for the AdminAPI service.
type AdminAPIYARPCClient interface {
	DescribeWorkflowExecution(context.Context, *DescribeWorkflowExecutionRequest, ...yarpc.CallOption) (*DescribeWorkflowExecutionResponse, error)
	DescribeHistoryHost(context.Context, *DescribeHistoryHostRequest, ...yarpc.CallOption) (*DescribeHistoryHostResponse, error)
	DescribeShardDistribution(context.Context, *DescribeShardDistributionRequest, ...yarpc.CallOption) (*DescribeShardDistributionResponse, error)
	CloseShard(context.Context, *CloseShardRequest, ...yarpc.CallOption) (*CloseShardResponse, error)
	RemoveTask(context.Context, *RemoveTaskRequest, ...yarpc.CallOption) (*RemoveTaskResponse, error)
	ResetQueue(context.Context, *ResetQueueRequest, ...yarpc.CallOption) (*ResetQueueResponse, error)
	DescribeQueue(context.Context, *DescribeQueueRequest, ...yarpc.CallOption) (*DescribeQueueResponse, error)
	GetWorkflowExecutionRawHistoryV2(context.Context, *GetWorkflowExecutionRawHistoryV2Request, ...yarpc.CallOption) (*GetWorkflowExecutionRawHistoryV2Response, error)
	GetReplicationMessages(context.Context, *GetReplicationMessagesRequest, ...yarpc.CallOption) (*GetReplicationMessagesResponse, error)
	GetDLQReplicationMessages(context.Context, *GetDLQReplicationMessagesRequest, ...yarpc.CallOption) (*GetDLQReplicationMessagesResponse, error)
	GetDomainReplicationMessages(context.Context, *GetDomainReplicationMessagesRequest, ...yarpc.CallOption) (*GetDomainReplicationMessagesResponse, error)
	ReapplyEvents(context.Context, *ReapplyEventsRequest, ...yarpc.CallOption) (*ReapplyEventsResponse, error)
	AddSearchAttribute(context.Context, *AddSearchAttributeRequest, ...yarpc.CallOption) (*AddSearchAttributeResponse, error)
	DescribeCluster(context.Context, *DescribeClusterRequest, ...yarpc.CallOption) (*DescribeClusterResponse, error)
	CountDLQMessages(context.Context, *CountDLQMessagesRequest, ...yarpc.CallOption) (*CountDLQMessagesResponse, error)
	ReadDLQMessages(context.Context, *ReadDLQMessagesRequest, ...yarpc.CallOption) (*ReadDLQMessagesResponse, error)
	PurgeDLQMessages(context.Context, *PurgeDLQMessagesRequest, ...yarpc.CallOption) (*PurgeDLQMessagesResponse, error)
	MergeDLQMessages(context.Context, *MergeDLQMessagesRequest, ...yarpc.CallOption) (*MergeDLQMessagesResponse, error)
	RefreshWorkflowTasks(context.Context, *RefreshWorkflowTasksRequest, ...yarpc.CallOption) (*RefreshWorkflowTasksResponse, error)
	ResendReplicationTasks(context.Context, *ResendReplicationTasksRequest, ...yarpc.CallOption) (*ResendReplicationTasksResponse, error)
	GetCrossClusterTasks(context.Context, *GetCrossClusterTasksRequest, ...yarpc.CallOption) (*GetCrossClusterTasksResponse, error)
	RespondCrossClusterTasksCompleted(context.Context, *RespondCrossClusterTasksCompletedRequest, ...yarpc.CallOption) (*RespondCrossClusterTasksCompletedResponse, error)
	GetDynamicConfig(context.Context, *GetDynamicConfigRequest, ...yarpc.CallOption) (*GetDynamicConfigResponse, error)
	UpdateDynamicConfig(context.Context, *UpdateDynamicConfigRequest, ...yarpc.CallOption) (*UpdateDynamicConfigResponse, error)
	RestoreDynamicConfig(context.Context, *RestoreDynamicConfigRequest, ...yarpc.CallOption) (*RestoreDynamicConfigResponse, error)
	ListDynamicConfig(context.Context, *ListDynamicConfigRequest, ...yarpc.CallOption) (*ListDynamicConfigResponse, error)
	DeleteWorkflow(context.Context, *DeleteWorkflowRequest, ...yarpc.CallOption) (*DeleteWorkflowResponse, error)
	MaintainCorruptWorkflow(context.Context, *MaintainCorruptWorkflowRequest, ...yarpc.CallOption) (*MaintainCorruptWorkflowResponse, error)
	GetGlobalIsolationGroups(context.Context, *GetGlobalIsolationGroupsRequest, ...yarpc.CallOption) (*GetGlobalIsolationGroupsResponse, error)
	UpdateGlobalIsolationGroups(context.Context, *UpdateGlobalIsolationGroupsRequest, ...yarpc.CallOption) (*UpdateGlobalIsolationGroupsResponse, error)
	GetDomainIsolationGroups(context.Context, *GetDomainIsolationGroupsRequest, ...yarpc.CallOption) (*GetDomainIsolationGroupsResponse, error)
	UpdateDomainIsolationGroups(context.Context, *UpdateDomainIsolationGroupsRequest, ...yarpc.CallOption) (*UpdateDomainIsolationGroupsResponse, error)
	GetDomainAsyncWorkflowConfiguraton(context.Context, *GetDomainAsyncWorkflowConfiguratonRequest, ...yarpc.CallOption) (*GetDomainAsyncWorkflowConfiguratonResponse, error)
	UpdateDomainAsyncWorkflowConfiguraton(context.Context, *UpdateDomainAsyncWorkflowConfiguratonRequest, ...yarpc.CallOption) (*UpdateDomainAsyncWorkflowConfiguratonResponse, error)
}

func newAdminAPIYARPCClient(clientConfig transport.ClientConfig, anyResolver jsonpb.AnyResolver, options ...protobuf.ClientOption) AdminAPIYARPCClient {
	return &_AdminAPIYARPCCaller{protobuf.NewStreamClient(
		protobuf.ClientParams{
			ServiceName:  "uber.cadence.admin.v1.AdminAPI",
			ClientConfig: clientConfig,
			AnyResolver:  anyResolver,
			Options:      options,
		},
	)}
}

// NewAdminAPIYARPCClient builds a new YARPC client for the AdminAPI service.
func NewAdminAPIYARPCClient(clientConfig transport.ClientConfig, options ...protobuf.ClientOption) AdminAPIYARPCClient {
	return newAdminAPIYARPCClient(clientConfig, nil, options...)
}

// AdminAPIYARPCServer is the YARPC server-side interface for the AdminAPI service.
type AdminAPIYARPCServer interface {
	DescribeWorkflowExecution(context.Context, *DescribeWorkflowExecutionRequest) (*DescribeWorkflowExecutionResponse, error)
	DescribeHistoryHost(context.Context, *DescribeHistoryHostRequest) (*DescribeHistoryHostResponse, error)
	DescribeShardDistribution(context.Context, *DescribeShardDistributionRequest) (*DescribeShardDistributionResponse, error)
	CloseShard(context.Context, *CloseShardRequest) (*CloseShardResponse, error)
	RemoveTask(context.Context, *RemoveTaskRequest) (*RemoveTaskResponse, error)
	ResetQueue(context.Context, *ResetQueueRequest) (*ResetQueueResponse, error)
	DescribeQueue(context.Context, *DescribeQueueRequest) (*DescribeQueueResponse, error)
	GetWorkflowExecutionRawHistoryV2(context.Context, *GetWorkflowExecutionRawHistoryV2Request) (*GetWorkflowExecutionRawHistoryV2Response, error)
	GetReplicationMessages(context.Context, *GetReplicationMessagesRequest) (*GetReplicationMessagesResponse, error)
	GetDLQReplicationMessages(context.Context, *GetDLQReplicationMessagesRequest) (*GetDLQReplicationMessagesResponse, error)
	GetDomainReplicationMessages(context.Context, *GetDomainReplicationMessagesRequest) (*GetDomainReplicationMessagesResponse, error)
	ReapplyEvents(context.Context, *ReapplyEventsRequest) (*ReapplyEventsResponse, error)
	AddSearchAttribute(context.Context, *AddSearchAttributeRequest) (*AddSearchAttributeResponse, error)
	DescribeCluster(context.Context, *DescribeClusterRequest) (*DescribeClusterResponse, error)
	CountDLQMessages(context.Context, *CountDLQMessagesRequest) (*CountDLQMessagesResponse, error)
	ReadDLQMessages(context.Context, *ReadDLQMessagesRequest) (*ReadDLQMessagesResponse, error)
	PurgeDLQMessages(context.Context, *PurgeDLQMessagesRequest) (*PurgeDLQMessagesResponse, error)
	MergeDLQMessages(context.Context, *MergeDLQMessagesRequest) (*MergeDLQMessagesResponse, error)
	RefreshWorkflowTasks(context.Context, *RefreshWorkflowTasksRequest) (*RefreshWorkflowTasksResponse, error)
	ResendReplicationTasks(context.Context, *ResendReplicationTasksRequest) (*ResendReplicationTasksResponse, error)
	GetCrossClusterTasks(context.Context, *GetCrossClusterTasksRequest) (*GetCrossClusterTasksResponse, error)
	RespondCrossClusterTasksCompleted(context.Context, *RespondCrossClusterTasksCompletedRequest) (*RespondCrossClusterTasksCompletedResponse, error)
	GetDynamicConfig(context.Context, *GetDynamicConfigRequest) (*GetDynamicConfigResponse, error)
	UpdateDynamicConfig(context.Context, *UpdateDynamicConfigRequest) (*UpdateDynamicConfigResponse, error)
	RestoreDynamicConfig(context.Context, *RestoreDynamicConfigRequest) (*RestoreDynamicConfigResponse, error)
	ListDynamicConfig(context.Context, *ListDynamicConfigRequest) (*ListDynamicConfigResponse, error)
	DeleteWorkflow(context.Context, *DeleteWorkflowRequest) (*DeleteWorkflowResponse, error)
	MaintainCorruptWorkflow(context.Context, *MaintainCorruptWorkflowRequest) (*MaintainCorruptWorkflowResponse, error)
	GetGlobalIsolationGroups(context.Context, *GetGlobalIsolationGroupsRequest) (*GetGlobalIsolationGroupsResponse, error)
	UpdateGlobalIsolationGroups(context.Context, *UpdateGlobalIsolationGroupsRequest) (*UpdateGlobalIsolationGroupsResponse, error)
	GetDomainIsolationGroups(context.Context, *GetDomainIsolationGroupsRequest) (*GetDomainIsolationGroupsResponse, error)
	UpdateDomainIsolationGroups(context.Context, *UpdateDomainIsolationGroupsRequest) (*UpdateDomainIsolationGroupsResponse, error)
	GetDomainAsyncWorkflowConfiguraton(context.Context, *GetDomainAsyncWorkflowConfiguratonRequest) (*GetDomainAsyncWorkflowConfiguratonResponse, error)
	UpdateDomainAsyncWorkflowConfiguraton(context.Context, *UpdateDomainAsyncWorkflowConfiguratonRequest) (*UpdateDomainAsyncWorkflowConfiguratonResponse, error)
}

type buildAdminAPIYARPCProceduresParams struct {
	Server      AdminAPIYARPCServer
	AnyResolver jsonpb.AnyResolver
}

func buildAdminAPIYARPCProcedures(params buildAdminAPIYARPCProceduresParams) []transport.Procedure {
	handler := &_AdminAPIYARPCHandler{params.Server}
	return protobuf.BuildProcedures(
		protobuf.BuildProceduresParams{
			ServiceName: "uber.cadence.admin.v1.AdminAPI",
			UnaryHandlerParams: []protobuf.BuildProceduresUnaryHandlerParams{
				{
					MethodName: "DescribeWorkflowExecution",
					Handler: protobuf.NewUnaryHandler(
						protobuf.UnaryHandlerParams{
							Handle:      handler.DescribeWorkflowExecution,
							NewRequest:  newAdminAPIServiceDescribeWorkflowExecutionYARPCRequest,
							AnyResolver: params.AnyResolver,
						},
					),
				},
				{
					MethodName: "DescribeHistoryHost",
					Handler: protobuf.NewUnaryHandler(
						protobuf.UnaryHandlerParams{
							Handle:      handler.DescribeHistoryHost,
							NewRequest:  newAdminAPIServiceDescribeHistoryHostYARPCRequest,
							AnyResolver: params.AnyResolver,
						},
					),
				},
				{
					MethodName: "DescribeShardDistribution",
					Handler: protobuf.NewUnaryHandler(
						protobuf.UnaryHandlerParams{
							Handle:      handler.DescribeShardDistribution,
							NewRequest:  newAdminAPIServiceDescribeShardDistributionYARPCRequest,
							AnyResolver: params.AnyResolver,
						},
					),
				},
				{
					MethodName: "CloseShard",
					Handler: protobuf.NewUnaryHandler(
						protobuf.UnaryHandlerParams{
							Handle:      handler.CloseShard,
							NewRequest:  newAdminAPIServiceCloseShardYARPCRequest,
							AnyResolver: params.AnyResolver,
						},
					),
				},
				{
					MethodName: "RemoveTask",
					Handler: protobuf.NewUnaryHandler(
						protobuf.UnaryHandlerParams{
							Handle:      handler.RemoveTask,
							NewRequest:  newAdminAPIServiceRemoveTaskYARPCRequest,
							AnyResolver: params.AnyResolver,
						},
					),
				},
				{
					MethodName: "ResetQueue",
					Handler: protobuf.NewUnaryHandler(
						protobuf.UnaryHandlerParams{
							Handle:      handler.ResetQueue,
							NewRequest:  newAdminAPIServiceResetQueueYARPCRequest,
							AnyResolver: params.AnyResolver,
						},
					),
				},
				{
					MethodName: "DescribeQueue",
					Handler: protobuf.NewUnaryHandler(
						protobuf.UnaryHandlerParams{
							Handle:      handler.DescribeQueue,
							NewRequest:  newAdminAPIServiceDescribeQueueYARPCRequest,
							AnyResolver: params.AnyResolver,
						},
					),
				},
				{
					MethodName: "GetWorkflowExecutionRawHistoryV2",
					Handler: protobuf.NewUnaryHandler(
						protobuf.UnaryHandlerParams{
							Handle:      handler.GetWorkflowExecutionRawHistoryV2,
							NewRequest:  newAdminAPIServiceGetWorkflowExecutionRawHistoryV2YARPCRequest,
							AnyResolver: params.AnyResolver,
						},
					),
				},
				{
					MethodName: "GetReplicationMessages",
					Handler: protobuf.NewUnaryHandler(
						protobuf.UnaryHandlerParams{
							Handle:      handler.GetReplicationMessages,
							NewRequest:  newAdminAPIServiceGetReplicationMessagesYARPCRequest,
							AnyResolver: params.AnyResolver,
						},
					),
				},
				{
					MethodName: "GetDLQReplicationMessages",
					Handler: protobuf.NewUnaryHandler(
						protobuf.UnaryHandlerParams{
							Handle:      handler.GetDLQReplicationMessages,
							NewRequest:  newAdminAPIServiceGetDLQReplicationMessagesYARPCRequest,
							AnyResolver: params.AnyResolver,
						},
					),
				},
				{
					MethodName: "GetDomainReplicationMessages",
					Handler: protobuf.NewUnaryHandler(
						protobuf.UnaryHandlerParams{
							Handle:      handler.GetDomainReplicationMessages,
							NewRequest:  newAdminAPIServiceGetDomainReplicationMessagesYARPCRequest,
							AnyResolver: params.AnyResolver,
						},
					),
				},
				{
					MethodName: "ReapplyEvents",
					Handler: protobuf.NewUnaryHandler(
						protobuf.UnaryHandlerParams{
							Handle:      handler.ReapplyEvents,
							NewRequest:  newAdminAPIServiceReapplyEventsYARPCRequest,
							AnyResolver: params.AnyResolver,
						},
					),
				},
				{
					MethodName: "AddSearchAttribute",
					Handler: protobuf.NewUnaryHandler(
						protobuf.UnaryHandlerParams{
							Handle:      handler.AddSearchAttribute,
							NewRequest:  newAdminAPIServiceAddSearchAttributeYARPCRequest,
							AnyResolver: params.AnyResolver,
						},
					),
				},
				{
					MethodName: "DescribeCluster",
					Handler: protobuf.NewUnaryHandler(
						protobuf.UnaryHandlerParams{
							Handle:      handler.DescribeCluster,
							NewRequest:  newAdminAPIServiceDescribeClusterYARPCRequest,
							AnyResolver: params.AnyResolver,
						},
					),
				},
				{
					MethodName: "CountDLQMessages",
					Handler: protobuf.NewUnaryHandler(
						protobuf.UnaryHandlerParams{
							Handle:      handler.CountDLQMessages,
							NewRequest:  newAdminAPIServiceCountDLQMessagesYARPCRequest,
							AnyResolver: params.AnyResolver,
						},
					),
				},
				{
					MethodName: "ReadDLQMessages",
					Handler: protobuf.NewUnaryHandler(
						protobuf.UnaryHandlerParams{
							Handle:      handler.ReadDLQMessages,
							NewRequest:  newAdminAPIServiceReadDLQMessagesYARPCRequest,
							AnyResolver: params.AnyResolver,
						},
					),
				},
				{
					MethodName: "PurgeDLQMessages",
					Handler: protobuf.NewUnaryHandler(
						protobuf.UnaryHandlerParams{
							Handle:      handler.PurgeDLQMessages,
							NewRequest:  newAdminAPIServicePurgeDLQMessagesYARPCRequest,
							AnyResolver: params.AnyResolver,
						},
					),
				},
				{
					MethodName: "MergeDLQMessages",
					Handler: protobuf.NewUnaryHandler(
						protobuf.UnaryHandlerParams{
							Handle:      handler.MergeDLQMessages,
							NewRequest:  newAdminAPIServiceMergeDLQMessagesYARPCRequest,
							AnyResolver: params.AnyResolver,
						},
					),
				},
				{
					MethodName: "RefreshWorkflowTasks",
					Handler: protobuf.NewUnaryHandler(
						protobuf.UnaryHandlerParams{
							Handle:      handler.RefreshWorkflowTasks,
							NewRequest:  newAdminAPIServiceRefreshWorkflowTasksYARPCRequest,
							AnyResolver: params.AnyResolver,
						},
					),
				},
				{
					MethodName: "ResendReplicationTasks",
					Handler: protobuf.NewUnaryHandler(
						protobuf.UnaryHandlerParams{
							Handle:      handler.ResendReplicationTasks,
							NewRequest:  newAdminAPIServiceResendReplicationTasksYARPCRequest,
							AnyResolver: params.AnyResolver,
						},
					),
				},
				{
					MethodName: "GetCrossClusterTasks",
					Handler: protobuf.NewUnaryHandler(
						protobuf.UnaryHandlerParams{
							Handle:      handler.GetCrossClusterTasks,
							NewRequest:  newAdminAPIServiceGetCrossClusterTasksYARPCRequest,
							AnyResolver: params.AnyResolver,
						},
					),
				},
				{
					MethodName: "RespondCrossClusterTasksCompleted",
					Handler: protobuf.NewUnaryHandler(
						protobuf.UnaryHandlerParams{
							Handle:      handler.RespondCrossClusterTasksCompleted,
							NewRequest:  newAdminAPIServiceRespondCrossClusterTasksCompletedYARPCRequest,
							AnyResolver: params.AnyResolver,
						},
					),
				},
				{
					MethodName: "GetDynamicConfig",
					Handler: protobuf.NewUnaryHandler(
						protobuf.UnaryHandlerParams{
							Handle:      handler.GetDynamicConfig,
							NewRequest:  newAdminAPIServiceGetDynamicConfigYARPCRequest,
							AnyResolver: params.AnyResolver,
						},
					),
				},
				{
					MethodName: "UpdateDynamicConfig",
					Handler: protobuf.NewUnaryHandler(
						protobuf.UnaryHandlerParams{
							Handle:      handler.UpdateDynamicConfig,
							NewRequest:  newAdminAPIServiceUpdateDynamicConfigYARPCRequest,
							AnyResolver: params.AnyResolver,
						},
					),
				},
				{
					MethodName: "RestoreDynamicConfig",
					Handler: protobuf.NewUnaryHandler(
						protobuf.UnaryHandlerParams{
							Handle:      handler.RestoreDynamicConfig,
							NewRequest:  newAdminAPIServiceRestoreDynamicConfigYARPCRequest,
							AnyResolver: params.AnyResolver,
						},
					),
				},
				{
					MethodName: "ListDynamicConfig",
					Handler: protobuf.NewUnaryHandler(
						protobuf.UnaryHandlerParams{
							Handle:      handler.ListDynamicConfig,
							NewRequest:  newAdminAPIServiceListDynamicConfigYARPCRequest,
							AnyResolver: params.AnyResolver,
						},
					),
				},
				{
					MethodName: "DeleteWorkflow",
					Handler: protobuf.NewUnaryHandler(
						protobuf.UnaryHandlerParams{
							Handle:      handler.DeleteWorkflow,
							NewRequest:  newAdminAPIServiceDeleteWorkflowYARPCRequest,
							AnyResolver: params.AnyResolver,
						},
					),
				},
				{
					MethodName: "MaintainCorruptWorkflow",
					Handler: protobuf.NewUnaryHandler(
						protobuf.UnaryHandlerParams{
							Handle:      handler.MaintainCorruptWorkflow,
							NewRequest:  newAdminAPIServiceMaintainCorruptWorkflowYARPCRequest,
							AnyResolver: params.AnyResolver,
						},
					),
				},
				{
					MethodName: "GetGlobalIsolationGroups",
					Handler: protobuf.NewUnaryHandler(
						protobuf.UnaryHandlerParams{
							Handle:      handler.GetGlobalIsolationGroups,
							NewRequest:  newAdminAPIServiceGetGlobalIsolationGroupsYARPCRequest,
							AnyResolver: params.AnyResolver,
						},
					),
				},
				{
					MethodName: "UpdateGlobalIsolationGroups",
					Handler: protobuf.NewUnaryHandler(
						protobuf.UnaryHandlerParams{
							Handle:      handler.UpdateGlobalIsolationGroups,
							NewRequest:  newAdminAPIServiceUpdateGlobalIsolationGroupsYARPCRequest,
							AnyResolver: params.AnyResolver,
						},
					),
				},
				{
					MethodName: "GetDomainIsolationGroups",
					Handler: protobuf.NewUnaryHandler(
						protobuf.UnaryHandlerParams{
							Handle:      handler.GetDomainIsolationGroups,
							NewRequest:  newAdminAPIServiceGetDomainIsolationGroupsYARPCRequest,
							AnyResolver: params.AnyResolver,
						},
					),
				},
				{
					MethodName: "UpdateDomainIsolationGroups",
					Handler: protobuf.NewUnaryHandler(
						protobuf.UnaryHandlerParams{
							Handle:      handler.UpdateDomainIsolationGroups,
							NewRequest:  newAdminAPIServiceUpdateDomainIsolationGroupsYARPCRequest,
							AnyResolver: params.AnyResolver,
						},
					),
				},
				{
					MethodName: "GetDomainAsyncWorkflowConfiguraton",
					Handler: protobuf.NewUnaryHandler(
						protobuf.UnaryHandlerParams{
							Handle:      handler.GetDomainAsyncWorkflowConfiguraton,
							NewRequest:  newAdminAPIServiceGetDomainAsyncWorkflowConfiguratonYARPCRequest,
							AnyResolver: params.AnyResolver,
						},
					),
				},
				{
					MethodName: "UpdateDomainAsyncWorkflowConfiguraton",
					Handler: protobuf.NewUnaryHandler(
						protobuf.UnaryHandlerParams{
							Handle:      handler.UpdateDomainAsyncWorkflowConfiguraton,
							NewRequest:  newAdminAPIServiceUpdateDomainAsyncWorkflowConfiguratonYARPCRequest,
							AnyResolver: params.AnyResolver,
						},
					),
				},
			},
			OnewayHandlerParams: []protobuf.BuildProceduresOnewayHandlerParams{},
			StreamHandlerParams: []protobuf.BuildProceduresStreamHandlerParams{},
		},
	)
}

// BuildAdminAPIYARPCProcedures prepares an implementation of the AdminAPI service for YARPC registration.
func BuildAdminAPIYARPCProcedures(server AdminAPIYARPCServer) []transport.Procedure {
	return buildAdminAPIYARPCProcedures(buildAdminAPIYARPCProceduresParams{Server: server})
}

// FxAdminAPIYARPCClientParams defines the input
// for NewFxAdminAPIYARPCClient. It provides the
// paramaters to get a AdminAPIYARPCClient in an
// Fx application.
type FxAdminAPIYARPCClientParams struct {
	fx.In

	Provider    yarpc.ClientConfig
	AnyResolver jsonpb.AnyResolver  `name:"yarpcfx" optional:"true"`
	Restriction restriction.Checker `optional:"true"`
}

// FxAdminAPIYARPCClientResult defines the output
// of NewFxAdminAPIYARPCClient. It provides a
// AdminAPIYARPCClient to an Fx application.
type FxAdminAPIYARPCClientResult struct {
	fx.Out

	Client AdminAPIYARPCClient

	// We are using an fx.Out struct here instead of just returning a client
	// so that we can add more values or add named versions of the client in
	// the future without breaking any existing code.
}

// NewFxAdminAPIYARPCClient provides a AdminAPIYARPCClient
// to an Fx application using the given name for routing.
//
//	fx.Provide(
//	  adminv1.NewFxAdminAPIYARPCClient("service-name"),
//	  ...
//	)
func NewFxAdminAPIYARPCClient(name string, options ...protobuf.ClientOption) interface{} {
	return func(params FxAdminAPIYARPCClientParams) FxAdminAPIYARPCClientResult {
		cc := params.Provider.ClientConfig(name)

		if params.Restriction != nil {
			if namer, ok := cc.GetUnaryOutbound().(transport.Namer); ok {
				if err := params.Restriction.Check(protobuf.Encoding, namer.TransportName()); err != nil {
					panic(err.Error())
				}
			}
		}

		return FxAdminAPIYARPCClientResult{
			Client: newAdminAPIYARPCClient(cc, params.AnyResolver, options...),
		}
	}
}

// FxAdminAPIYARPCProceduresParams defines the input
// for NewFxAdminAPIYARPCProcedures. It provides the
// paramaters to get AdminAPIYARPCServer procedures in an
// Fx application.
type FxAdminAPIYARPCProceduresParams struct {
	fx.In

	Server      AdminAPIYARPCServer
	AnyResolver jsonpb.AnyResolver `name:"yarpcfx" optional:"true"`
}

// FxAdminAPIYARPCProceduresResult defines the output
// of NewFxAdminAPIYARPCProcedures. It provides
// AdminAPIYARPCServer procedures to an Fx application.
//
// The procedures are provided to the "yarpcfx" value group.
// Dig 1.2 or newer must be used for this feature to work.
type FxAdminAPIYARPCProceduresResult struct {
	fx.Out

	Procedures     []transport.Procedure `group:"yarpcfx"`
	ReflectionMeta reflection.ServerMeta `group:"yarpcfx"`
}

// NewFxAdminAPIYARPCProcedures provides AdminAPIYARPCServer procedures to an Fx application.
// It expects a AdminAPIYARPCServer to be present in the container.
//
//	fx.Provide(
//	  adminv1.NewFxAdminAPIYARPCProcedures(),
//	  ...
//	)
func NewFxAdminAPIYARPCProcedures() interface{} {
	return func(params FxAdminAPIYARPCProceduresParams) FxAdminAPIYARPCProceduresResult {
		return FxAdminAPIYARPCProceduresResult{
			Procedures: buildAdminAPIYARPCProcedures(buildAdminAPIYARPCProceduresParams{
				Server:      params.Server,
				AnyResolver: params.AnyResolver,
			}),
			ReflectionMeta: reflection.ServerMeta{
				ServiceName:     "uber.cadence.admin.v1.AdminAPI",
				FileDescriptors: yarpcFileDescriptorClosurec6fc96d64a8b67fd,
			},
		}
	}
}

type _AdminAPIYARPCCaller struct {
	streamClient protobuf.StreamClient
}

func (c *_AdminAPIYARPCCaller) DescribeWorkflowExecution(ctx context.Context, request *DescribeWorkflowExecutionRequest, options ...yarpc.CallOption) (*DescribeWorkflowExecutionResponse, error) {
	responseMessage, err := c.streamClient.Call(ctx, "DescribeWorkflowExecution", request, newAdminAPIServiceDescribeWorkflowExecutionYARPCResponse, options...)
	if responseMessage == nil {
		return nil, err
	}
	response, ok := responseMessage.(*DescribeWorkflowExecutionResponse)
	if !ok {
		return nil, protobuf.CastError(emptyAdminAPIServiceDescribeWorkflowExecutionYARPCResponse, responseMessage)
	}
	return response, err
}

func (c *_AdminAPIYARPCCaller) DescribeHistoryHost(ctx context.Context, request *DescribeHistoryHostRequest, options ...yarpc.CallOption) (*DescribeHistoryHostResponse, error) {
	responseMessage, err := c.streamClient.Call(ctx, "DescribeHistoryHost", request, newAdminAPIServiceDescribeHistoryHostYARPCResponse, options...)
	if responseMessage == nil {
		return nil, err
	}
	response, ok := responseMessage.(*DescribeHistoryHostResponse)
	if !ok {
		return nil, protobuf.CastError(emptyAdminAPIServiceDescribeHistoryHostYARPCResponse, responseMessage)
	}
	return response, err
}

func (c *_AdminAPIYARPCCaller) DescribeShardDistribution(ctx context.Context, request *DescribeShardDistributionRequest, options ...yarpc.CallOption) (*DescribeShardDistributionResponse, error) {
	responseMessage, err := c.streamClient.Call(ctx, "DescribeShardDistribution", request, newAdminAPIServiceDescribeShardDistributionYARPCResponse, options...)
	if responseMessage == nil {
		return nil, err
	}
	response, ok := responseMessage.(*DescribeShardDistributionResponse)
	if !ok {
		return nil, protobuf.CastError(emptyAdminAPIServiceDescribeShardDistributionYARPCResponse, responseMessage)
	}
	return response, err
}

func (c *_AdminAPIYARPCCaller) CloseShard(ctx context.Context, request *CloseShardRequest, options ...yarpc.CallOption) (*CloseShardResponse, error) {
	responseMessage, err := c.streamClient.Call(ctx, "CloseShard", request, newAdminAPIServiceCloseShardYARPCResponse, options...)
	if responseMessage == nil {
		return nil, err
	}
	response, ok := responseMessage.(*CloseShardResponse)
	if !ok {
		return nil, protobuf.CastError(emptyAdminAPIServiceCloseShardYARPCResponse, responseMessage)
	}
	return response, err
}

func (c *_AdminAPIYARPCCaller) RemoveTask(ctx context.Context, request *RemoveTaskRequest, options ...yarpc.CallOption) (*RemoveTaskResponse, error) {
	responseMessage, err := c.streamClient.Call(ctx, "RemoveTask", request, newAdminAPIServiceRemoveTaskYARPCResponse, options...)
	if responseMessage == nil {
		return nil, err
	}
	response, ok := responseMessage.(*RemoveTaskResponse)
	if !ok {
		return nil, protobuf.CastError(emptyAdminAPIServiceRemoveTaskYARPCResponse, responseMessage)
	}
	return response, err
}

func (c *_AdminAPIYARPCCaller) ResetQueue(ctx context.Context, request *ResetQueueRequest, options ...yarpc.CallOption) (*ResetQueueResponse, error) {
	responseMessage, err := c.streamClient.Call(ctx, "ResetQueue", request, newAdminAPIServiceResetQueueYARPCResponse, options...)
	if responseMessage == nil {
		return nil, err
	}
	response, ok := responseMessage.(*ResetQueueResponse)
	if !ok {
		return nil, protobuf.CastError(emptyAdminAPIServiceResetQueueYARPCResponse, responseMessage)
	}
	return response, err
}

func (c *_AdminAPIYARPCCaller) DescribeQueue(ctx context.Context, request *DescribeQueueRequest, options ...yarpc.CallOption) (*DescribeQueueResponse, error) {
	responseMessage, err := c.streamClient.Call(ctx, "DescribeQueue", request, newAdminAPIServiceDescribeQueueYARPCResponse, options...)
	if responseMessage == nil {
		return nil, err
	}
	response, ok := responseMessage.(*DescribeQueueResponse)
	if !ok {
		return nil, protobuf.CastError(emptyAdminAPIServiceDescribeQueueYARPCResponse, responseMessage)
	}
	return response, err
}

func (c *_AdminAPIYARPCCaller) GetWorkflowExecutionRawHistoryV2(ctx context.Context, request *GetWorkflowExecutionRawHistoryV2Request, options ...yarpc.CallOption) (*GetWorkflowExecutionRawHistoryV2Response, error) {
	responseMessage, err := c.streamClient.Call(ctx, "GetWorkflowExecutionRawHistoryV2", request, newAdminAPIServiceGetWorkflowExecutionRawHistoryV2YARPCResponse, options...)
	if responseMessage == nil {
		return nil, err
	}
	response, ok := responseMessage.(*GetWorkflowExecutionRawHistoryV2Response)
	if !ok {
		return nil, protobuf.CastError(emptyAdminAPIServiceGetWorkflowExecutionRawHistoryV2YARPCResponse, responseMessage)
	}
	return response, err
}

func (c *_AdminAPIYARPCCaller) GetReplicationMessages(ctx context.Context, request *GetReplicationMessagesRequest, options ...yarpc.CallOption) (*GetReplicationMessagesResponse, error) {
	responseMessage, err := c.streamClient.Call(ctx, "GetReplicationMessages", request, newAdminAPIServiceGetReplicationMessagesYARPCResponse, options...)
	if responseMessage == nil {
		return nil, err
	}
	response, ok := responseMessage.(*GetReplicationMessagesResponse)
	if !ok {
		return nil, protobuf.CastError(emptyAdminAPIServiceGetReplicationMessagesYARPCResponse, responseMessage)
	}
	return response, err
}

func (c *_AdminAPIYARPCCaller) GetDLQReplicationMessages(ctx context.Context, request *GetDLQReplicationMessagesRequest, options ...yarpc.CallOption) (*GetDLQReplicationMessagesResponse, error) {
	responseMessage, err := c.streamClient.Call(ctx, "GetDLQReplicationMessages", request, newAdminAPIServiceGetDLQReplicationMessagesYARPCResponse, options...)
	if responseMessage == nil {
		return nil, err
	}
	response, ok := responseMessage.(*GetDLQReplicationMessagesResponse)
	if !ok {
		return nil, protobuf.CastError(emptyAdminAPIServiceGetDLQReplicationMessagesYARPCResponse, responseMessage)
	}
	return response, err
}

func (c *_AdminAPIYARPCCaller) GetDomainReplicationMessages(ctx context.Context, request *GetDomainReplicationMessagesRequest, options ...yarpc.CallOption) (*GetDomainReplicationMessagesResponse, error) {
	responseMessage, err := c.streamClient.Call(ctx, "GetDomainReplicationMessages", request, newAdminAPIServiceGetDomainReplicationMessagesYARPCResponse, options...)
	if responseMessage == nil {
		return nil, err
	}
	response, ok := responseMessage.(*GetDomainReplicationMessagesResponse)
	if !ok {
		return nil, protobuf.CastError(emptyAdminAPIServiceGetDomainReplicationMessagesYARPCResponse, responseMessage)
	}
	return response, err
}

func (c *_AdminAPIYARPCCaller) ReapplyEvents(ctx context.Context, request *ReapplyEventsRequest, options ...yarpc.CallOption) (*ReapplyEventsResponse, error) {
	responseMessage, err := c.streamClient.Call(ctx, "ReapplyEvents", request, newAdminAPIServiceReapplyEventsYARPCResponse, options...)
	if responseMessage == nil {
		return nil, err
	}
	response, ok := responseMessage.(*ReapplyEventsResponse)
	if !ok {
		return nil, protobuf.CastError(emptyAdminAPIServiceReapplyEventsYARPCResponse, responseMessage)
	}
	return response, err
}

func (c *_AdminAPIYARPCCaller) AddSearchAttribute(ctx context.Context, request *AddSearchAttributeRequest, options ...yarpc.CallOption) (*AddSearchAttributeResponse, error) {
	responseMessage, err := c.streamClient.Call(ctx, "AddSearchAttribute", request, newAdminAPIServiceAddSearchAttributeYARPCResponse, options...)
	if responseMessage == nil {
		return nil, err
	}
	response, ok := responseMessage.(*AddSearchAttributeResponse)
	if !ok {
		return nil, protobuf.CastError(emptyAdminAPIServiceAddSearchAttributeYARPCResponse, responseMessage)
	}
	return response, err
}

func (c *_AdminAPIYARPCCaller) DescribeCluster(ctx context.Context, request *DescribeClusterRequest, options ...yarpc.CallOption) (*DescribeClusterResponse, error) {
	responseMessage, err := c.streamClient.Call(ctx, "DescribeCluster", request, newAdminAPIServiceDescribeClusterYARPCResponse, options...)
	if responseMessage == nil {
		return nil, err
	}
	response, ok := responseMessage.(*DescribeClusterResponse)
	if !ok {
		return nil, protobuf.CastError(emptyAdminAPIServiceDescribeClusterYARPCResponse, responseMessage)
	}
	return response, err
}

func (c *_AdminAPIYARPCCaller) CountDLQMessages(ctx context.Context, request *CountDLQMessagesRequest, options ...yarpc.CallOption) (*CountDLQMessagesResponse, error) {
	responseMessage, err := c.streamClient.Call(ctx, "CountDLQMessages", request, newAdminAPIServiceCountDLQMessagesYARPCResponse, options...)
	if responseMessage == nil {
		return nil, err
	}
	response, ok := responseMessage.(*CountDLQMessagesResponse)
	if !ok {
		return nil, protobuf.CastError(emptyAdminAPIServiceCountDLQMessagesYARPCResponse, responseMessage)
	}
	return response, err
}

func (c *_AdminAPIYARPCCaller) ReadDLQMessages(ctx context.Context, request *ReadDLQMessagesRequest, options ...yarpc.CallOption) (*ReadDLQMessagesResponse, error) {
	responseMessage, err := c.streamClient.Call(ctx, "ReadDLQMessages", request, newAdminAPIServiceReadDLQMessagesYARPCResponse, options...)
	if responseMessage == nil {
		return nil, err
	}
	response, ok := responseMessage.(*ReadDLQMessagesResponse)
	if !ok {
		return nil, protobuf.CastError(emptyAdminAPIServiceReadDLQMessagesYARPCResponse, responseMessage)
	}
	return response, err
}

func (c *_AdminAPIYARPCCaller) PurgeDLQMessages(ctx context.Context, request *PurgeDLQMessagesRequest, options ...yarpc.CallOption) (*PurgeDLQMessagesResponse, error) {
	responseMessage, err := c.streamClient.Call(ctx, "PurgeDLQMessages", request, newAdminAPIServicePurgeDLQMessagesYARPCResponse, options...)
	if responseMessage == nil {
		return nil, err
	}
	response, ok := responseMessage.(*PurgeDLQMessagesResponse)
	if !ok {
		return nil, protobuf.CastError(emptyAdminAPIServicePurgeDLQMessagesYARPCResponse, responseMessage)
	}
	return response, err
}

func (c *_AdminAPIYARPCCaller) MergeDLQMessages(ctx context.Context, request *MergeDLQMessagesRequest, options ...yarpc.CallOption) (*MergeDLQMessagesResponse, error) {
	responseMessage, err := c.streamClient.Call(ctx, "MergeDLQMessages", request, newAdminAPIServiceMergeDLQMessagesYARPCResponse, options...)
	if responseMessage == nil {
		return nil, err
	}
	response, ok := responseMessage.(*MergeDLQMessagesResponse)
	if !ok {
		return nil, protobuf.CastError(emptyAdminAPIServiceMergeDLQMessagesYARPCResponse, responseMessage)
	}
	return response, err
}

func (c *_AdminAPIYARPCCaller) RefreshWorkflowTasks(ctx context.Context, request *RefreshWorkflowTasksRequest, options ...yarpc.CallOption) (*RefreshWorkflowTasksResponse, error) {
	responseMessage, err := c.streamClient.Call(ctx, "RefreshWorkflowTasks", request, newAdminAPIServiceRefreshWorkflowTasksYARPCResponse, options...)
	if responseMessage == nil {
		return nil, err
	}
	response, ok := responseMessage.(*RefreshWorkflowTasksResponse)
	if !ok {
		return nil, protobuf.CastError(emptyAdminAPIServiceRefreshWorkflowTasksYARPCResponse, responseMessage)
	}
	return response, err
}

func (c *_AdminAPIYARPCCaller) ResendReplicationTasks(ctx context.Context, request *ResendReplicationTasksRequest, options ...yarpc.CallOption) (*ResendReplicationTasksResponse, error) {
	responseMessage, err := c.streamClient.Call(ctx, "ResendReplicationTasks", request, newAdminAPIServiceResendReplicationTasksYARPCResponse, options...)
	if responseMessage == nil {
		return nil, err
	}
	response, ok := responseMessage.(*ResendReplicationTasksResponse)
	if !ok {
		return nil, protobuf.CastError(emptyAdminAPIServiceResendReplicationTasksYARPCResponse, responseMessage)
	}
	return response, err
}

func (c *_AdminAPIYARPCCaller) GetCrossClusterTasks(ctx context.Context, request *GetCrossClusterTasksRequest, options ...yarpc.CallOption) (*GetCrossClusterTasksResponse, error) {
	responseMessage, err := c.streamClient.Call(ctx, "GetCrossClusterTasks", request, newAdminAPIServiceGetCrossClusterTasksYARPCResponse, options...)
	if responseMessage == nil {
		return nil, err
	}
	response, ok := responseMessage.(*GetCrossClusterTasksResponse)
	if !ok {
		return nil, protobuf.CastError(emptyAdminAPIServiceGetCrossClusterTasksYARPCResponse, responseMessage)
	}
	return response, err
}

func (c *_AdminAPIYARPCCaller) RespondCrossClusterTasksCompleted(ctx context.Context, request *RespondCrossClusterTasksCompletedRequest, options ...yarpc.CallOption) (*RespondCrossClusterTasksCompletedResponse, error) {
	responseMessage, err := c.streamClient.Call(ctx, "RespondCrossClusterTasksCompleted", request, newAdminAPIServiceRespondCrossClusterTasksCompletedYARPCResponse, options...)
	if responseMessage == nil {
		return nil, err
	}
	response, ok := responseMessage.(*RespondCrossClusterTasksCompletedResponse)
	if !ok {
		return nil, protobuf.CastError(emptyAdminAPIServiceRespondCrossClusterTasksCompletedYARPCResponse, responseMessage)
	}
	return response, err
}

func (c *_AdminAPIYARPCCaller) GetDynamicConfig(ctx context.Context, request *GetDynamicConfigRequest, options ...yarpc.CallOption) (*GetDynamicConfigResponse, error) {
	responseMessage, err := c.streamClient.Call(ctx, "GetDynamicConfig", request, newAdminAPIServiceGetDynamicConfigYARPCResponse, options...)
	if responseMessage == nil {
		return nil, err
	}
	response, ok := responseMessage.(*GetDynamicConfigResponse)
	if !ok {
		return nil, protobuf.CastError(emptyAdminAPIServiceGetDynamicConfigYARPCResponse, responseMessage)
	}
	return response, err
}

func (c *_AdminAPIYARPCCaller) UpdateDynamicConfig(ctx context.Context, request *UpdateDynamicConfigRequest, options ...yarpc.CallOption) (*UpdateDynamicConfigResponse, error) {
	responseMessage, err := c.streamClient.Call(ctx, "UpdateDynamicConfig", request, newAdminAPIServiceUpdateDynamicConfigYARPCResponse, options...)
	if responseMessage == nil {
		return nil, err
	}
	response, ok := responseMessage.(*UpdateDynamicConfigResponse)
	if !ok {
		return nil, protobuf.CastError(emptyAdminAPIServiceUpdateDynamicConfigYARPCResponse, responseMessage)
	}
	return response, err
}

func (c *_AdminAPIYARPCCaller) RestoreDynamicConfig(ctx context.Context, request *RestoreDynamicConfigRequest, options ...yarpc.CallOption) (*RestoreDynamicConfigResponse, error) {
	responseMessage, err := c.streamClient.Call(ctx, "RestoreDynamicConfig", request, newAdminAPIServiceRestoreDynamicConfigYARPCResponse, options...)
	if responseMessage == nil {
		return nil, err
	}
	response, ok := responseMessage.(*RestoreDynamicConfigResponse)
	if !ok {
		return nil, protobuf.CastError(emptyAdminAPIServiceRestoreDynamicConfigYARPCResponse, responseMessage)
	}
	return response, err
}

func (c *_AdminAPIYARPCCaller) ListDynamicConfig(ctx context.Context, request *ListDynamicConfigRequest, options ...yarpc.CallOption) (*ListDynamicConfigResponse, error) {
	responseMessage, err := c.streamClient.Call(ctx, "ListDynamicConfig", request, newAdminAPIServiceListDynamicConfigYARPCResponse, options...)
	if responseMessage == nil {
		return nil, err
	}
	response, ok := responseMessage.(*ListDynamicConfigResponse)
	if !ok {
		return nil, protobuf.CastError(emptyAdminAPIServiceListDynamicConfigYARPCResponse, responseMessage)
	}
	return response, err
}

func (c *_AdminAPIYARPCCaller) DeleteWorkflow(ctx context.Context, request *DeleteWorkflowRequest, options ...yarpc.CallOption) (*DeleteWorkflowResponse, error) {
	responseMessage, err := c.streamClient.Call(ctx, "DeleteWorkflow", request, newAdminAPIServiceDeleteWorkflowYARPCResponse, options...)
	if responseMessage == nil {
		return nil, err
	}
	response, ok := responseMessage.(*DeleteWorkflowResponse)
	if !ok {
		return nil, protobuf.CastError(emptyAdminAPIServiceDeleteWorkflowYARPCResponse, responseMessage)
	}
	return response, err
}

func (c *_AdminAPIYARPCCaller) MaintainCorruptWorkflow(ctx context.Context, request *MaintainCorruptWorkflowRequest, options ...yarpc.CallOption) (*MaintainCorruptWorkflowResponse, error) {
	responseMessage, err := c.streamClient.Call(ctx, "MaintainCorruptWorkflow", request, newAdminAPIServiceMaintainCorruptWorkflowYARPCResponse, options...)
	if responseMessage == nil {
		return nil, err
	}
	response, ok := responseMessage.(*MaintainCorruptWorkflowResponse)
	if !ok {
		return nil, protobuf.CastError(emptyAdminAPIServiceMaintainCorruptWorkflowYARPCResponse, responseMessage)
	}
	return response, err
}

func (c *_AdminAPIYARPCCaller) GetGlobalIsolationGroups(ctx context.Context, request *GetGlobalIsolationGroupsRequest, options ...yarpc.CallOption) (*GetGlobalIsolationGroupsResponse, error) {
	responseMessage, err := c.streamClient.Call(ctx, "GetGlobalIsolationGroups", request, newAdminAPIServiceGetGlobalIsolationGroupsYARPCResponse, options...)
	if responseMessage == nil {
		return nil, err
	}
	response, ok := responseMessage.(*GetGlobalIsolationGroupsResponse)
	if !ok {
		return nil, protobuf.CastError(emptyAdminAPIServiceGetGlobalIsolationGroupsYARPCResponse, responseMessage)
	}
	return response, err
}

func (c *_AdminAPIYARPCCaller) UpdateGlobalIsolationGroups(ctx context.Context, request *UpdateGlobalIsolationGroupsRequest, options ...yarpc.CallOption) (*UpdateGlobalIsolationGroupsResponse, error) {
	responseMessage, err := c.streamClient.Call(ctx, "UpdateGlobalIsolationGroups", request, newAdminAPIServiceUpdateGlobalIsolationGroupsYARPCResponse, options...)
	if responseMessage == nil {
		return nil, err
	}
	response, ok := responseMessage.(*UpdateGlobalIsolationGroupsResponse)
	if !ok {
		return nil, protobuf.CastError(emptyAdminAPIServiceUpdateGlobalIsolationGroupsYARPCResponse, responseMessage)
	}
	return response, err
}

func (c *_AdminAPIYARPCCaller) GetDomainIsolationGroups(ctx context.Context, request *GetDomainIsolationGroupsRequest, options ...yarpc.CallOption) (*GetDomainIsolationGroupsResponse, error) {
	responseMessage, err := c.streamClient.Call(ctx, "GetDomainIsolationGroups", request, newAdminAPIServiceGetDomainIsolationGroupsYARPCResponse, options...)
	if responseMessage == nil {
		return nil, err
	}
	response, ok := responseMessage.(*GetDomainIsolationGroupsResponse)
	if !ok {
		return nil, protobuf.CastError(emptyAdminAPIServiceGetDomainIsolationGroupsYARPCResponse, responseMessage)
	}
	return response, err
}

func (c *_AdminAPIYARPCCaller) UpdateDomainIsolationGroups(ctx context.Context, request *UpdateDomainIsolationGroupsRequest, options ...yarpc.CallOption) (*UpdateDomainIsolationGroupsResponse, error) {
	responseMessage, err := c.streamClient.Call(ctx, "UpdateDomainIsolationGroups", request, newAdminAPIServiceUpdateDomainIsolationGroupsYARPCResponse, options...)
	if responseMessage == nil {
		return nil, err
	}
	response, ok := responseMessage.(*UpdateDomainIsolationGroupsResponse)
	if !ok {
		return nil, protobuf.CastError(emptyAdminAPIServiceUpdateDomainIsolationGroupsYARPCResponse, responseMessage)
	}
	return response, err
}

func (c *_AdminAPIYARPCCaller) GetDomainAsyncWorkflowConfiguraton(ctx context.Context, request *GetDomainAsyncWorkflowConfiguratonRequest, options ...yarpc.CallOption) (*GetDomainAsyncWorkflowConfiguratonResponse, error) {
	responseMessage, err := c.streamClient.Call(ctx, "GetDomainAsyncWorkflowConfiguraton", request, newAdminAPIServiceGetDomainAsyncWorkflowConfiguratonYARPCResponse, options...)
	if responseMessage == nil {
		return nil, err
	}
	response, ok := responseMessage.(*GetDomainAsyncWorkflowConfiguratonResponse)
	if !ok {
		return nil, protobuf.CastError(emptyAdminAPIServiceGetDomainAsyncWorkflowConfiguratonYARPCResponse, responseMessage)
	}
	return response, err
}

func (c *_AdminAPIYARPCCaller) UpdateDomainAsyncWorkflowConfiguraton(ctx context.Context, request *UpdateDomainAsyncWorkflowConfiguratonRequest, options ...yarpc.CallOption) (*UpdateDomainAsyncWorkflowConfiguratonResponse, error) {
	responseMessage, err := c.streamClient.Call(ctx, "UpdateDomainAsyncWorkflowConfiguraton", request, newAdminAPIServiceUpdateDomainAsyncWorkflowConfiguratonYARPCResponse, options...)
	if responseMessage == nil {
		return nil, err
	}
	response, ok := responseMessage.(*UpdateDomainAsyncWorkflowConfiguratonResponse)
	if !ok {
		return nil, protobuf.CastError(emptyAdminAPIServiceUpdateDomainAsyncWorkflowConfiguratonYARPCResponse, responseMessage)
	}
	return response, err
}

type _AdminAPIYARPCHandler struct {
	server AdminAPIYARPCServer
}

func (h *_AdminAPIYARPCHandler) DescribeWorkflowExecution(ctx context.Context, requestMessage proto.Message) (proto.Message, error) {
	var request *DescribeWorkflowExecutionRequest
	var ok bool
	if requestMessage != nil {
		request, ok = requestMessage.(*DescribeWorkflowExecutionRequest)
		if !ok {
			return nil, protobuf.CastError(emptyAdminAPIServiceDescribeWorkflowExecutionYARPCRequest, requestMessage)
		}
	}
	response, err := h.server.DescribeWorkflowExecution(ctx, request)
	if response == nil {
		return nil, err
	}
	return response, err
}

func (h *_AdminAPIYARPCHandler) DescribeHistoryHost(ctx context.Context, requestMessage proto.Message) (proto.Message, error) {
	var request *DescribeHistoryHostRequest
	var ok bool
	if requestMessage != nil {
		request, ok = requestMessage.(*DescribeHistoryHostRequest)
		if !ok {
			return nil, protobuf.CastError(emptyAdminAPIServiceDescribeHistoryHostYARPCRequest, requestMessage)
		}
	}
	response, err := h.server.DescribeHistoryHost(ctx, request)
	if response == nil {
		return nil, err
	}
	return response, err
}

func (h *_AdminAPIYARPCHandler) DescribeShardDistribution(ctx context.Context, requestMessage proto.Message) (proto.Message, error) {
	var request *DescribeShardDistributionRequest
	var ok bool
	if requestMessage != nil {
		request, ok = requestMessage.(*DescribeShardDistributionRequest)
		if !ok {
			return nil, protobuf.CastError(emptyAdminAPIServiceDescribeShardDistributionYARPCRequest, requestMessage)
		}
	}
	response, err := h.server.DescribeShardDistribution(ctx, request)
	if response == nil {
		return nil, err
	}
	return response, err
}

func (h *_AdminAPIYARPCHandler) CloseShard(ctx context.Context, requestMessage proto.Message) (proto.Message, error) {
	var request *CloseShardRequest
	var ok bool
	if requestMessage != nil {
		request, ok = requestMessage.(*CloseShardRequest)
		if !ok {
			return nil, protobuf.CastError(emptyAdminAPIServiceCloseShardYARPCRequest, requestMessage)
		}
	}
	response, err := h.server.CloseShard(ctx, request)
	if response == nil {
		return nil, err
	}
	return response, err
}

func (h *_AdminAPIYARPCHandler) RemoveTask(ctx context.Context, requestMessage proto.Message) (proto.Message, error) {
	var request *RemoveTaskRequest
	var ok bool
	if requestMessage != nil {
		request, ok = requestMessage.(*RemoveTaskRequest)
		if !ok {
			return nil, protobuf.CastError(emptyAdminAPIServiceRemoveTaskYARPCRequest, requestMessage)
		}
	}
	response, err := h.server.RemoveTask(ctx, request)
	if response == nil {
		return nil, err
	}
	return response, err
}

func (h *_AdminAPIYARPCHandler) ResetQueue(ctx context.Context, requestMessage proto.Message) (proto.Message, error) {
	var request *ResetQueueRequest
	var ok bool
	if requestMessage != nil {
		request, ok = requestMessage.(*ResetQueueRequest)
		if !ok {
			return nil, protobuf.CastError(emptyAdminAPIServiceResetQueueYARPCRequest, requestMessage)
		}
	}
	response, err := h.server.ResetQueue(ctx, request)
	if response == nil {
		return nil, err
	}
	return response, err
}

func (h *_AdminAPIYARPCHandler) DescribeQueue(ctx context.Context, requestMessage proto.Message) (proto.Message, error) {
	var request *DescribeQueueRequest
	var ok bool
	if requestMessage != nil {
		request, ok = requestMessage.(*DescribeQueueRequest)
		if !ok {
			return nil, protobuf.CastError(emptyAdminAPIServiceDescribeQueueYARPCRequest, requestMessage)
		}
	}
	response, err := h.server.DescribeQueue(ctx, request)
	if response == nil {
		return nil, err
	}
	return response, err
}

func (h *_AdminAPIYARPCHandler) GetWorkflowExecutionRawHistoryV2(ctx context.Context, requestMessage proto.Message) (proto.Message, error) {
	var request *GetWorkflowExecutionRawHistoryV2Request
	var ok bool
	if requestMessage != nil {
		request, ok = requestMessage.(*GetWorkflowExecutionRawHistoryV2Request)
		if !ok {
			return nil, protobuf.CastError(emptyAdminAPIServiceGetWorkflowExecutionRawHistoryV2YARPCRequest, requestMessage)
		}
	}
	response, err := h.server.GetWorkflowExecutionRawHistoryV2(ctx, request)
	if response == nil {
		return nil, err
	}
	return response, err
}

func (h *_AdminAPIYARPCHandler) GetReplicationMessages(ctx context.Context, requestMessage proto.Message) (proto.Message, error) {
	var request *GetReplicationMessagesRequest
	var ok bool
	if requestMessage != nil {
		request, ok = requestMessage.(*GetReplicationMessagesRequest)
		if !ok {
			return nil, protobuf.CastError(emptyAdminAPIServiceGetReplicationMessagesYARPCRequest, requestMessage)
		}
	}
	response, err := h.server.GetReplicationMessages(ctx, request)
	if response == nil {
		return nil, err
	}
	return response, err
}

func (h *_AdminAPIYARPCHandler) GetDLQReplicationMessages(ctx context.Context, requestMessage proto.Message) (proto.Message, error) {
	var request *GetDLQReplicationMessagesRequest
	var ok bool
	if requestMessage != nil {
		request, ok = requestMessage.(*GetDLQReplicationMessagesRequest)
		if !ok {
			return nil, protobuf.CastError(emptyAdminAPIServiceGetDLQReplicationMessagesYARPCRequest, requestMessage)
		}
	}
	response, err := h.server.GetDLQReplicationMessages(ctx, request)
	if response == nil {
		return nil, err
	}
	return response, err
}

func (h *_AdminAPIYARPCHandler) GetDomainReplicationMessages(ctx context.Context, requestMessage proto.Message) (proto.Message, error) {
	var request *GetDomainReplicationMessagesRequest
	var ok bool
	if requestMessage != nil {
		request, ok = requestMessage.(*GetDomainReplicationMessagesRequest)
		if !ok {
			return nil, protobuf.CastError(emptyAdminAPIServiceGetDomainReplicationMessagesYARPCRequest, requestMessage)
		}
	}
	response, err := h.server.GetDomainReplicationMessages(ctx, request)
	if response == nil {
		return nil, err
	}
	return response, err
}

func (h *_AdminAPIYARPCHandler) ReapplyEvents(ctx context.Context, requestMessage proto.Message) (proto.Message, error) {
	var request *ReapplyEventsRequest
	var ok bool
	if requestMessage != nil {
		request, ok = requestMessage.(*ReapplyEventsRequest)
		if !ok {
			return nil, protobuf.CastError(emptyAdminAPIServiceReapplyEventsYARPCRequest, requestMessage)
		}
	}
	response, err := h.server.ReapplyEvents(ctx, request)
	if response == nil {
		return nil, err
	}
	return response, err
}

func (h *_AdminAPIYARPCHandler) AddSearchAttribute(ctx context.Context, requestMessage proto.Message) (proto.Message, error) {
	var request *AddSearchAttributeRequest
	var ok bool
	if requestMessage != nil {
		request, ok = requestMessage.(*AddSearchAttributeRequest)
		if !ok {
			return nil, protobuf.CastError(emptyAdminAPIServiceAddSearchAttributeYARPCRequest, requestMessage)
		}
	}
	response, err := h.server.AddSearchAttribute(ctx, request)
	if response == nil {
		return nil, err
	}
	return response, err
}

func (h *_AdminAPIYARPCHandler) DescribeCluster(ctx context.Context, requestMessage proto.Message) (proto.Message, error) {
	var request *DescribeClusterRequest
	var ok bool
	if requestMessage != nil {
		request, ok = requestMessage.(*DescribeClusterRequest)
		if !ok {
			return nil, protobuf.CastError(emptyAdminAPIServiceDescribeClusterYARPCRequest, requestMessage)
		}
	}
	response, err := h.server.DescribeCluster(ctx, request)
	if response == nil {
		return nil, err
	}
	return response, err
}

func (h *_AdminAPIYARPCHandler) CountDLQMessages(ctx context.Context, requestMessage proto.Message) (proto.Message, error) {
	var request *CountDLQMessagesRequest
	var ok bool
	if requestMessage != nil {
		request, ok = requestMessage.(*CountDLQMessagesRequest)
		if !ok {
			return nil, protobuf.CastError(emptyAdminAPIServiceCountDLQMessagesYARPCRequest, requestMessage)
		}
	}
	response, err := h.server.CountDLQMessages(ctx, request)
	if response == nil {
		return nil, err
	}
	return response, err
}

func (h *_AdminAPIYARPCHandler) ReadDLQMessages(ctx context.Context, requestMessage proto.Message) (proto.Message, error) {
	var request *ReadDLQMessagesRequest
	var ok bool
	if requestMessage != nil {
		request, ok = requestMessage.(*ReadDLQMessagesRequest)
		if !ok {
			return nil, protobuf.CastError(emptyAdminAPIServiceReadDLQMessagesYARPCRequest, requestMessage)
		}
	}
	response, err := h.server.ReadDLQMessages(ctx, request)
	if response == nil {
		return nil, err
	}
	return response, err
}

func (h *_AdminAPIYARPCHandler) PurgeDLQMessages(ctx context.Context, requestMessage proto.Message) (proto.Message, error) {
	var request *PurgeDLQMessagesRequest
	var ok bool
	if requestMessage != nil {
		request, ok = requestMessage.(*PurgeDLQMessagesRequest)
		if !ok {
			return nil, protobuf.CastError(emptyAdminAPIServicePurgeDLQMessagesYARPCRequest, requestMessage)
		}
	}
	response, err := h.server.PurgeDLQMessages(ctx, request)
	if response == nil {
		return nil, err
	}
	return response, err
}

func (h *_AdminAPIYARPCHandler) MergeDLQMessages(ctx context.Context, requestMessage proto.Message) (proto.Message, error) {
	var request *MergeDLQMessagesRequest
	var ok bool
	if requestMessage != nil {
		request, ok = requestMessage.(*MergeDLQMessagesRequest)
		if !ok {
			return nil, protobuf.CastError(emptyAdminAPIServiceMergeDLQMessagesYARPCRequest, requestMessage)
		}
	}
	response, err := h.server.MergeDLQMessages(ctx, request)
	if response == nil {
		return nil, err
	}
	return response, err
}

func (h *_AdminAPIYARPCHandler) RefreshWorkflowTasks(ctx context.Context, requestMessage proto.Message) (proto.Message, error) {
	var request *RefreshWorkflowTasksRequest
	var ok bool
	if requestMessage != nil {
		request, ok = requestMessage.(*RefreshWorkflowTasksRequest)
		if !ok {
			return nil, protobuf.CastError(emptyAdminAPIServiceRefreshWorkflowTasksYARPCRequest, requestMessage)
		}
	}
	response, err := h.server.RefreshWorkflowTasks(ctx, request)
	if response == nil {
		return nil, err
	}
	return response, err
}

func (h *_AdminAPIYARPCHandler) ResendReplicationTasks(ctx context.Context, requestMessage proto.Message) (proto.Message, error) {
	var request *ResendReplicationTasksRequest
	var ok bool
	if requestMessage != nil {
		request, ok = requestMessage.(*ResendReplicationTasksRequest)
		if !ok {
			return nil, protobuf.CastError(emptyAdminAPIServiceResendReplicationTasksYARPCRequest, requestMessage)
		}
	}
	response, err := h.server.ResendReplicationTasks(ctx, request)
	if response == nil {
		return nil, err
	}
	return response, err
}

func (h *_AdminAPIYARPCHandler) GetCrossClusterTasks(ctx context.Context, requestMessage proto.Message) (proto.Message, error) {
	var request *GetCrossClusterTasksRequest
	var ok bool
	if requestMessage != nil {
		request, ok = requestMessage.(*GetCrossClusterTasksRequest)
		if !ok {
			return nil, protobuf.CastError(emptyAdminAPIServiceGetCrossClusterTasksYARPCRequest, requestMessage)
		}
	}
	response, err := h.server.GetCrossClusterTasks(ctx, request)
	if response == nil {
		return nil, err
	}
	return response, err
}

func (h *_AdminAPIYARPCHandler) RespondCrossClusterTasksCompleted(ctx context.Context, requestMessage proto.Message) (proto.Message, error) {
	var request *RespondCrossClusterTasksCompletedRequest
	var ok bool
	if requestMessage != nil {
		request, ok = requestMessage.(*RespondCrossClusterTasksCompletedRequest)
		if !ok {
			return nil, protobuf.CastError(emptyAdminAPIServiceRespondCrossClusterTasksCompletedYARPCRequest, requestMessage)
		}
	}
	response, err := h.server.RespondCrossClusterTasksCompleted(ctx, request)
	if response == nil {
		return nil, err
	}
	return response, err
}

func (h *_AdminAPIYARPCHandler) GetDynamicConfig(ctx context.Context, requestMessage proto.Message) (proto.Message, error) {
	var request *GetDynamicConfigRequest
	var ok bool
	if requestMessage != nil {
		request, ok = requestMessage.(*GetDynamicConfigRequest)
		if !ok {
			return nil, protobuf.CastError(emptyAdminAPIServiceGetDynamicConfigYARPCRequest, requestMessage)
		}
	}
	response, err := h.server.GetDynamicConfig(ctx, request)
	if response == nil {
		return nil, err
	}
	return response, err
}

func (h *_AdminAPIYARPCHandler) UpdateDynamicConfig(ctx context.Context, requestMessage proto.Message) (proto.Message, error) {
	var request *UpdateDynamicConfigRequest
	var ok bool
	if requestMessage != nil {
		request, ok = requestMessage.(*UpdateDynamicConfigRequest)
		if !ok {
			return nil, protobuf.CastError(emptyAdminAPIServiceUpdateDynamicConfigYARPCRequest, requestMessage)
		}
	}
	response, err := h.server.UpdateDynamicConfig(ctx, request)
	if response == nil {
		return nil, err
	}
	return response, err
}

func (h *_AdminAPIYARPCHandler) RestoreDynamicConfig(ctx context.Context, requestMessage proto.Message) (proto.Message, error) {
	var request *RestoreDynamicConfigRequest
	var ok bool
	if requestMessage != nil {
		request, ok = requestMessage.(*RestoreDynamicConfigRequest)
		if !ok {
			return nil, protobuf.CastError(emptyAdminAPIServiceRestoreDynamicConfigYARPCRequest, requestMessage)
		}
	}
	response, err := h.server.RestoreDynamicConfig(ctx, request)
	if response == nil {
		return nil, err
	}
	return response, err
}

func (h *_AdminAPIYARPCHandler) ListDynamicConfig(ctx context.Context, requestMessage proto.Message) (proto.Message, error) {
	var request *ListDynamicConfigRequest
	var ok bool
	if requestMessage != nil {
		request, ok = requestMessage.(*ListDynamicConfigRequest)
		if !ok {
			return nil, protobuf.CastError(emptyAdminAPIServiceListDynamicConfigYARPCRequest, requestMessage)
		}
	}
	response, err := h.server.ListDynamicConfig(ctx, request)
	if response == nil {
		return nil, err
	}
	return response, err
}

func (h *_AdminAPIYARPCHandler) DeleteWorkflow(ctx context.Context, requestMessage proto.Message) (proto.Message, error) {
	var request *DeleteWorkflowRequest
	var ok bool
	if requestMessage != nil {
		request, ok = requestMessage.(*DeleteWorkflowRequest)
		if !ok {
			return nil, protobuf.CastError(emptyAdminAPIServiceDeleteWorkflowYARPCRequest, requestMessage)
		}
	}
	response, err := h.server.DeleteWorkflow(ctx, request)
	if response == nil {
		return nil, err
	}
	return response, err
}

func (h *_AdminAPIYARPCHandler) MaintainCorruptWorkflow(ctx context.Context, requestMessage proto.Message) (proto.Message, error) {
	var request *MaintainCorruptWorkflowRequest
	var ok bool
	if requestMessage != nil {
		request, ok = requestMessage.(*MaintainCorruptWorkflowRequest)
		if !ok {
			return nil, protobuf.CastError(emptyAdminAPIServiceMaintainCorruptWorkflowYARPCRequest, requestMessage)
		}
	}
	response, err := h.server.MaintainCorruptWorkflow(ctx, request)
	if response == nil {
		return nil, err
	}
	return response, err
}

func (h *_AdminAPIYARPCHandler) GetGlobalIsolationGroups(ctx context.Context, requestMessage proto.Message) (proto.Message, error) {
	var request *GetGlobalIsolationGroupsRequest
	var ok bool
	if requestMessage != nil {
		request, ok = requestMessage.(*GetGlobalIsolationGroupsRequest)
		if !ok {
			return nil, protobuf.CastError(emptyAdminAPIServiceGetGlobalIsolationGroupsYARPCRequest, requestMessage)
		}
	}
	response, err := h.server.GetGlobalIsolationGroups(ctx, request)
	if response == nil {
		return nil, err
	}
	return response, err
}

func (h *_AdminAPIYARPCHandler) UpdateGlobalIsolationGroups(ctx context.Context, requestMessage proto.Message) (proto.Message, error) {
	var request *UpdateGlobalIsolationGroupsRequest
	var ok bool
	if requestMessage != nil {
		request, ok = requestMessage.(*UpdateGlobalIsolationGroupsRequest)
		if !ok {
			return nil, protobuf.CastError(emptyAdminAPIServiceUpdateGlobalIsolationGroupsYARPCRequest, requestMessage)
		}
	}
	response, err := h.server.UpdateGlobalIsolationGroups(ctx, request)
	if response == nil {
		return nil, err
	}
	return response, err
}

func (h *_AdminAPIYARPCHandler) GetDomainIsolationGroups(ctx context.Context, requestMessage proto.Message) (proto.Message, error) {
	var request *GetDomainIsolationGroupsRequest
	var ok bool
	if requestMessage != nil {
		request, ok = requestMessage.(*GetDomainIsolationGroupsRequest)
		if !ok {
			return nil, protobuf.CastError(emptyAdminAPIServiceGetDomainIsolationGroupsYARPCRequest, requestMessage)
		}
	}
	response, err := h.server.GetDomainIsolationGroups(ctx, request)
	if response == nil {
		return nil, err
	}
	return response, err
}

func (h *_AdminAPIYARPCHandler) UpdateDomainIsolationGroups(ctx context.Context, requestMessage proto.Message) (proto.Message, error) {
	var request *UpdateDomainIsolationGroupsRequest
	var ok bool
	if requestMessage != nil {
		request, ok = requestMessage.(*UpdateDomainIsolationGroupsRequest)
		if !ok {
			return nil, protobuf.CastError(emptyAdminAPIServiceUpdateDomainIsolationGroupsYARPCRequest, requestMessage)
		}
	}
	response, err := h.server.UpdateDomainIsolationGroups(ctx, request)
	if response == nil {
		return nil, err
	}
	return response, err
}

func (h *_AdminAPIYARPCHandler) GetDomainAsyncWorkflowConfiguraton(ctx context.Context, requestMessage proto.Message) (proto.Message, error) {
	var request *GetDomainAsyncWorkflowConfiguratonRequest
	var ok bool
	if requestMessage != nil {
		request, ok = requestMessage.(*GetDomainAsyncWorkflowConfiguratonRequest)
		if !ok {
			return nil, protobuf.CastError(emptyAdminAPIServiceGetDomainAsyncWorkflowConfiguratonYARPCRequest, requestMessage)
		}
	}
	response, err := h.server.GetDomainAsyncWorkflowConfiguraton(ctx, request)
	if response == nil {
		return nil, err
	}
	return response, err
}

func (h *_AdminAPIYARPCHandler) UpdateDomainAsyncWorkflowConfiguraton(ctx context.Context, requestMessage proto.Message) (proto.Message, error) {
	var request *UpdateDomainAsyncWorkflowConfiguratonRequest
	var ok bool
	if requestMessage != nil {
		request, ok = requestMessage.(*UpdateDomainAsyncWorkflowConfiguratonRequest)
		if !ok {
			return nil, protobuf.CastError(emptyAdminAPIServiceUpdateDomainAsyncWorkflowConfiguratonYARPCRequest, requestMessage)
		}
	}
	response, err := h.server.UpdateDomainAsyncWorkflowConfiguraton(ctx, request)
	if response == nil {
		return nil, err
	}
	return response, err
}

func newAdminAPIServiceDescribeWorkflowExecutionYARPCRequest() proto.Message {
	return &DescribeWorkflowExecutionRequest{}
}

func newAdminAPIServiceDescribeWorkflowExecutionYARPCResponse() proto.Message {
	return &DescribeWorkflowExecutionResponse{}
}

func newAdminAPIServiceDescribeHistoryHostYARPCRequest() proto.Message {
	return &DescribeHistoryHostRequest{}
}

func newAdminAPIServiceDescribeHistoryHostYARPCResponse() proto.Message {
	return &DescribeHistoryHostResponse{}
}

func newAdminAPIServiceDescribeShardDistributionYARPCRequest() proto.Message {
	return &DescribeShardDistributionRequest{}
}

func newAdminAPIServiceDescribeShardDistributionYARPCResponse() proto.Message {
	return &DescribeShardDistributionResponse{}
}

func newAdminAPIServiceCloseShardYARPCRequest() proto.Message {
	return &CloseShardRequest{}
}

func newAdminAPIServiceCloseShardYARPCResponse() proto.Message {
	return &CloseShardResponse{}
}

func newAdminAPIServiceRemoveTaskYARPCRequest() proto.Message {
	return &RemoveTaskRequest{}
}

func newAdminAPIServiceRemoveTaskYARPCResponse() proto.Message {
	return &RemoveTaskResponse{}
}

func newAdminAPIServiceResetQueueYARPCRequest() proto.Message {
	return &ResetQueueRequest{}
}

func newAdminAPIServiceResetQueueYARPCResponse() proto.Message {
	return &ResetQueueResponse{}
}

func newAdminAPIServiceDescribeQueueYARPCRequest() proto.Message {
	return &DescribeQueueRequest{}
}

func newAdminAPIServiceDescribeQueueYARPCResponse() proto.Message {
	return &DescribeQueueResponse{}
}

func newAdminAPIServiceGetWorkflowExecutionRawHistoryV2YARPCRequest() proto.Message {
	return &GetWorkflowExecutionRawHistoryV2Request{}
}

func newAdminAPIServiceGetWorkflowExecutionRawHistoryV2YARPCResponse() proto.Message {
	return &GetWorkflowExecutionRawHistoryV2Response{}
}

func newAdminAPIServiceGetReplicationMessagesYARPCRequest() proto.Message {
	return &GetReplicationMessagesRequest{}
}

func newAdminAPIServiceGetReplicationMessagesYARPCResponse() proto.Message {
	return &GetReplicationMessagesResponse{}
}

func newAdminAPIServiceGetDLQReplicationMessagesYARPCRequest() proto.Message {
	return &GetDLQReplicationMessagesRequest{}
}

func newAdminAPIServiceGetDLQReplicationMessagesYARPCResponse() proto.Message {
	return &GetDLQReplicationMessagesResponse{}
}

func newAdminAPIServiceGetDomainReplicationMessagesYARPCRequest() proto.Message {
	return &GetDomainReplicationMessagesRequest{}
}

func newAdminAPIServiceGetDomainReplicationMessagesYARPCResponse() proto.Message {
	return &GetDomainReplicationMessagesResponse{}
}

func newAdminAPIServiceReapplyEventsYARPCRequest() proto.Message {
	return &ReapplyEventsRequest{}
}

func newAdminAPIServiceReapplyEventsYARPCResponse() proto.Message {
	return &ReapplyEventsResponse{}
}

func newAdminAPIServiceAddSearchAttributeYARPCRequest() proto.Message {
	return &AddSearchAttributeRequest{}
}

func newAdminAPIServiceAddSearchAttributeYARPCResponse() proto.Message {
	return &AddSearchAttributeResponse{}
}

func newAdminAPIServiceDescribeClusterYARPCRequest() proto.Message {
	return &DescribeClusterRequest{}
}

func newAdminAPIServiceDescribeClusterYARPCResponse() proto.Message {
	return &DescribeClusterResponse{}
}

func newAdminAPIServiceCountDLQMessagesYARPCRequest() proto.Message {
	return &CountDLQMessagesRequest{}
}

func newAdminAPIServiceCountDLQMessagesYARPCResponse() proto.Message {
	return &CountDLQMessagesResponse{}
}

func newAdminAPIServiceReadDLQMessagesYARPCRequest() proto.Message {
	return &ReadDLQMessagesRequest{}
}

func newAdminAPIServiceReadDLQMessagesYARPCResponse() proto.Message {
	return &ReadDLQMessagesResponse{}
}

func newAdminAPIServicePurgeDLQMessagesYARPCRequest() proto.Message {
	return &PurgeDLQMessagesRequest{}
}

func newAdminAPIServicePurgeDLQMessagesYARPCResponse() proto.Message {
	return &PurgeDLQMessagesResponse{}
}

func newAdminAPIServiceMergeDLQMessagesYARPCRequest() proto.Message {
	return &MergeDLQMessagesRequest{}
}

func newAdminAPIServiceMergeDLQMessagesYARPCResponse() proto.Message {
	return &MergeDLQMessagesResponse{}
}

func newAdminAPIServiceRefreshWorkflowTasksYARPCRequest() proto.Message {
	return &RefreshWorkflowTasksRequest{}
}

func newAdminAPIServiceRefreshWorkflowTasksYARPCResponse() proto.Message {
	return &RefreshWorkflowTasksResponse{}
}

func newAdminAPIServiceResendReplicationTasksYARPCRequest() proto.Message {
	return &ResendReplicationTasksRequest{}
}

func newAdminAPIServiceResendReplicationTasksYARPCResponse() proto.Message {
	return &ResendReplicationTasksResponse{}
}

func newAdminAPIServiceGetCrossClusterTasksYARPCRequest() proto.Message {
	return &GetCrossClusterTasksRequest{}
}

func newAdminAPIServiceGetCrossClusterTasksYARPCResponse() proto.Message {
	return &GetCrossClusterTasksResponse{}
}

func newAdminAPIServiceRespondCrossClusterTasksCompletedYARPCRequest() proto.Message {
	return &RespondCrossClusterTasksCompletedRequest{}
}

func newAdminAPIServiceRespondCrossClusterTasksCompletedYARPCResponse() proto.Message {
	return &RespondCrossClusterTasksCompletedResponse{}
}

func newAdminAPIServiceGetDynamicConfigYARPCRequest() proto.Message {
	return &GetDynamicConfigRequest{}
}

func newAdminAPIServiceGetDynamicConfigYARPCResponse() proto.Message {
	return &GetDynamicConfigResponse{}
}

func newAdminAPIServiceUpdateDynamicConfigYARPCRequest() proto.Message {
	return &UpdateDynamicConfigRequest{}
}

func newAdminAPIServiceUpdateDynamicConfigYARPCResponse() proto.Message {
	return &UpdateDynamicConfigResponse{}
}

func newAdminAPIServiceRestoreDynamicConfigYARPCRequest() proto.Message {
	return &RestoreDynamicConfigRequest{}
}

func newAdminAPIServiceRestoreDynamicConfigYARPCResponse() proto.Message {
	return &RestoreDynamicConfigResponse{}
}

func newAdminAPIServiceListDynamicConfigYARPCRequest() proto.Message {
	return &ListDynamicConfigRequest{}
}

func newAdminAPIServiceListDynamicConfigYARPCResponse() proto.Message {
	return &ListDynamicConfigResponse{}
}

func newAdminAPIServiceDeleteWorkflowYARPCRequest() proto.Message {
	return &DeleteWorkflowRequest{}
}

func newAdminAPIServiceDeleteWorkflowYARPCResponse() proto.Message {
	return &DeleteWorkflowResponse{}
}

func newAdminAPIServiceMaintainCorruptWorkflowYARPCRequest() proto.Message {
	return &MaintainCorruptWorkflowRequest{}
}

func newAdminAPIServiceMaintainCorruptWorkflowYARPCResponse() proto.Message {
	return &MaintainCorruptWorkflowResponse{}
}

func newAdminAPIServiceGetGlobalIsolationGroupsYARPCRequest() proto.Message {
	return &GetGlobalIsolationGroupsRequest{}
}

func newAdminAPIServiceGetGlobalIsolationGroupsYARPCResponse() proto.Message {
	return &GetGlobalIsolationGroupsResponse{}
}

func newAdminAPIServiceUpdateGlobalIsolationGroupsYARPCRequest() proto.Message {
	return &UpdateGlobalIsolationGroupsRequest{}
}

func newAdminAPIServiceUpdateGlobalIsolationGroupsYARPCResponse() proto.Message {
	return &UpdateGlobalIsolationGroupsResponse{}
}

func newAdminAPIServiceGetDomainIsolationGroupsYARPCRequest() proto.Message {
	return &GetDomainIsolationGroupsRequest{}
}

func newAdminAPIServiceGetDomainIsolationGroupsYARPCResponse() proto.Message {
	return &GetDomainIsolationGroupsResponse{}
}

func newAdminAPIServiceUpdateDomainIsolationGroupsYARPCRequest() proto.Message {
	return &UpdateDomainIsolationGroupsRequest{}
}

func newAdminAPIServiceUpdateDomainIsolationGroupsYARPCResponse() proto.Message {
	return &UpdateDomainIsolationGroupsResponse{}
}

func newAdminAPIServiceGetDomainAsyncWorkflowConfiguratonYARPCRequest() proto.Message {
	return &GetDomainAsyncWorkflowConfiguratonRequest{}
}

func newAdminAPIServiceGetDomainAsyncWorkflowConfiguratonYARPCResponse() proto.Message {
	return &GetDomainAsyncWorkflowConfiguratonResponse{}
}

func newAdminAPIServiceUpdateDomainAsyncWorkflowConfiguratonYARPCRequest() proto.Message {
	return &UpdateDomainAsyncWorkflowConfiguratonRequest{}
}

func newAdminAPIServiceUpdateDomainAsyncWorkflowConfiguratonYARPCResponse() proto.Message {
	return &UpdateDomainAsyncWorkflowConfiguratonResponse{}
}

var (
	emptyAdminAPIServiceDescribeWorkflowExecutionYARPCRequest              = &DescribeWorkflowExecutionRequest{}
	emptyAdminAPIServiceDescribeWorkflowExecutionYARPCResponse             = &DescribeWorkflowExecutionResponse{}
	emptyAdminAPIServiceDescribeHistoryHostYARPCRequest                    = &DescribeHistoryHostRequest{}
	emptyAdminAPIServiceDescribeHistoryHostYARPCResponse                   = &DescribeHistoryHostResponse{}
	emptyAdminAPIServiceDescribeShardDistributionYARPCRequest              = &DescribeShardDistributionRequest{}
	emptyAdminAPIServiceDescribeShardDistributionYARPCResponse             = &DescribeShardDistributionResponse{}
	emptyAdminAPIServiceCloseShardYARPCRequest                             = &CloseShardRequest{}
	emptyAdminAPIServiceCloseShardYARPCResponse                            = &CloseShardResponse{}
	emptyAdminAPIServiceRemoveTaskYARPCRequest                             = &RemoveTaskRequest{}
	emptyAdminAPIServiceRemoveTaskYARPCResponse                            = &RemoveTaskResponse{}
	emptyAdminAPIServiceResetQueueYARPCRequest                             = &ResetQueueRequest{}
	emptyAdminAPIServiceResetQueueYARPCResponse                            = &ResetQueueResponse{}
	emptyAdminAPIServiceDescribeQueueYARPCRequest                          = &DescribeQueueRequest{}
	emptyAdminAPIServiceDescribeQueueYARPCResponse                         = &DescribeQueueResponse{}
	emptyAdminAPIServiceGetWorkflowExecutionRawHistoryV2YARPCRequest       = &GetWorkflowExecutionRawHistoryV2Request{}
	emptyAdminAPIServiceGetWorkflowExecutionRawHistoryV2YARPCResponse      = &GetWorkflowExecutionRawHistoryV2Response{}
	emptyAdminAPIServiceGetReplicationMessagesYARPCRequest                 = &GetReplicationMessagesRequest{}
	emptyAdminAPIServiceGetReplicationMessagesYARPCResponse                = &GetReplicationMessagesResponse{}
	emptyAdminAPIServiceGetDLQReplicationMessagesYARPCRequest              = &GetDLQReplicationMessagesRequest{}
	emptyAdminAPIServiceGetDLQReplicationMessagesYARPCResponse             = &GetDLQReplicationMessagesResponse{}
	emptyAdminAPIServiceGetDomainReplicationMessagesYARPCRequest           = &GetDomainReplicationMessagesRequest{}
	emptyAdminAPIServiceGetDomainReplicationMessagesYARPCResponse          = &GetDomainReplicationMessagesResponse{}
	emptyAdminAPIServiceReapplyEventsYARPCRequest                          = &ReapplyEventsRequest{}
	emptyAdminAPIServiceReapplyEventsYARPCResponse                         = &ReapplyEventsResponse{}
	emptyAdminAPIServiceAddSearchAttributeYARPCRequest                     = &AddSearchAttributeRequest{}
	emptyAdminAPIServiceAddSearchAttributeYARPCResponse                    = &AddSearchAttributeResponse{}
	emptyAdminAPIServiceDescribeClusterYARPCRequest                        = &DescribeClusterRequest{}
	emptyAdminAPIServiceDescribeClusterYARPCResponse                       = &DescribeClusterResponse{}
	emptyAdminAPIServiceCountDLQMessagesYARPCRequest                       = &CountDLQMessagesRequest{}
	emptyAdminAPIServiceCountDLQMessagesYARPCResponse                      = &CountDLQMessagesResponse{}
	emptyAdminAPIServiceReadDLQMessagesYARPCRequest                        = &ReadDLQMessagesRequest{}
	emptyAdminAPIServiceReadDLQMessagesYARPCResponse                       = &ReadDLQMessagesResponse{}
	emptyAdminAPIServicePurgeDLQMessagesYARPCRequest                       = &PurgeDLQMessagesRequest{}
	emptyAdminAPIServicePurgeDLQMessagesYARPCResponse                      = &PurgeDLQMessagesResponse{}
	emptyAdminAPIServiceMergeDLQMessagesYARPCRequest                       = &MergeDLQMessagesRequest{}
	emptyAdminAPIServiceMergeDLQMessagesYARPCResponse                      = &MergeDLQMessagesResponse{}
	emptyAdminAPIServiceRefreshWorkflowTasksYARPCRequest                   = &RefreshWorkflowTasksRequest{}
	emptyAdminAPIServiceRefreshWorkflowTasksYARPCResponse                  = &RefreshWorkflowTasksResponse{}
	emptyAdminAPIServiceResendReplicationTasksYARPCRequest                 = &ResendReplicationTasksRequest{}
	emptyAdminAPIServiceResendReplicationTasksYARPCResponse                = &ResendReplicationTasksResponse{}
	emptyAdminAPIServiceGetCrossClusterTasksYARPCRequest                   = &GetCrossClusterTasksRequest{}
	emptyAdminAPIServiceGetCrossClusterTasksYARPCResponse                  = &GetCrossClusterTasksResponse{}
	emptyAdminAPIServiceRespondCrossClusterTasksCompletedYARPCRequest      = &RespondCrossClusterTasksCompletedRequest{}
	emptyAdminAPIServiceRespondCrossClusterTasksCompletedYARPCResponse     = &RespondCrossClusterTasksCompletedResponse{}
	emptyAdminAPIServiceGetDynamicConfigYARPCRequest                       = &GetDynamicConfigRequest{}
	emptyAdminAPIServiceGetDynamicConfigYARPCResponse                      = &GetDynamicConfigResponse{}
	emptyAdminAPIServiceUpdateDynamicConfigYARPCRequest                    = &UpdateDynamicConfigRequest{}
	emptyAdminAPIServiceUpdateDynamicConfigYARPCResponse                   = &UpdateDynamicConfigResponse{}
	emptyAdminAPIServiceRestoreDynamicConfigYARPCRequest                   = &RestoreDynamicConfigRequest{}
	emptyAdminAPIServiceRestoreDynamicConfigYARPCResponse                  = &RestoreDynamicConfigResponse{}
	emptyAdminAPIServiceListDynamicConfigYARPCRequest                      = &ListDynamicConfigRequest{}
	emptyAdminAPIServiceListDynamicConfigYARPCResponse                     = &ListDynamicConfigResponse{}
	emptyAdminAPIServiceDeleteWorkflowYARPCRequest                         = &DeleteWorkflowRequest{}
	emptyAdminAPIServiceDeleteWorkflowYARPCResponse                        = &DeleteWorkflowResponse{}
	emptyAdminAPIServiceMaintainCorruptWorkflowYARPCRequest                = &MaintainCorruptWorkflowRequest{}
	emptyAdminAPIServiceMaintainCorruptWorkflowYARPCResponse               = &MaintainCorruptWorkflowResponse{}
	emptyAdminAPIServiceGetGlobalIsolationGroupsYARPCRequest               = &GetGlobalIsolationGroupsRequest{}
	emptyAdminAPIServiceGetGlobalIsolationGroupsYARPCResponse              = &GetGlobalIsolationGroupsResponse{}
	emptyAdminAPIServiceUpdateGlobalIsolationGroupsYARPCRequest            = &UpdateGlobalIsolationGroupsRequest{}
	emptyAdminAPIServiceUpdateGlobalIsolationGroupsYARPCResponse           = &UpdateGlobalIsolationGroupsResponse{}
	emptyAdminAPIServiceGetDomainIsolationGroupsYARPCRequest               = &GetDomainIsolationGroupsRequest{}
	emptyAdminAPIServiceGetDomainIsolationGroupsYARPCResponse              = &GetDomainIsolationGroupsResponse{}
	emptyAdminAPIServiceUpdateDomainIsolationGroupsYARPCRequest            = &UpdateDomainIsolationGroupsRequest{}
	emptyAdminAPIServiceUpdateDomainIsolationGroupsYARPCResponse           = &UpdateDomainIsolationGroupsResponse{}
	emptyAdminAPIServiceGetDomainAsyncWorkflowConfiguratonYARPCRequest     = &GetDomainAsyncWorkflowConfiguratonRequest{}
	emptyAdminAPIServiceGetDomainAsyncWorkflowConfiguratonYARPCResponse    = &GetDomainAsyncWorkflowConfiguratonResponse{}
	emptyAdminAPIServiceUpdateDomainAsyncWorkflowConfiguratonYARPCRequest  = &UpdateDomainAsyncWorkflowConfiguratonRequest{}
	emptyAdminAPIServiceUpdateDomainAsyncWorkflowConfiguratonYARPCResponse = &UpdateDomainAsyncWorkflowConfiguratonResponse{}
)

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

func init() {
	yarpc.RegisterClientBuilder(
		func(clientConfig transport.ClientConfig, structField reflect.StructField) AdminAPIYARPCClient {
			return NewAdminAPIYARPCClient(clientConfig, protobuf.ClientBuilderOptions(clientConfig, structField)...)
		},
	)
}