// Code generated by protoc-gen-psrpc v0.7.0, DO NOT EDIT.
// source: rpc/ingress.proto

package rpc

import (
	"context"

	"github.com/livekit/psrpc"
	"github.com/livekit/psrpc/pkg/client"
	"github.com/livekit/psrpc/pkg/info"
	"github.com/livekit/psrpc/pkg/rand"
	"github.com/livekit/psrpc/pkg/server"
	"github.com/livekit/psrpc/version"
)
import google_protobuf "google.golang.org/protobuf/types/known/emptypb"
import livekit5 "github.com/livekit/protocol/livekit"

var _ = version.PsrpcVersion_0_7

// ================================
// IngressInternal Client Interface
// ================================

type IngressInternalClient interface {
	StartIngress(ctx context.Context, req *StartIngressRequest, opts ...psrpc.RequestOption) (*livekit5.IngressInfo, error)

	ListActiveIngress(ctx context.Context, topic string, req *ListActiveIngressRequest, opts ...psrpc.RequestOption) (<-chan *psrpc.Response[*ListActiveIngressResponse], error)

	KillIngressSession(ctx context.Context, ingressId string, resourceId string, req *KillIngressSessionRequest, opts ...psrpc.RequestOption) (*google_protobuf.Empty, error)

	// Close immediately, without waiting for pending RPCs
	Close()
}

// ====================================
// IngressInternal ServerImpl Interface
// ====================================

type IngressInternalServerImpl interface {
	StartIngress(context.Context, *StartIngressRequest) (*livekit5.IngressInfo, error)
	StartIngressAffinity(context.Context, *StartIngressRequest) float32

	ListActiveIngress(context.Context, *ListActiveIngressRequest) (*ListActiveIngressResponse, error)

	KillIngressSession(context.Context, *KillIngressSessionRequest) (*google_protobuf.Empty, error)
}

// ================================
// IngressInternal Server Interface
// ================================

type IngressInternalServer interface {
	RegisterListActiveIngressTopic(topic string) error
	DeregisterListActiveIngressTopic(topic string)
	RegisterKillIngressSessionTopic(ingressId string, resourceId string) error
	DeregisterKillIngressSessionTopic(ingressId string, resourceId string)

	// Close and wait for pending RPCs to complete
	Shutdown()

	// Close immediately, without waiting for pending RPCs
	Kill()
}

// ======================
// IngressInternal Client
// ======================

type ingressInternalClient struct {
	client *client.RPCClient
}

// NewIngressInternalClient creates a psrpc client that implements the IngressInternalClient interface.
func NewIngressInternalClient(bus psrpc.MessageBus, opts ...psrpc.ClientOption) (IngressInternalClient, error) {
	sd := &info.ServiceDefinition{
		Name: "IngressInternal",
		ID:   rand.NewClientID(),
	}

	sd.RegisterMethod("StartIngress", true, false, true, false)
	sd.RegisterMethod("ListActiveIngress", false, true, false, false)
	sd.RegisterMethod("KillIngressSession", false, false, true, true)

	rpcClient, err := client.NewRPCClient(sd, bus, opts...)
	if err != nil {
		return nil, err
	}

	return &ingressInternalClient{
		client: rpcClient,
	}, nil
}

func (c *ingressInternalClient) StartIngress(ctx context.Context, req *StartIngressRequest, opts ...psrpc.RequestOption) (*livekit5.IngressInfo, error) {
	return client.RequestSingle[*livekit5.IngressInfo](ctx, c.client, "StartIngress", nil, req, opts...)
}

func (c *ingressInternalClient) ListActiveIngress(ctx context.Context, topic string, req *ListActiveIngressRequest, opts ...psrpc.RequestOption) (<-chan *psrpc.Response[*ListActiveIngressResponse], error) {
	return client.RequestMulti[*ListActiveIngressResponse](ctx, c.client, "ListActiveIngress", []string{topic}, req, opts...)
}

func (c *ingressInternalClient) KillIngressSession(ctx context.Context, ingressId string, resourceId string, req *KillIngressSessionRequest, opts ...psrpc.RequestOption) (*google_protobuf.Empty, error) {
	return client.RequestSingle[*google_protobuf.Empty](ctx, c.client, "KillIngressSession", []string{ingressId, resourceId}, req, opts...)
}

func (s *ingressInternalClient) Close() {
	s.client.Close()
}

// ======================
// IngressInternal Server
// ======================

type ingressInternalServer struct {
	svc IngressInternalServerImpl
	rpc *server.RPCServer
}

// NewIngressInternalServer builds a RPCServer that will route requests
// to the corresponding method in the provided svc implementation.
func NewIngressInternalServer(svc IngressInternalServerImpl, bus psrpc.MessageBus, opts ...psrpc.ServerOption) (IngressInternalServer, error) {
	sd := &info.ServiceDefinition{
		Name: "IngressInternal",
		ID:   rand.NewServerID(),
	}

	s := server.NewRPCServer(sd, bus, opts...)

	sd.RegisterMethod("StartIngress", true, false, true, false)
	var err error
	err = server.RegisterHandler(s, "StartIngress", nil, svc.StartIngress, svc.StartIngressAffinity)
	if err != nil {
		s.Close(false)
		return nil, err
	}

	sd.RegisterMethod("ListActiveIngress", false, true, false, false)
	sd.RegisterMethod("KillIngressSession", false, false, true, true)
	return &ingressInternalServer{
		svc: svc,
		rpc: s,
	}, nil
}

func (s *ingressInternalServer) RegisterListActiveIngressTopic(topic string) error {
	return server.RegisterHandler(s.rpc, "ListActiveIngress", []string{topic}, s.svc.ListActiveIngress, nil)
}

func (s *ingressInternalServer) DeregisterListActiveIngressTopic(topic string) {
	s.rpc.DeregisterHandler("ListActiveIngress", []string{topic})
}

func (s *ingressInternalServer) RegisterKillIngressSessionTopic(ingressId string, resourceId string) error {
	return server.RegisterHandler(s.rpc, "KillIngressSession", []string{ingressId, resourceId}, s.svc.KillIngressSession, nil)
}

func (s *ingressInternalServer) DeregisterKillIngressSessionTopic(ingressId string, resourceId string) {
	s.rpc.DeregisterHandler("KillIngressSession", []string{ingressId, resourceId})
}

func (s *ingressInternalServer) Shutdown() {
	s.rpc.Close(false)
}

func (s *ingressInternalServer) Kill() {
	s.rpc.Close(true)
}

// ====================================
// IngressInternal Unimplemented Server
// ====================================

type UnimplementedIngressInternalServer struct{}

func (UnimplementedIngressInternalServer) StartIngress(context.Context, *StartIngressRequest) (*livekit5.IngressInfo, error) {
	return nil, psrpc.ErrUnimplemented
}
func (UnimplementedIngressInternalServer) StartIngressAffinity(context.Context, *StartIngressRequest) float32 {
	return -1
}

func (UnimplementedIngressInternalServer) ListActiveIngress(context.Context, *ListActiveIngressRequest) (*ListActiveIngressResponse, error) {
	return nil, psrpc.ErrUnimplemented
}

func (UnimplementedIngressInternalServer) KillIngressSession(context.Context, *KillIngressSessionRequest) (*google_protobuf.Empty, error) {
	return nil, psrpc.ErrUnimplemented
}

// ===============================
// IngressHandler Client Interface
// ===============================

type IngressHandlerClient interface {
	UpdateIngress(ctx context.Context, topic string, req *livekit5.UpdateIngressRequest, opts ...psrpc.RequestOption) (*livekit5.IngressState, error)

	DeleteIngress(ctx context.Context, topic string, req *livekit5.DeleteIngressRequest, opts ...psrpc.RequestOption) (*livekit5.IngressState, error)

	DeleteWHIPResource(ctx context.Context, topic string, req *DeleteWHIPResourceRequest, opts ...psrpc.RequestOption) (*google_protobuf.Empty, error)

	ICERestartWHIPResource(ctx context.Context, topic string, req *ICERestartWHIPResourceRequest, opts ...psrpc.RequestOption) (*ICERestartWHIPResourceResponse, error)

	WHIPRTCConnectionNotify(ctx context.Context, topic string, req *WHIPRTCConnectionNotifyRequest, opts ...psrpc.RequestOption) (*google_protobuf.Empty, error)

	// Close immediately, without waiting for pending RPCs
	Close()
}

// ===================================
// IngressHandler ServerImpl Interface
// ===================================

type IngressHandlerServerImpl interface {
	UpdateIngress(context.Context, *livekit5.UpdateIngressRequest) (*livekit5.IngressState, error)

	DeleteIngress(context.Context, *livekit5.DeleteIngressRequest) (*livekit5.IngressState, error)

	DeleteWHIPResource(context.Context, *DeleteWHIPResourceRequest) (*google_protobuf.Empty, error)

	ICERestartWHIPResource(context.Context, *ICERestartWHIPResourceRequest) (*ICERestartWHIPResourceResponse, error)

	WHIPRTCConnectionNotify(context.Context, *WHIPRTCConnectionNotifyRequest) (*google_protobuf.Empty, error)
}

// ===============================
// IngressHandler Server Interface
// ===============================

type IngressHandlerServer interface {
	RegisterUpdateIngressTopic(topic string) error
	DeregisterUpdateIngressTopic(topic string)
	RegisterDeleteIngressTopic(topic string) error
	DeregisterDeleteIngressTopic(topic string)
	RegisterDeleteWHIPResourceTopic(topic string) error
	DeregisterDeleteWHIPResourceTopic(topic string)
	RegisterICERestartWHIPResourceTopic(topic string) error
	DeregisterICERestartWHIPResourceTopic(topic string)
	RegisterWHIPRTCConnectionNotifyTopic(topic string) error
	DeregisterWHIPRTCConnectionNotifyTopic(topic string)

	// Close and wait for pending RPCs to complete
	Shutdown()

	// Close immediately, without waiting for pending RPCs
	Kill()
}

// =====================
// IngressHandler Client
// =====================

type ingressHandlerClient struct {
	client *client.RPCClient
}

// NewIngressHandlerClient creates a psrpc client that implements the IngressHandlerClient interface.
func NewIngressHandlerClient(bus psrpc.MessageBus, opts ...psrpc.ClientOption) (IngressHandlerClient, error) {
	sd := &info.ServiceDefinition{
		Name: "IngressHandler",
		ID:   rand.NewClientID(),
	}

	sd.RegisterMethod("UpdateIngress", false, false, true, true)
	sd.RegisterMethod("DeleteIngress", false, false, true, true)
	sd.RegisterMethod("DeleteWHIPResource", false, false, true, true)
	sd.RegisterMethod("ICERestartWHIPResource", false, false, true, true)
	sd.RegisterMethod("WHIPRTCConnectionNotify", false, false, false, true)

	rpcClient, err := client.NewRPCClient(sd, bus, opts...)
	if err != nil {
		return nil, err
	}

	return &ingressHandlerClient{
		client: rpcClient,
	}, nil
}

func (c *ingressHandlerClient) UpdateIngress(ctx context.Context, topic string, req *livekit5.UpdateIngressRequest, opts ...psrpc.RequestOption) (*livekit5.IngressState, error) {
	return client.RequestSingle[*livekit5.IngressState](ctx, c.client, "UpdateIngress", []string{topic}, req, opts...)
}

func (c *ingressHandlerClient) DeleteIngress(ctx context.Context, topic string, req *livekit5.DeleteIngressRequest, opts ...psrpc.RequestOption) (*livekit5.IngressState, error) {
	return client.RequestSingle[*livekit5.IngressState](ctx, c.client, "DeleteIngress", []string{topic}, req, opts...)
}

func (c *ingressHandlerClient) DeleteWHIPResource(ctx context.Context, topic string, req *DeleteWHIPResourceRequest, opts ...psrpc.RequestOption) (*google_protobuf.Empty, error) {
	return client.RequestSingle[*google_protobuf.Empty](ctx, c.client, "DeleteWHIPResource", []string{topic}, req, opts...)
}

func (c *ingressHandlerClient) ICERestartWHIPResource(ctx context.Context, topic string, req *ICERestartWHIPResourceRequest, opts ...psrpc.RequestOption) (*ICERestartWHIPResourceResponse, error) {
	return client.RequestSingle[*ICERestartWHIPResourceResponse](ctx, c.client, "ICERestartWHIPResource", []string{topic}, req, opts...)
}

func (c *ingressHandlerClient) WHIPRTCConnectionNotify(ctx context.Context, topic string, req *WHIPRTCConnectionNotifyRequest, opts ...psrpc.RequestOption) (*google_protobuf.Empty, error) {
	return client.RequestSingle[*google_protobuf.Empty](ctx, c.client, "WHIPRTCConnectionNotify", []string{topic}, req, opts...)
}

func (s *ingressHandlerClient) Close() {
	s.client.Close()
}

// =====================
// IngressHandler Server
// =====================

type ingressHandlerServer struct {
	svc IngressHandlerServerImpl
	rpc *server.RPCServer
}

// NewIngressHandlerServer builds a RPCServer that will route requests
// to the corresponding method in the provided svc implementation.
func NewIngressHandlerServer(svc IngressHandlerServerImpl, bus psrpc.MessageBus, opts ...psrpc.ServerOption) (IngressHandlerServer, error) {
	sd := &info.ServiceDefinition{
		Name: "IngressHandler",
		ID:   rand.NewServerID(),
	}

	s := server.NewRPCServer(sd, bus, opts...)

	sd.RegisterMethod("UpdateIngress", false, false, true, true)
	sd.RegisterMethod("DeleteIngress", false, false, true, true)
	sd.RegisterMethod("DeleteWHIPResource", false, false, true, true)
	sd.RegisterMethod("ICERestartWHIPResource", false, false, true, true)
	sd.RegisterMethod("WHIPRTCConnectionNotify", false, false, false, true)
	return &ingressHandlerServer{
		svc: svc,
		rpc: s,
	}, nil
}

func (s *ingressHandlerServer) RegisterUpdateIngressTopic(topic string) error {
	return server.RegisterHandler(s.rpc, "UpdateIngress", []string{topic}, s.svc.UpdateIngress, nil)
}

func (s *ingressHandlerServer) DeregisterUpdateIngressTopic(topic string) {
	s.rpc.DeregisterHandler("UpdateIngress", []string{topic})
}

func (s *ingressHandlerServer) RegisterDeleteIngressTopic(topic string) error {
	return server.RegisterHandler(s.rpc, "DeleteIngress", []string{topic}, s.svc.DeleteIngress, nil)
}

func (s *ingressHandlerServer) DeregisterDeleteIngressTopic(topic string) {
	s.rpc.DeregisterHandler("DeleteIngress", []string{topic})
}

func (s *ingressHandlerServer) RegisterDeleteWHIPResourceTopic(topic string) error {
	return server.RegisterHandler(s.rpc, "DeleteWHIPResource", []string{topic}, s.svc.DeleteWHIPResource, nil)
}

func (s *ingressHandlerServer) DeregisterDeleteWHIPResourceTopic(topic string) {
	s.rpc.DeregisterHandler("DeleteWHIPResource", []string{topic})
}

func (s *ingressHandlerServer) RegisterICERestartWHIPResourceTopic(topic string) error {
	return server.RegisterHandler(s.rpc, "ICERestartWHIPResource", []string{topic}, s.svc.ICERestartWHIPResource, nil)
}

func (s *ingressHandlerServer) DeregisterICERestartWHIPResourceTopic(topic string) {
	s.rpc.DeregisterHandler("ICERestartWHIPResource", []string{topic})
}

func (s *ingressHandlerServer) RegisterWHIPRTCConnectionNotifyTopic(topic string) error {
	return server.RegisterHandler(s.rpc, "WHIPRTCConnectionNotify", []string{topic}, s.svc.WHIPRTCConnectionNotify, nil)
}

func (s *ingressHandlerServer) DeregisterWHIPRTCConnectionNotifyTopic(topic string) {
	s.rpc.DeregisterHandler("WHIPRTCConnectionNotify", []string{topic})
}

func (s *ingressHandlerServer) Shutdown() {
	s.rpc.Close(false)
}

func (s *ingressHandlerServer) Kill() {
	s.rpc.Close(true)
}

// ===================================
// IngressHandler Unimplemented Server
// ===================================

type UnimplementedIngressHandlerServer struct{}

func (UnimplementedIngressHandlerServer) UpdateIngress(context.Context, *livekit5.UpdateIngressRequest) (*livekit5.IngressState, error) {
	return nil, psrpc.ErrUnimplemented
}

func (UnimplementedIngressHandlerServer) DeleteIngress(context.Context, *livekit5.DeleteIngressRequest) (*livekit5.IngressState, error) {
	return nil, psrpc.ErrUnimplemented
}

func (UnimplementedIngressHandlerServer) DeleteWHIPResource(context.Context, *DeleteWHIPResourceRequest) (*google_protobuf.Empty, error) {
	return nil, psrpc.ErrUnimplemented
}

func (UnimplementedIngressHandlerServer) ICERestartWHIPResource(context.Context, *ICERestartWHIPResourceRequest) (*ICERestartWHIPResourceResponse, error) {
	return nil, psrpc.ErrUnimplemented
}

func (UnimplementedIngressHandlerServer) WHIPRTCConnectionNotify(context.Context, *WHIPRTCConnectionNotifyRequest) (*google_protobuf.Empty, error) {
	return nil, psrpc.ErrUnimplemented
}

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