// Code generated by protoc-gen-go. DO NOT EDIT.
// source: test_platform/steps/execution.proto

package steps

import (
	fmt "fmt"
	proto "github.com/golang/protobuf/proto"
	test_platform "go.chromium.org/chromiumos/infra/proto/go/test_platform"
	common "go.chromium.org/chromiumos/infra/proto/go/test_platform/common"
	config "go.chromium.org/chromiumos/infra/proto/go/test_platform/config"
	math "math"
)

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

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

type ExecuteRequests struct {
	// Each ExecuteRequest is handled independently.
	Requests             []*ExecuteRequest          `protobuf:"bytes,1,rep,name=requests,proto3" json:"requests,omitempty"`
	TaggedRequests       map[string]*ExecuteRequest `protobuf:"bytes,2,rep,name=tagged_requests,json=taggedRequests,proto3" json:"tagged_requests,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	XXX_NoUnkeyedLiteral struct{}                   `json:"-"`
	XXX_unrecognized     []byte                     `json:"-"`
	XXX_sizecache        int32                      `json:"-"`
}

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

func (m *ExecuteRequests) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ExecuteRequests.Unmarshal(m, b)
}
func (m *ExecuteRequests) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ExecuteRequests.Marshal(b, m, deterministic)
}
func (m *ExecuteRequests) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ExecuteRequests.Merge(m, src)
}
func (m *ExecuteRequests) XXX_Size() int {
	return xxx_messageInfo_ExecuteRequests.Size(m)
}
func (m *ExecuteRequests) XXX_DiscardUnknown() {
	xxx_messageInfo_ExecuteRequests.DiscardUnknown(m)
}

var xxx_messageInfo_ExecuteRequests proto.InternalMessageInfo

func (m *ExecuteRequests) GetRequests() []*ExecuteRequest {
	if m != nil {
		return m.Requests
	}
	return nil
}

func (m *ExecuteRequests) GetTaggedRequests() map[string]*ExecuteRequest {
	if m != nil {
		return m.TaggedRequests
	}
	return nil
}

type ExecuteResponses struct {
	// Each ExecuteResponse corresponds to a single ExecuteRequest handled
	// independently.
	Responses            []*ExecuteResponse          `protobuf:"bytes,1,rep,name=responses,proto3" json:"responses,omitempty"`
	TaggedResponses      map[string]*ExecuteResponse `protobuf:"bytes,2,rep,name=tagged_responses,json=taggedResponses,proto3" json:"tagged_responses,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	XXX_NoUnkeyedLiteral struct{}                    `json:"-"`
	XXX_unrecognized     []byte                      `json:"-"`
	XXX_sizecache        int32                       `json:"-"`
}

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

func (m *ExecuteResponses) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ExecuteResponses.Unmarshal(m, b)
}
func (m *ExecuteResponses) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ExecuteResponses.Marshal(b, m, deterministic)
}
func (m *ExecuteResponses) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ExecuteResponses.Merge(m, src)
}
func (m *ExecuteResponses) XXX_Size() int {
	return xxx_messageInfo_ExecuteResponses.Size(m)
}
func (m *ExecuteResponses) XXX_DiscardUnknown() {
	xxx_messageInfo_ExecuteResponses.DiscardUnknown(m)
}

var xxx_messageInfo_ExecuteResponses proto.InternalMessageInfo

func (m *ExecuteResponses) GetResponses() []*ExecuteResponse {
	if m != nil {
		return m.Responses
	}
	return nil
}

func (m *ExecuteResponses) GetTaggedResponses() map[string]*ExecuteResponse {
	if m != nil {
		return m.TaggedResponses
	}
	return nil
}

// ExecuteRequest defines the input of the Execute step.
type ExecuteRequest struct {
	// RequestParams are the request-wide parameters for the
	// cros_test_platform request. This includes all the request-wide information
	// needed in order to execute tests (e.g. labels, retry parameters,
	// scheduling parameters).
	RequestParams        *test_platform.Request_Params `protobuf:"bytes,1,opt,name=request_params,json=requestParams,proto3" json:"request_params,omitempty"`
	Enumeration          *EnumerationResponse          `protobuf:"bytes,2,opt,name=enumeration,proto3" json:"enumeration,omitempty"`
	Config               *config.Config                `protobuf:"bytes,3,opt,name=config,proto3" json:"config,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                      `json:"-"`
	XXX_unrecognized     []byte                        `json:"-"`
	XXX_sizecache        int32                         `json:"-"`
}

func (m *ExecuteRequest) Reset()         { *m = ExecuteRequest{} }
func (m *ExecuteRequest) String() string { return proto.CompactTextString(m) }
func (*ExecuteRequest) ProtoMessage()    {}
func (*ExecuteRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_54d6d12c45be2188, []int{2}
}

func (m *ExecuteRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ExecuteRequest.Unmarshal(m, b)
}
func (m *ExecuteRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ExecuteRequest.Marshal(b, m, deterministic)
}
func (m *ExecuteRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ExecuteRequest.Merge(m, src)
}
func (m *ExecuteRequest) XXX_Size() int {
	return xxx_messageInfo_ExecuteRequest.Size(m)
}
func (m *ExecuteRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_ExecuteRequest.DiscardUnknown(m)
}

var xxx_messageInfo_ExecuteRequest proto.InternalMessageInfo

func (m *ExecuteRequest) GetRequestParams() *test_platform.Request_Params {
	if m != nil {
		return m.RequestParams
	}
	return nil
}

func (m *ExecuteRequest) GetEnumeration() *EnumerationResponse {
	if m != nil {
		return m.Enumeration
	}
	return nil
}

func (m *ExecuteRequest) GetConfig() *config.Config {
	if m != nil {
		return m.Config
	}
	return nil
}

// ExecuteResponse defines the output of the Execute step.
type ExecuteResponse struct {
	// TODO(crbug.com/1020326) Deprecate and delete this in favor of
	// consolidated_results.
	TaskResults []*ExecuteResponse_TaskResult `protobuf:"bytes,1,rep,name=task_results,json=taskResults,proto3" json:"task_results,omitempty"`
	// Note: Autotest backend does not (and can not) set consolidated_results.
	// See crbug.com/1020326
	ConsolidatedResults []*ExecuteResponse_ConsolidatedResult `protobuf:"bytes,3,rep,name=consolidated_results,json=consolidatedResults,proto3" json:"consolidated_results,omitempty"`
	// State encodes the state of the overall execution, including the ultimate
	// verdict (taking into account any sub-task verdicts).
	State                *test_platform.TaskState `protobuf:"bytes,2,opt,name=state,proto3" json:"state,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                 `json:"-"`
	XXX_unrecognized     []byte                   `json:"-"`
	XXX_sizecache        int32                    `json:"-"`
}

func (m *ExecuteResponse) Reset()         { *m = ExecuteResponse{} }
func (m *ExecuteResponse) String() string { return proto.CompactTextString(m) }
func (*ExecuteResponse) ProtoMessage()    {}
func (*ExecuteResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_54d6d12c45be2188, []int{3}
}

func (m *ExecuteResponse) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ExecuteResponse.Unmarshal(m, b)
}
func (m *ExecuteResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ExecuteResponse.Marshal(b, m, deterministic)
}
func (m *ExecuteResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ExecuteResponse.Merge(m, src)
}
func (m *ExecuteResponse) XXX_Size() int {
	return xxx_messageInfo_ExecuteResponse.Size(m)
}
func (m *ExecuteResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_ExecuteResponse.DiscardUnknown(m)
}

var xxx_messageInfo_ExecuteResponse proto.InternalMessageInfo

func (m *ExecuteResponse) GetTaskResults() []*ExecuteResponse_TaskResult {
	if m != nil {
		return m.TaskResults
	}
	return nil
}

func (m *ExecuteResponse) GetConsolidatedResults() []*ExecuteResponse_ConsolidatedResult {
	if m != nil {
		return m.ConsolidatedResults
	}
	return nil
}

func (m *ExecuteResponse) GetState() *test_platform.TaskState {
	if m != nil {
		return m.State
	}
	return nil
}

type ExecuteResponse_TaskResult struct {
	// URL at which a human can view the task's run state (e.g. link to
	// swarming or cautotest job view).
	TaskUrl string                   `protobuf:"bytes,2,opt,name=task_url,json=taskUrl,proto3" json:"task_url,omitempty"`
	State   *test_platform.TaskState `protobuf:"bytes,3,opt,name=state,proto3" json:"state,omitempty"`
	Name    string                   `protobuf:"bytes,4,opt,name=name,proto3" json:"name,omitempty"`
	// URL at which a human can view the task's logs (e.g. a link to
	// stainless gs viewer for this task).
	LogUrl string `protobuf:"bytes,5,opt,name=log_url,json=logUrl,proto3" json:"log_url,omitempty"`
	// The attempt number, starting at 0.
	// Within an execution, the tuple (name, attempt) will be unique.
	Attempt int32 `protobuf:"varint,6,opt,name=attempt,proto3" json:"attempt,omitempty"`
	// The results of individual test cases that were executed as part of
	// the task.
	TestCases []*ExecuteResponse_TaskResult_TestCaseResult `protobuf:"bytes,7,rep,name=test_cases,json=testCases,proto3" json:"test_cases,omitempty"`
	// The results of steps run prior to running the actual tests
	// (e.g. provision).
	PrejobSteps []*ExecuteResponse_TaskResult_TestCaseResult `protobuf:"bytes,8,rep,name=prejob_steps,json=prejobSteps,proto3" json:"prejob_steps,omitempty"`
	// Logdata is the location at which the task's full output will
	// eventually be available. Not intended for human's to view; use
	// log_url instead.
	LogData *common.TaskLogData `protobuf:"bytes,9,opt,name=log_data,json=logData,proto3" json:"log_data,omitempty"`
	// Location, as URL, at which to place low-latency, high-importance
	// log data which fails the task if not offloaded properly.
	SynchronousLogDataUrl string   `protobuf:"bytes,10,opt,name=synchronous_log_data_url,json=synchronousLogDataUrl,proto3" json:"synchronous_log_data_url,omitempty"`
	XXX_NoUnkeyedLiteral  struct{} `json:"-"`
	XXX_unrecognized      []byte   `json:"-"`
	XXX_sizecache         int32    `json:"-"`
}

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

func (m *ExecuteResponse_TaskResult) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ExecuteResponse_TaskResult.Unmarshal(m, b)
}
func (m *ExecuteResponse_TaskResult) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ExecuteResponse_TaskResult.Marshal(b, m, deterministic)
}
func (m *ExecuteResponse_TaskResult) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ExecuteResponse_TaskResult.Merge(m, src)
}
func (m *ExecuteResponse_TaskResult) XXX_Size() int {
	return xxx_messageInfo_ExecuteResponse_TaskResult.Size(m)
}
func (m *ExecuteResponse_TaskResult) XXX_DiscardUnknown() {
	xxx_messageInfo_ExecuteResponse_TaskResult.DiscardUnknown(m)
}

var xxx_messageInfo_ExecuteResponse_TaskResult proto.InternalMessageInfo

func (m *ExecuteResponse_TaskResult) GetTaskUrl() string {
	if m != nil {
		return m.TaskUrl
	}
	return ""
}

func (m *ExecuteResponse_TaskResult) GetState() *test_platform.TaskState {
	if m != nil {
		return m.State
	}
	return nil
}

func (m *ExecuteResponse_TaskResult) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

func (m *ExecuteResponse_TaskResult) GetLogUrl() string {
	if m != nil {
		return m.LogUrl
	}
	return ""
}

func (m *ExecuteResponse_TaskResult) GetAttempt() int32 {
	if m != nil {
		return m.Attempt
	}
	return 0
}

func (m *ExecuteResponse_TaskResult) GetTestCases() []*ExecuteResponse_TaskResult_TestCaseResult {
	if m != nil {
		return m.TestCases
	}
	return nil
}

func (m *ExecuteResponse_TaskResult) GetPrejobSteps() []*ExecuteResponse_TaskResult_TestCaseResult {
	if m != nil {
		return m.PrejobSteps
	}
	return nil
}

func (m *ExecuteResponse_TaskResult) GetLogData() *common.TaskLogData {
	if m != nil {
		return m.LogData
	}
	return nil
}

func (m *ExecuteResponse_TaskResult) GetSynchronousLogDataUrl() string {
	if m != nil {
		return m.SynchronousLogDataUrl
	}
	return ""
}

type ExecuteResponse_TaskResult_TestCaseResult struct {
	// Test case name which is generally independent from task name.
	// E.g. a task named "tast.critical-system" may have a test case
	// named "tast.audio.DevicePlay".
	// For tasks with a single test case it will generally be the same
	// as the task name, e.g. "logging_UserCrash".
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// Verdict describes whether the test case passed, failed, or had
	// some other indefinite verdict.
	Verdict test_platform.TaskState_Verdict `protobuf:"varint,2,opt,name=verdict,proto3,enum=test_platform.TaskState_Verdict" json:"verdict,omitempty"`
	// A one line human readable description of what happened during
	// test case execution (e.g. error/warning message). Not intended
	// to be machine parseable. There's no guarantee that a given root
	// cause will always resolve to the same summary.
	HumanReadableSummary string   `protobuf:"bytes,3,opt,name=human_readable_summary,json=humanReadableSummary,proto3" json:"human_readable_summary,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

func (m *ExecuteResponse_TaskResult_TestCaseResult) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ExecuteResponse_TaskResult_TestCaseResult.Unmarshal(m, b)
}
func (m *ExecuteResponse_TaskResult_TestCaseResult) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ExecuteResponse_TaskResult_TestCaseResult.Marshal(b, m, deterministic)
}
func (m *ExecuteResponse_TaskResult_TestCaseResult) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ExecuteResponse_TaskResult_TestCaseResult.Merge(m, src)
}
func (m *ExecuteResponse_TaskResult_TestCaseResult) XXX_Size() int {
	return xxx_messageInfo_ExecuteResponse_TaskResult_TestCaseResult.Size(m)
}
func (m *ExecuteResponse_TaskResult_TestCaseResult) XXX_DiscardUnknown() {
	xxx_messageInfo_ExecuteResponse_TaskResult_TestCaseResult.DiscardUnknown(m)
}

var xxx_messageInfo_ExecuteResponse_TaskResult_TestCaseResult proto.InternalMessageInfo

func (m *ExecuteResponse_TaskResult_TestCaseResult) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

func (m *ExecuteResponse_TaskResult_TestCaseResult) GetVerdict() test_platform.TaskState_Verdict {
	if m != nil {
		return m.Verdict
	}
	return test_platform.TaskState_VERDICT_UNSPECIFIED
}

func (m *ExecuteResponse_TaskResult_TestCaseResult) GetHumanReadableSummary() string {
	if m != nil {
		return m.HumanReadableSummary
	}
	return ""
}

type ExecuteResponse_ConsolidatedResult struct {
	// result for each attempt of the corresponding enumeration.
	Attempts             []*ExecuteResponse_TaskResult `protobuf:"bytes,1,rep,name=attempts,proto3" json:"attempts,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                      `json:"-"`
	XXX_unrecognized     []byte                        `json:"-"`
	XXX_sizecache        int32                         `json:"-"`
}

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

func (m *ExecuteResponse_ConsolidatedResult) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ExecuteResponse_ConsolidatedResult.Unmarshal(m, b)
}
func (m *ExecuteResponse_ConsolidatedResult) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ExecuteResponse_ConsolidatedResult.Marshal(b, m, deterministic)
}
func (m *ExecuteResponse_ConsolidatedResult) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ExecuteResponse_ConsolidatedResult.Merge(m, src)
}
func (m *ExecuteResponse_ConsolidatedResult) XXX_Size() int {
	return xxx_messageInfo_ExecuteResponse_ConsolidatedResult.Size(m)
}
func (m *ExecuteResponse_ConsolidatedResult) XXX_DiscardUnknown() {
	xxx_messageInfo_ExecuteResponse_ConsolidatedResult.DiscardUnknown(m)
}

var xxx_messageInfo_ExecuteResponse_ConsolidatedResult proto.InternalMessageInfo

func (m *ExecuteResponse_ConsolidatedResult) GetAttempts() []*ExecuteResponse_TaskResult {
	if m != nil {
		return m.Attempts
	}
	return nil
}

func init() {
	proto.RegisterType((*ExecuteRequests)(nil), "test_platform.steps.ExecuteRequests")
	proto.RegisterMapType((map[string]*ExecuteRequest)(nil), "test_platform.steps.ExecuteRequests.TaggedRequestsEntry")
	proto.RegisterType((*ExecuteResponses)(nil), "test_platform.steps.ExecuteResponses")
	proto.RegisterMapType((map[string]*ExecuteResponse)(nil), "test_platform.steps.ExecuteResponses.TaggedResponsesEntry")
	proto.RegisterType((*ExecuteRequest)(nil), "test_platform.steps.ExecuteRequest")
	proto.RegisterType((*ExecuteResponse)(nil), "test_platform.steps.ExecuteResponse")
	proto.RegisterType((*ExecuteResponse_TaskResult)(nil), "test_platform.steps.ExecuteResponse.TaskResult")
	proto.RegisterType((*ExecuteResponse_TaskResult_TestCaseResult)(nil), "test_platform.steps.ExecuteResponse.TaskResult.TestCaseResult")
	proto.RegisterType((*ExecuteResponse_ConsolidatedResult)(nil), "test_platform.steps.ExecuteResponse.ConsolidatedResult")
}

func init() {
	proto.RegisterFile("test_platform/steps/execution.proto", fileDescriptor_54d6d12c45be2188)
}

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