github.com/mattdotmatt/gauge@v0.3.2-0.20160421115137-425a4cdccb62/gauge_messages/api_v2.pb.go

// Code generated by protoc-gen-go.
// source: api_v2.proto
// DO NOT EDIT!

package gauge_messages

import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"

import (
	context "golang.org/x/net/context"
	grpc "google.golang.org/grpc"
)

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

// Types of log level that gauge supports
type ExecutionRequest_LogLevel int32

const (
	ExecutionRequest_INFO    ExecutionRequest_LogLevel = 0
	ExecutionRequest_DEBUG   ExecutionRequest_LogLevel = 1
	ExecutionRequest_WARNING ExecutionRequest_LogLevel = 2
	ExecutionRequest_ERROR   ExecutionRequest_LogLevel = 3
)

var ExecutionRequest_LogLevel_name = map[int32]string{
	0: "INFO",
	1: "DEBUG",
	2: "WARNING",
	3: "ERROR",
}
var ExecutionRequest_LogLevel_value = map[string]int32{
	"INFO":    0,
	"DEBUG":   1,
	"WARNING": 2,
	"ERROR":   3,
}

func (x ExecutionRequest_LogLevel) Enum() *ExecutionRequest_LogLevel {
	p := new(ExecutionRequest_LogLevel)
	*p = x
	return p
}
func (x ExecutionRequest_LogLevel) String() string {
	return proto.EnumName(ExecutionRequest_LogLevel_name, int32(x))
}
func (x *ExecutionRequest_LogLevel) UnmarshalJSON(data []byte) error {
	value, err := proto.UnmarshalJSONEnum(ExecutionRequest_LogLevel_value, data, "ExecutionRequest_LogLevel")
	if err != nil {
		return err
	}
	*x = ExecutionRequest_LogLevel(value)
	return nil
}
func (ExecutionRequest_LogLevel) EnumDescriptor() ([]byte, []int) { return fileDescriptor1, []int{0, 0} }

// Strategies for parallelization
type ExecutionRequest_Strategy int32

const (
	ExecutionRequest_LAZY  ExecutionRequest_Strategy = 0
	ExecutionRequest_EAGER ExecutionRequest_Strategy = 1
)

var ExecutionRequest_Strategy_name = map[int32]string{
	0: "LAZY",
	1: "EAGER",
}
var ExecutionRequest_Strategy_value = map[string]int32{
	"LAZY":  0,
	"EAGER": 1,
}

func (x ExecutionRequest_Strategy) Enum() *ExecutionRequest_Strategy {
	p := new(ExecutionRequest_Strategy)
	*p = x
	return p
}
func (x ExecutionRequest_Strategy) String() string {
	return proto.EnumName(ExecutionRequest_Strategy_name, int32(x))
}
func (x *ExecutionRequest_Strategy) UnmarshalJSON(data []byte) error {
	value, err := proto.UnmarshalJSONEnum(ExecutionRequest_Strategy_value, data, "ExecutionRequest_Strategy")
	if err != nil {
		return err
	}
	*x = ExecutionRequest_Strategy(value)
	return nil
}
func (ExecutionRequest_Strategy) EnumDescriptor() ([]byte, []int) { return fileDescriptor1, []int{0, 1} }

// Types of Execution result
type ExecutionResponse_ExecutionResponseType int32

const (
	ExecutionResponse_ScenarioResult           ExecutionResponse_ExecutionResponseType = 0
	ExecutionResponse_BeforeSuiteHookResult    ExecutionResponse_ExecutionResponseType = 1
	ExecutionResponse_AfterSuiteHookResult     ExecutionResponse_ExecutionResponseType = 2
	ExecutionResponse_BeforeSpecHookResult     ExecutionResponse_ExecutionResponseType = 3
	ExecutionResponse_AfterSpecHookResult      ExecutionResponse_ExecutionResponseType = 4
	ExecutionResponse_SuiteDataStoreInitResult ExecutionResponse_ExecutionResponseType = 5
	ExecutionResponse_SpecDataStoreInitResult  ExecutionResponse_ExecutionResponseType = 6
	ExecutionResponse_ValidationResult         ExecutionResponse_ExecutionResponseType = 7
)

var ExecutionResponse_ExecutionResponseType_name = map[int32]string{
	0: "ScenarioResult",
	1: "BeforeSuiteHookResult",
	2: "AfterSuiteHookResult",
	3: "BeforeSpecHookResult",
	4: "AfterSpecHookResult",
	5: "SuiteDataStoreInitResult",
	6: "SpecDataStoreInitResult",
	7: "ValidationResult",
}
var ExecutionResponse_ExecutionResponseType_value = map[string]int32{
	"ScenarioResult":           0,
	"BeforeSuiteHookResult":    1,
	"AfterSuiteHookResult":     2,
	"BeforeSpecHookResult":     3,
	"AfterSpecHookResult":      4,
	"SuiteDataStoreInitResult": 5,
	"SpecDataStoreInitResult":  6,
	"ValidationResult":         7,
}

func (x ExecutionResponse_ExecutionResponseType) Enum() *ExecutionResponse_ExecutionResponseType {
	p := new(ExecutionResponse_ExecutionResponseType)
	*p = x
	return p
}
func (x ExecutionResponse_ExecutionResponseType) String() string {
	return proto.EnumName(ExecutionResponse_ExecutionResponseType_name, int32(x))
}
func (x *ExecutionResponse_ExecutionResponseType) UnmarshalJSON(data []byte) error {
	value, err := proto.UnmarshalJSONEnum(ExecutionResponse_ExecutionResponseType_value, data, "ExecutionResponse_ExecutionResponseType")
	if err != nil {
		return err
	}
	*x = ExecutionResponse_ExecutionResponseType(value)
	return nil
}
func (ExecutionResponse_ExecutionResponseType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor1, []int{1, 0}
}

// Specifies the execution status
type ExecutionResponse_Status int32

const (
	ExecutionResponse_PASSED  ExecutionResponse_Status = 0
	ExecutionResponse_FAILED  ExecutionResponse_Status = 1
	ExecutionResponse_SKIPPED ExecutionResponse_Status = 2
)

var ExecutionResponse_Status_name = map[int32]string{
	0: "PASSED",
	1: "FAILED",
	2: "SKIPPED",
}
var ExecutionResponse_Status_value = map[string]int32{
	"PASSED":  0,
	"FAILED":  1,
	"SKIPPED": 2,
}

func (x ExecutionResponse_Status) Enum() *ExecutionResponse_Status {
	p := new(ExecutionResponse_Status)
	*p = x
	return p
}
func (x ExecutionResponse_Status) String() string {
	return proto.EnumName(ExecutionResponse_Status_name, int32(x))
}
func (x *ExecutionResponse_Status) UnmarshalJSON(data []byte) error {
	value, err := proto.UnmarshalJSONEnum(ExecutionResponse_Status_value, data, "ExecutionResponse_Status")
	if err != nil {
		return err
	}
	*x = ExecutionResponse_Status(value)
	return nil
}
func (ExecutionResponse_Status) EnumDescriptor() ([]byte, []int) { return fileDescriptor1, []int{1, 1} }

// ExecutionRequest defines the structure of requests that the API's consumers can send to request execution of specs/scenarios
type ExecutionRequest struct {
	// Each ExecutionRequest can ask to execute multiple spec files or multiple scenarios in a spec or a directory or all
	Specs []string `protobuf:"bytes,1,rep,name=specs" json:"specs,omitempty"`
	// Tag expression to filter specs and scenarios during execution. Default: ""
	Tags *string `protobuf:"bytes,2,opt,name=tags" json:"tags,omitempty"`
	// The working directory for gauge.
	WorkingDir *string `protobuf:"bytes,3,opt,name=workingDir" json:"workingDir,omitempty"`
	// Environment to choose for gauge.
	Environment *string                    `protobuf:"bytes,4,opt,name=environment" json:"environment,omitempty"`
	LogLevel    *ExecutionRequest_LogLevel `protobuf:"varint,5,opt,name=logLevel,enum=gauge.messages.ExecutionRequest_LogLevel" json:"logLevel,omitempty"`
	// Whether to run gauge in parallel mode.
	IsParallel *bool `protobuf:"varint,6,opt,name=isParallel" json:"isParallel,omitempty"`
	// If isParallel is true, this specifies how many parallel streams to run.
	ParallelStreams *int32 `protobuf:"varint,7,opt,name=parallelStreams" json:"parallelStreams,omitempty"`
	// Specify which group of specs to execute, based on number of parallel streams. Works only when strategy is EAGER.
	Group *int32 `protobuf:"varint,8,opt,name=group" json:"group,omitempty"`
	// Toggles simple console reporting
	SimpleConsole *bool `protobuf:"varint,9,opt,name=simpleConsole" json:"simpleConsole,omitempty"`
	// If true, sorts execution of specifications alphabetically
	Sort     *bool                      `protobuf:"varint,10,opt,name=sort" json:"sort,omitempty"`
	Strategy *ExecutionRequest_Strategy `protobuf:"varint,11,opt,name=strategy,enum=gauge.messages.ExecutionRequest_Strategy" json:"strategy,omitempty"`
	// Specify against which rows of datatable the scenarios should be executed
	TableRows        *string `protobuf:"bytes,12,opt,name=tableRows" json:"tableRows,omitempty"`
	XXX_unrecognized []byte  `json:"-"`
}

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

func (m *ExecutionRequest) GetSpecs() []string {
	if m != nil {
		return m.Specs
	}
	return nil
}

func (m *ExecutionRequest) GetTags() string {
	if m != nil && m.Tags != nil {
		return *m.Tags
	}
	return ""
}

func (m *ExecutionRequest) GetWorkingDir() string {
	if m != nil && m.WorkingDir != nil {
		return *m.WorkingDir
	}
	return ""
}

func (m *ExecutionRequest) GetEnvironment() string {
	if m != nil && m.Environment != nil {
		return *m.Environment
	}
	return ""
}

func (m *ExecutionRequest) GetLogLevel() ExecutionRequest_LogLevel {
	if m != nil && m.LogLevel != nil {
		return *m.LogLevel
	}
	return ExecutionRequest_INFO
}

func (m *ExecutionRequest) GetIsParallel() bool {
	if m != nil && m.IsParallel != nil {
		return *m.IsParallel
	}
	return false
}

func (m *ExecutionRequest) GetParallelStreams() int32 {
	if m != nil && m.ParallelStreams != nil {
		return *m.ParallelStreams
	}
	return 0
}

func (m *ExecutionRequest) GetGroup() int32 {
	if m != nil && m.Group != nil {
		return *m.Group
	}
	return 0
}

func (m *ExecutionRequest) GetSimpleConsole() bool {
	if m != nil && m.SimpleConsole != nil {
		return *m.SimpleConsole
	}
	return false
}

func (m *ExecutionRequest) GetSort() bool {
	if m != nil && m.Sort != nil {
		return *m.Sort
	}
	return false
}

func (m *ExecutionRequest) GetStrategy() ExecutionRequest_Strategy {
	if m != nil && m.Strategy != nil {
		return *m.Strategy
	}
	return ExecutionRequest_LAZY
}

func (m *ExecutionRequest) GetTableRows() string {
	if m != nil && m.TableRows != nil {
		return *m.TableRows
	}
	return ""
}

// ExecutionResponse defines the structure of response for ExecutionRequest message
type ExecutionResponse struct {
	Type *ExecutionResponse_ExecutionResponseType `protobuf:"varint,1,req,name=type,enum=gauge.messages.ExecutionResponse_ExecutionResponseType" json:"type,omitempty"`
	// An identifier for the current execution result
	ID     *string                   `protobuf:"bytes,2,opt,name=ID" json:"ID,omitempty"`
	Status *ExecutionResponse_Status `protobuf:"varint,3,opt,name=status,enum=gauge.messages.ExecutionResponse_Status" json:"status,omitempty"`
	// Contains the Execution error and its details
	Error         []*ExecutionResponse_ExecutionError `protobuf:"bytes,4,rep,name=error" json:"error,omitempty"`
	ExecutionTime *int64                              `protobuf:"varint,5,opt,name=executionTime" json:"executionTime,omitempty"`
	// Contains the console output messages
	Stdout           *string `protobuf:"bytes,6,opt,name=stdout" json:"stdout,omitempty"`
	XXX_unrecognized []byte  `json:"-"`
}

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

func (m *ExecutionResponse) GetType() ExecutionResponse_ExecutionResponseType {
	if m != nil && m.Type != nil {
		return *m.Type
	}
	return ExecutionResponse_ScenarioResult
}

func (m *ExecutionResponse) GetID() string {
	if m != nil && m.ID != nil {
		return *m.ID
	}
	return ""
}

func (m *ExecutionResponse) GetStatus() ExecutionResponse_Status {
	if m != nil && m.Status != nil {
		return *m.Status
	}
	return ExecutionResponse_PASSED
}

func (m *ExecutionResponse) GetError() []*ExecutionResponse_ExecutionError {
	if m != nil {
		return m.Error
	}
	return nil
}

func (m *ExecutionResponse) GetExecutionTime() int64 {
	if m != nil && m.ExecutionTime != nil {
		return *m.ExecutionTime
	}
	return 0
}

func (m *ExecutionResponse) GetStdout() string {
	if m != nil && m.Stdout != nil {
		return *m.Stdout
	}
	return ""
}

// Specifies the execution time
// ExecutionError represents the failure during execution along with details of failure
type ExecutionResponse_ExecutionError struct {
	// Stacktrace from the failure
	StackTrace *string `protobuf:"bytes,1,opt,name=stackTrace" json:"stackTrace,omitempty"`
	// Error message from the failure
	ErrorMessage *string `protobuf:"bytes,2,opt,name=errorMessage" json:"errorMessage,omitempty"`
	// Byte array holding the screenshot taken at the time of failure.
	ScreenShot       []byte `protobuf:"bytes,3,opt,name=screenShot" json:"screenShot,omitempty"`
	XXX_unrecognized []byte `json:"-"`
}

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

func (m *ExecutionResponse_ExecutionError) GetStackTrace() string {
	if m != nil && m.StackTrace != nil {
		return *m.StackTrace
	}
	return ""
}

func (m *ExecutionResponse_ExecutionError) GetErrorMessage() string {
	if m != nil && m.ErrorMessage != nil {
		return *m.ErrorMessage
	}
	return ""
}

func (m *ExecutionResponse_ExecutionError) GetScreenShot() []byte {
	if m != nil {
		return m.ScreenShot
	}
	return nil
}

func init() {
	proto.RegisterType((*ExecutionRequest)(nil), "gauge.messages.ExecutionRequest")
	proto.RegisterType((*ExecutionResponse)(nil), "gauge.messages.ExecutionResponse")
	proto.RegisterType((*ExecutionResponse_ExecutionError)(nil), "gauge.messages.ExecutionResponse.ExecutionError")
	proto.RegisterEnum("gauge.messages.ExecutionRequest_LogLevel", ExecutionRequest_LogLevel_name, ExecutionRequest_LogLevel_value)
	proto.RegisterEnum("gauge.messages.ExecutionRequest_Strategy", ExecutionRequest_Strategy_name, ExecutionRequest_Strategy_value)
	proto.RegisterEnum("gauge.messages.ExecutionResponse_ExecutionResponseType", ExecutionResponse_ExecutionResponseType_name, ExecutionResponse_ExecutionResponseType_value)
	proto.RegisterEnum("gauge.messages.ExecutionResponse_Status", ExecutionResponse_Status_name, ExecutionResponse_Status_value)
}

// Reference imports to suppress errors if they are not otherwise used.
var _ context.Context
var _ grpc.ClientConn

// Client API for Execution service

type ExecutionClient interface {
	// Bind RPC method
	Execute(ctx context.Context, in *ExecutionRequest, opts ...grpc.CallOption) (Execution_ExecuteClient, error)
}

type executionClient struct {
	cc *grpc.ClientConn
}

func NewExecutionClient(cc *grpc.ClientConn) ExecutionClient {
	return &executionClient{cc}
}

func (c *executionClient) Execute(ctx context.Context, in *ExecutionRequest, opts ...grpc.CallOption) (Execution_ExecuteClient, error) {
	stream, err := grpc.NewClientStream(ctx, &_Execution_serviceDesc.Streams[0], c.cc, "/gauge.messages.Execution/execute", opts...)
	if err != nil {
		return nil, err
	}
	x := &executionExecuteClient{stream}
	if err := x.ClientStream.SendMsg(in); err != nil {
		return nil, err
	}
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	return x, nil
}

type Execution_ExecuteClient interface {
	Recv() (*ExecutionResponse, error)
	grpc.ClientStream
}

type executionExecuteClient struct {
	grpc.ClientStream
}

func (x *executionExecuteClient) Recv() (*ExecutionResponse, error) {
	m := new(ExecutionResponse)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

// Server API for Execution service

type ExecutionServer interface {
	// Bind RPC method
	Execute(*ExecutionRequest, Execution_ExecuteServer) error
}

func RegisterExecutionServer(s *grpc.Server, srv ExecutionServer) {
	s.RegisterService(&_Execution_serviceDesc, srv)
}

func _Execution_Execute_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(ExecutionRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(ExecutionServer).Execute(m, &executionExecuteServer{stream})
}

type Execution_ExecuteServer interface {
	Send(*ExecutionResponse) error
	grpc.ServerStream
}

type executionExecuteServer struct {
	grpc.ServerStream
}

func (x *executionExecuteServer) Send(m *ExecutionResponse) error {
	return x.ServerStream.SendMsg(m)
}

var _Execution_serviceDesc = grpc.ServiceDesc{
	ServiceName: "gauge.messages.Execution",
	HandlerType: (*ExecutionServer)(nil),
	Methods:     []grpc.MethodDesc{},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "execute",
			Handler:       _Execution_Execute_Handler,
			ServerStreams: true,
		},
	},
}

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