go/testplans/suite_scheduler.pb.go

// Code generated by protoc-gen-go. DO NOT EDIT.
// source: testplans/suite_scheduler.proto

package testplans

import (
	fmt "fmt"
	proto "github.com/golang/protobuf/proto"
	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

// Branches that can be targeted.
type Branch int32

const (
	Branch_BRANCH_UNSPECIFIED Branch = 0
	// Canary Branch or ToT.
	Branch_CANARY Branch = 1
	// Dev Branch or ToT-1.
	Branch_DEV Branch = 2
	// Beta Branch or ToT-2.
	Branch_BETA Branch = 3
	// Stable Branch or ToT-3.
	Branch_STABLE Branch = 4
)

var Branch_name = map[int32]string{
	0: "BRANCH_UNSPECIFIED",
	1: "CANARY",
	2: "DEV",
	3: "BETA",
	4: "STABLE",
}

var Branch_value = map[string]int32{
	"BRANCH_UNSPECIFIED": 0,
	"CANARY":             1,
	"DEV":                2,
	"BETA":               3,
	"STABLE":             4,
}

func (x Branch) String() string {
	return proto.EnumName(Branch_name, int32(x))
}

func (Branch) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_905bf28b41c26c54, []int{0}
}

// Whether to use firmware from ToT or firmware branch.
type SchedulerConfig_FirmwareBranch int32

const (
	SchedulerConfig_UNSPECIFIED SchedulerConfig_FirmwareBranch = 0
	// ToT branch.
	SchedulerConfig_CROS SchedulerConfig_FirmwareBranch = 1
	// Firmware branch.
	SchedulerConfig_FIRMWARE SchedulerConfig_FirmwareBranch = 2
)

var SchedulerConfig_FirmwareBranch_name = map[int32]string{
	0: "UNSPECIFIED",
	1: "CROS",
	2: "FIRMWARE",
}

var SchedulerConfig_FirmwareBranch_value = map[string]int32{
	"UNSPECIFIED": 0,
	"CROS":        1,
	"FIRMWARE":    2,
}

func (x SchedulerConfig_FirmwareBranch) String() string {
	return proto.EnumName(SchedulerConfig_FirmwareBranch_name, int32(x))
}

func (SchedulerConfig_FirmwareBranch) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_905bf28b41c26c54, []int{3, 0}
}

// LaunchProfile defines how often the suite is launched.
type SchedulerConfig_LaunchCriteria_LaunchProfile int32

const (
	SchedulerConfig_LaunchCriteria_UNSPECIFIED SchedulerConfig_LaunchCriteria_LaunchProfile = 0
	// Run on every new release build of the boards/variants targeted.
	SchedulerConfig_LaunchCriteria_NEW_BUILD SchedulerConfig_LaunchCriteria_LaunchProfile = 1
	// Run once a day at the specified hour. Used to be "NIGHTLY".
	SchedulerConfig_LaunchCriteria_DAILY SchedulerConfig_LaunchCriteria_LaunchProfile = 2
	// Run once a week at the specified time.
	SchedulerConfig_LaunchCriteria_WEEKLY SchedulerConfig_LaunchCriteria_LaunchProfile = 3
	// NOT SUPPORTED. Will be supported in the redesign.
	SchedulerConfig_LaunchCriteria_CRON_BASED SchedulerConfig_LaunchCriteria_LaunchProfile = 4
)

var SchedulerConfig_LaunchCriteria_LaunchProfile_name = map[int32]string{
	0: "UNSPECIFIED",
	1: "NEW_BUILD",
	2: "DAILY",
	3: "WEEKLY",
	4: "CRON_BASED",
}

var SchedulerConfig_LaunchCriteria_LaunchProfile_value = map[string]int32{
	"UNSPECIFIED": 0,
	"NEW_BUILD":   1,
	"DAILY":       2,
	"WEEKLY":      3,
	"CRON_BASED":  4,
}

func (x SchedulerConfig_LaunchCriteria_LaunchProfile) String() string {
	return proto.EnumName(SchedulerConfig_LaunchCriteria_LaunchProfile_name, int32(x))
}

func (SchedulerConfig_LaunchCriteria_LaunchProfile) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_905bf28b41c26c54, []int{3, 1, 0}
}

// Defines a board, its variants and its models.
type Board struct {
	// Name of the board. Eg: eve.
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// List of variants assiciated with the board.
	// This should only be the suffixes. Eg: ['-kernelnext'].
	Variants []string `protobuf:"bytes,2,rep,name=variants,proto3" json:"variants,omitempty"`
	// List of models of the boards to test on.
	Models               []string `protobuf:"bytes,3,rep,name=models,proto3" json:"models,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_Board proto.InternalMessageInfo

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

func (m *Board) GetVariants() []string {
	if m != nil {
		return m.Variants
	}
	return nil
}

func (m *Board) GetModels() []string {
	if m != nil {
		return m.Models
	}
	return nil
}

// Aims to reflect data in lab_config.ini.
type LabConfig struct {
	// List of board definitions.
	Boards               []*Board `protobuf:"bytes,1,rep,name=boards,proto3" json:"boards,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_LabConfig proto.InternalMessageInfo

func (m *LabConfig) GetBoards() []*Board {
	if m != nil {
		return m.Boards
	}
	return nil
}

// Specify a Board and Variant pair.
type BoardVariant struct {
	Board                string   `protobuf:"bytes,1,opt,name=board,proto3" json:"board,omitempty"`
	Variant              string   `protobuf:"bytes,2,opt,name=variant,proto3" json:"variant,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_BoardVariant proto.InternalMessageInfo

func (m *BoardVariant) GetBoard() string {
	if m != nil {
		return m.Board
	}
	return ""
}

func (m *BoardVariant) GetVariant() string {
	if m != nil {
		return m.Variant
	}
	return ""
}

// Most fields are the same as suite_scheduler.ini just better organized.
// The entries will be used to generate a suite_scheduler.ini in starlark scripts.
type SchedulerConfig struct {
	// Name of the config. Needs to be unique.
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// Name of the suite to run.
	Suite          string                          `protobuf:"bytes,2,opt,name=suite,proto3" json:"suite,omitempty"`
	Contacts       []*SchedulerConfig_Contact      `protobuf:"bytes,3,rep,name=contacts,proto3" json:"contacts,omitempty"`
	LaunchCriteria *SchedulerConfig_LaunchCriteria `protobuf:"bytes,4,opt,name=launch_criteria,json=launchCriteria,proto3" json:"launch_criteria,omitempty"`
	// Branches to target.
	Branches            []Branch                       `protobuf:"varint,5,rep,packed,name=branches,proto3,enum=testplans.Branch" json:"branches,omitempty"`
	TargetOptions       *SchedulerConfig_TargetOptions `protobuf:"bytes,6,opt,name=target_options,json=targetOptions,proto3" json:"target_options,omitempty"`
	PoolOptions         *SchedulerConfig_PoolOptions   `protobuf:"bytes,7,opt,name=pool_options,json=poolOptions,proto3" json:"pool_options,omitempty"`
	FirmwareRoBuildSpec SchedulerConfig_FirmwareBranch `protobuf:"varint,8,opt,name=firmware_ro_build_spec,json=firmwareRoBuildSpec,proto3,enum=testplans.SchedulerConfig_FirmwareBranch" json:"firmware_ro_build_spec,omitempty"`
	RunOptions          *SchedulerConfig_RunOptions    `protobuf:"bytes,9,opt,name=run_options,json=runOptions,proto3" json:"run_options,omitempty"`
	// Name of the config, used for analytics. Does not have to be unique.
	AnalyticsName        string   `protobuf:"bytes,10,opt,name=analytics_name,json=analyticsName,proto3" json:"analytics_name,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_SchedulerConfig proto.InternalMessageInfo

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

func (m *SchedulerConfig) GetSuite() string {
	if m != nil {
		return m.Suite
	}
	return ""
}

func (m *SchedulerConfig) GetContacts() []*SchedulerConfig_Contact {
	if m != nil {
		return m.Contacts
	}
	return nil
}

func (m *SchedulerConfig) GetLaunchCriteria() *SchedulerConfig_LaunchCriteria {
	if m != nil {
		return m.LaunchCriteria
	}
	return nil
}

func (m *SchedulerConfig) GetBranches() []Branch {
	if m != nil {
		return m.Branches
	}
	return nil
}

func (m *SchedulerConfig) GetTargetOptions() *SchedulerConfig_TargetOptions {
	if m != nil {
		return m.TargetOptions
	}
	return nil
}

func (m *SchedulerConfig) GetPoolOptions() *SchedulerConfig_PoolOptions {
	if m != nil {
		return m.PoolOptions
	}
	return nil
}

func (m *SchedulerConfig) GetFirmwareRoBuildSpec() SchedulerConfig_FirmwareBranch {
	if m != nil {
		return m.FirmwareRoBuildSpec
	}
	return SchedulerConfig_UNSPECIFIED
}

func (m *SchedulerConfig) GetRunOptions() *SchedulerConfig_RunOptions {
	if m != nil {
		return m.RunOptions
	}
	return nil
}

func (m *SchedulerConfig) GetAnalyticsName() string {
	if m != nil {
		return m.AnalyticsName
	}
	return ""
}

// Contact emails will one day be paged in case of problems with the config.
type SchedulerConfig_Contact struct {
	Email                string   `protobuf:"bytes,1,opt,name=email,proto3" json:"email,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_SchedulerConfig_Contact proto.InternalMessageInfo

func (m *SchedulerConfig_Contact) GetEmail() string {
	if m != nil {
		return m.Email
	}
	return ""
}

// LaunchCriteria specifies when the suite should be launched.
type SchedulerConfig_LaunchCriteria struct {
	LaunchProfile SchedulerConfig_LaunchCriteria_LaunchProfile `protobuf:"varint,1,opt,name=launch_profile,json=launchProfile,proto3,enum=testplans.SchedulerConfig_LaunchCriteria_LaunchProfile" json:"launch_profile,omitempty"`
	// Hour at which to run. Needs to be specified for nightly and weekly profiles.
	// Has to be [0, 23].
	Hour int32 `protobuf:"varint,2,opt,name=hour,proto3" json:"hour,omitempty"`
	// Day on which to run. Needs to be specified for weekly profile.
	// Has to be [0, 6].
	Day int32 `protobuf:"varint,3,opt,name=day,proto3" json:"day,omitempty"`
	// NOT SUPPORTED. Cron compatible schedule eg: "* * 1,3,5 * *".
	CronSchedule         string   `protobuf:"bytes,4,opt,name=cron_schedule,json=cronSchedule,proto3" json:"cron_schedule,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_SchedulerConfig_LaunchCriteria proto.InternalMessageInfo

func (m *SchedulerConfig_LaunchCriteria) GetLaunchProfile() SchedulerConfig_LaunchCriteria_LaunchProfile {
	if m != nil {
		return m.LaunchProfile
	}
	return SchedulerConfig_LaunchCriteria_UNSPECIFIED
}

func (m *SchedulerConfig_LaunchCriteria) GetHour() int32 {
	if m != nil {
		return m.Hour
	}
	return 0
}

func (m *SchedulerConfig_LaunchCriteria) GetDay() int32 {
	if m != nil {
		return m.Day
	}
	return 0
}

func (m *SchedulerConfig_LaunchCriteria) GetCronSchedule() string {
	if m != nil {
		return m.CronSchedule
	}
	return ""
}

// Set of boards, variants and models to target.
type SchedulerConfig_TargetOptions struct {
	// Use at the most one among the two fields below. If boards_list is empty,
	// all boards are targeted. exclude_boards will exclude those boards from
	// the all boards list.
	BoardsList    []string `protobuf:"bytes,1,rep,name=boards_list,json=boardsList,proto3" json:"boards_list,omitempty"`
	ExcludeBoards []string `protobuf:"bytes,2,rep,name=exclude_boards,json=excludeBoards,proto3" json:"exclude_boards,omitempty"`
	// To specify variants, either all variants can be skipped.
	SkipVariants bool `protobuf:"varint,8,opt,name=skip_variants,json=skipVariants,proto3" json:"skip_variants,omitempty"`
	// OR use at the most one among the two fields below. If variants_list is empty,
	// all variants are targeted. exclude_variants will exclude those variants
	// from the all variants list.
	VariantsList    []*BoardVariant `protobuf:"bytes,3,rep,name=variants_list,json=variantsList,proto3" json:"variants_list,omitempty"`
	ExcludeVariants []*BoardVariant `protobuf:"bytes,4,rep,name=exclude_variants,json=excludeVariants,proto3" json:"exclude_variants,omitempty"`
	// There's two ways of specifying models. If all of these fields are empty,
	// all possible models are targeted.
	// Models to be targeted can be listed explicitly in models_list.
	ModelsList []string `protobuf:"bytes,5,rep,name=models_list,json=modelsList,proto3" json:"models_list,omitempty"`
	// OR start with the complete list and exclude some specific models.
	// any_model only tests the suite on a single model.
	AnyModel             bool     `protobuf:"varint,6,opt,name=any_model,json=anyModel,proto3" json:"any_model,omitempty"`
	ExcludeModels        []string `protobuf:"bytes,7,rep,name=exclude_models,json=excludeModels,proto3" json:"exclude_models,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_SchedulerConfig_TargetOptions proto.InternalMessageInfo

func (m *SchedulerConfig_TargetOptions) GetBoardsList() []string {
	if m != nil {
		return m.BoardsList
	}
	return nil
}

func (m *SchedulerConfig_TargetOptions) GetExcludeBoards() []string {
	if m != nil {
		return m.ExcludeBoards
	}
	return nil
}

func (m *SchedulerConfig_TargetOptions) GetSkipVariants() bool {
	if m != nil {
		return m.SkipVariants
	}
	return false
}

func (m *SchedulerConfig_TargetOptions) GetVariantsList() []*BoardVariant {
	if m != nil {
		return m.VariantsList
	}
	return nil
}

func (m *SchedulerConfig_TargetOptions) GetExcludeVariants() []*BoardVariant {
	if m != nil {
		return m.ExcludeVariants
	}
	return nil
}

func (m *SchedulerConfig_TargetOptions) GetModelsList() []string {
	if m != nil {
		return m.ModelsList
	}
	return nil
}

func (m *SchedulerConfig_TargetOptions) GetAnyModel() bool {
	if m != nil {
		return m.AnyModel
	}
	return false
}

func (m *SchedulerConfig_TargetOptions) GetExcludeModels() []string {
	if m != nil {
		return m.ExcludeModels
	}
	return nil
}

// Aggregate of options related to DUT pool.
type SchedulerConfig_PoolOptions struct {
	// Quota Scheduler account to use.
	QsAccount string `protobuf:"bytes,1,opt,name=qs_account,json=qsAccount,proto3" json:"qs_account,omitempty"`
	// Pool to schedule on.
	Pool string `protobuf:"bytes,2,opt,name=pool,proto3" json:"pool,omitempty"`
	// Integer priority to assign. Only used by CTS. Quota scheduler takes care of
	// priorities for the rest. Has to be [20, 255].
	Priority             int32    `protobuf:"varint,3,opt,name=priority,proto3" json:"priority,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_SchedulerConfig_PoolOptions proto.InternalMessageInfo

func (m *SchedulerConfig_PoolOptions) GetQsAccount() string {
	if m != nil {
		return m.QsAccount
	}
	return ""
}

func (m *SchedulerConfig_PoolOptions) GetPool() string {
	if m != nil {
		return m.Pool
	}
	return ""
}

func (m *SchedulerConfig_PoolOptions) GetPriority() int32 {
	if m != nil {
		return m.Priority
	}
	return 0
}

// Execution related options.
type SchedulerConfig_RunOptions struct {
	// Whether to retry if the task fails.
	Retry      bool                                            `protobuf:"varint,1,opt,name=retry,proto3" json:"retry,omitempty"`
	Dimensions []*SchedulerConfig_RunOptions_SwarmingDimension `protobuf:"bytes,2,rep,name=dimensions,proto3" json:"dimensions,omitempty"`
	// Timeout of the task.
	TimeoutMins int32 `protobuf:"varint,3,opt,name=timeout_mins,json=timeoutMins,proto3" json:"timeout_mins,omitempty"`
	// If sanity HW test passed, launch this test. Irrespective of the release build's
	// final status.
	OnlySanityTestRequired bool     `protobuf:"varint,4,opt,name=only_sanity_test_required,json=onlySanityTestRequired,proto3" json:"only_sanity_test_required,omitempty"`
	XXX_NoUnkeyedLiteral   struct{} `json:"-"`
	XXX_unrecognized       []byte   `json:"-"`
	XXX_sizecache          int32    `json:"-"`
}

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

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

var xxx_messageInfo_SchedulerConfig_RunOptions proto.InternalMessageInfo

func (m *SchedulerConfig_RunOptions) GetRetry() bool {
	if m != nil {
		return m.Retry
	}
	return false
}

func (m *SchedulerConfig_RunOptions) GetDimensions() []*SchedulerConfig_RunOptions_SwarmingDimension {
	if m != nil {
		return m.Dimensions
	}
	return nil
}

func (m *SchedulerConfig_RunOptions) GetTimeoutMins() int32 {
	if m != nil {
		return m.TimeoutMins
	}
	return 0
}

func (m *SchedulerConfig_RunOptions) GetOnlySanityTestRequired() bool {
	if m != nil {
		return m.OnlySanityTestRequired
	}
	return false
}

// A list of extra labels/dimensions to attach.
// Extra Swarming Dimensions that can be specified.
type SchedulerConfig_RunOptions_SwarmingDimension struct {
	Key                  string   `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
	Value                string   `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_SchedulerConfig_RunOptions_SwarmingDimension proto.InternalMessageInfo

func (m *SchedulerConfig_RunOptions_SwarmingDimension) GetKey() string {
	if m != nil {
		return m.Key
	}
	return ""
}

func (m *SchedulerConfig_RunOptions_SwarmingDimension) GetValue() string {
	if m != nil {
		return m.Value
	}
	return ""
}

// A proto to contain all the configs.
type SchedulerCfg struct {
	Configs              []*SchedulerConfig `protobuf:"bytes,1,rep,name=configs,proto3" json:"configs,omitempty"`
	XXX_NoUnkeyedLiteral struct{}           `json:"-"`
	XXX_unrecognized     []byte             `json:"-"`
	XXX_sizecache        int32              `json:"-"`
}

func (m *SchedulerCfg) Reset()         { *m = SchedulerCfg{} }
func (m *SchedulerCfg) String() string { return proto.CompactTextString(m) }
func (*SchedulerCfg) ProtoMessage()    {}
func (*SchedulerCfg) Descriptor() ([]byte, []int) {
	return fileDescriptor_905bf28b41c26c54, []int{4}
}

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

var xxx_messageInfo_SchedulerCfg proto.InternalMessageInfo

func (m *SchedulerCfg) GetConfigs() []*SchedulerConfig {
	if m != nil {
		return m.Configs
	}
	return nil
}

func init() {
	proto.RegisterEnum("testplans.Branch", Branch_name, Branch_value)
	proto.RegisterEnum("testplans.SchedulerConfig_FirmwareBranch", SchedulerConfig_FirmwareBranch_name, SchedulerConfig_FirmwareBranch_value)
	proto.RegisterEnum("testplans.SchedulerConfig_LaunchCriteria_LaunchProfile", SchedulerConfig_LaunchCriteria_LaunchProfile_name, SchedulerConfig_LaunchCriteria_LaunchProfile_value)
	proto.RegisterType((*Board)(nil), "testplans.Board")
	proto.RegisterType((*LabConfig)(nil), "testplans.LabConfig")
	proto.RegisterType((*BoardVariant)(nil), "testplans.BoardVariant")
	proto.RegisterType((*SchedulerConfig)(nil), "testplans.SchedulerConfig")
	proto.RegisterType((*SchedulerConfig_Contact)(nil), "testplans.SchedulerConfig.Contact")
	proto.RegisterType((*SchedulerConfig_LaunchCriteria)(nil), "testplans.SchedulerConfig.LaunchCriteria")
	proto.RegisterType((*SchedulerConfig_TargetOptions)(nil), "testplans.SchedulerConfig.TargetOptions")
	proto.RegisterType((*SchedulerConfig_PoolOptions)(nil), "testplans.SchedulerConfig.PoolOptions")
	proto.RegisterType((*SchedulerConfig_RunOptions)(nil), "testplans.SchedulerConfig.RunOptions")
	proto.RegisterType((*SchedulerConfig_RunOptions_SwarmingDimension)(nil), "testplans.SchedulerConfig.RunOptions.SwarmingDimension")
	proto.RegisterType((*SchedulerCfg)(nil), "testplans.SchedulerCfg")
}

func init() { proto.RegisterFile("testplans/suite_scheduler.proto", fileDescriptor_905bf28b41c26c54) }

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