// Code generated by protoc-gen-go. DO NOT EDIT.
// source: test/plan/v1/plan.proto

package plan

import (
	fmt "fmt"
	proto "github.com/golang/protobuf/proto"
	api "go.chromium.org/chromiumos/config/go/api"
	v1 "go.chromium.org/chromiumos/infra/proto/go/test/fleet/v1"
	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 Exclusion_Type int32

const (
	// Do not use.
	Exclusion_TYPE_UNSPECIFIED Exclusion_Type = 0
	// There are no active plans to remove these exclusions becuase it is
	// prohibitive to fix the issue or business needs do not justify the effort
	// to fix the issue.
	//
	// Each PERMANENT exclusion MUST include references that point to a business
	// justification for its addition.
	Exclusion_PERMANENT Exclusion_Type = 1
	// Use for excluding new tests from running on devices where the test has
	// not yet been stabilized. The intention is to support incremental rollout
	// of new tests.
	//
	// These exclsusion are temporary. These exclusions SHOULD be routinely
	// audited and resolved or promoted to PERMANENT exclusions.
	Exclusion_TEMPORARY_NEW_TEST Exclusion_Type = 2
	// Use for excluding broken / flakey tests while a fix is being worked on.
	//
	// These exclsusion are temporary. These exclusions SHOULD be routinely
	// audited and resolved or promoted to PERMANENT exclusions.
	Exclusion_TEMPORARY_PENDING_FIX Exclusion_Type = 3
)

var Exclusion_Type_name = map[int32]string{
	0: "TYPE_UNSPECIFIED",
	1: "PERMANENT",
	2: "TEMPORARY_NEW_TEST",
	3: "TEMPORARY_PENDING_FIX",
}

var Exclusion_Type_value = map[string]int32{
	"TYPE_UNSPECIFIED":      0,
	"PERMANENT":             1,
	"TEMPORARY_NEW_TEST":    2,
	"TEMPORARY_PENDING_FIX": 3,
}

func (x Exclusion_Type) String() string {
	return proto.EnumName(Exclusion_Type_name, int32(x))
}

func (Exclusion_Type) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_1a74b4d4119f628f, []int{5, 0}
}

type Exclusion_Action int32

const (
	// Specify no action.
	//
	// The Test Lab Environment may choose any of the available actions based
	// on internal heuristics.
	//
	// The default Action is a good default if none of the considersations for
	// the specific actions below apply.
	Exclusion_ACTION_UNSPECIFIED Exclusion_Action = 0
	// Do not schedule the selected Tests on specified Devices Under Test.
	//
	// It is especially useful to set this Action for permanent exceptions as it
	// is definitely not useful to run the Tests at all in those cases.
	Exclusion_DO_NOT_SCHEDULE Exclusion_Action = 1
	// Schedule the Test on Devices Under Test as required by the test plan
	// unit, but mark the results for selected tests on the specified Devices
	// Under Test as non-critical. Results marked non-critical are intended to
	// be ignored by result consumers (e.g, presubmit system should consider the
	// result irrelevant for validatting a Chrome OS build).
	//
	// This action does not guarantee that results for the selected (Test,
	// Device Under Test) pairs are always available because that depends no how
	// the test plan Unit is interpreted overall. When this action is set, the
	// Test Lab Environment SHOULD NOT make any special effort to include /
	// exclude the selected (Test, Device Under Test) pairs.
	//
	// It is useful to set this Action for temporary exclusions where the
	// results generated from test execution can be uesd to root cause and fix
	// the underlying issues.
	Exclusion_MARK_NON_CRITICAL Exclusion_Action = 2
)

var Exclusion_Action_name = map[int32]string{
	0: "ACTION_UNSPECIFIED",
	1: "DO_NOT_SCHEDULE",
	2: "MARK_NON_CRITICAL",
}

var Exclusion_Action_value = map[string]int32{
	"ACTION_UNSPECIFIED": 0,
	"DO_NOT_SCHEDULE":    1,
	"MARK_NON_CRITICAL":  2,
}

func (x Exclusion_Action) String() string {
	return proto.EnumName(Exclusion_Action_name, int32(x))
}

func (Exclusion_Action) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_1a74b4d4119f628f, []int{5, 1}
}

// A set of known test plans.
//
// In practice, a complete specification of all known plans may consist of
// multiple Specification instances. In that case the plan names MUST be unique
// across different Specification instances.
type Specification struct {
	Plans                []*Plan  `protobuf:"bytes,1,rep,name=plans,proto3" json:"plans,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_Specification proto.InternalMessageInfo

func (m *Specification) GetPlans() []*Plan {
	if m != nil {
		return m.Plans
	}
	return nil
}

// A Plan fully specifies a Test Platform end-user's coverage needs.
//
// Plans SHOULD associate platform software and Device Under Test condition
// coverage rules with tests that exercise those components. Plans MUST be used
// in the Test Platform request API. Other Test Lab Environments may use plans
// to ease interoperation with the Test Platform.
type Plan struct {
	// A globally unique test plan name.
	//
	// MUST be valid resource name per https://aip.dev/122.
	//
	// Pattern: plans/{plan}
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// Each test plan unit specifies a particular set of tests to be run to meet
	// specific conditions.
	Units                []*Unit  `protobuf:"bytes,2,rep,name=units,proto3" json:"units,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_Plan proto.InternalMessageInfo

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

func (m *Plan) GetUnits() []*Unit {
	if m != nil {
		return m.Units
	}
	return nil
}

// Specifies a particular set of tests to be run to meet specific conditions.
type Unit struct {
	// A globally unique test plan unit name.
	//
	// MUST be valid resource name per https://aip.dev/122.
	//
	// Pattern: plans/{plan}/units/{unit}
	//   where {plan} is the parent Plan of this Unit.
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// Selects tests to include in this test plan unit.
	//
	// See also: exclusions.
	TestConstraint *TestConstraint `protobuf:"bytes,2,opt,name=test_constraint,json=testConstraint,proto3" json:"test_constraint,omitempty"`
	// Selects the set of Devices Under Test that satisfy the coverage
	// requirements of this test plan unit.
	//
	// See also: exclusions.
	DutCoverageConstraint *DUTCoverageConstraint `protobuf:"bytes,3,opt,name=dut_coverage_constraint,json=dutCoverageConstraint,proto3" json:"dut_coverage_constraint,omitempty"`
	// Chrome OS platform software covered by this test plan.
	//
	// Test Platform requests may optionally include a reference to platform
	// software to be tested via the test plan. For such requests, Test Platform
	// MUST only execute test plan units that have non-trivial coverage of the
	// referenced platform software. Unrelated test plan units MUST be skipped.
	//
	// A typical example is presubmit testing: When testing a change to the
	// network manager, it may be desirable to only run test plan units that
	// are known to exercise the network manager.
	//
	// For a test plan unit with no `code_coverage` specified, Test Platform MUST
	// assume coverage of all platform software (i.e., this test plan unit MUST
	// never be skipped for code coverage considerations).
	CodeCoverage *CodeCoverage `protobuf:"bytes,4,opt,name=code_coverage,json=codeCoverage,proto3" json:"code_coverage,omitempty"`
	// A list of criteria for (test, Device Under Test) pairs that MUST be
	// excluded from this test plan.
	//
	// Exclusions are used to record exceptions to the test plan specification for
	// devices that are known to cause test failures for some temporary or
	// permanent reasons. The test_constraint and dut_coverage_constraint fields
	// together specify the _intent_ of the test plan unit. The exclusions further
	// restrict what Devices Under Test can be used to satisfy the test plan unit
	// due to practical considerations.
	//
	// Each exclusion SHOULD correspond to a different business reason.
	// Conceptually, fixing a known issue should result in an exclusion being
	// removed.
	Exclusions           []*Exclusion `protobuf:"bytes,5,rep,name=exclusions,proto3" json:"exclusions,omitempty"`
	XXX_NoUnkeyedLiteral struct{}     `json:"-"`
	XXX_unrecognized     []byte       `json:"-"`
	XXX_sizecache        int32        `json:"-"`
}

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

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

var xxx_messageInfo_Unit proto.InternalMessageInfo

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

func (m *Unit) GetTestConstraint() *TestConstraint {
	if m != nil {
		return m.TestConstraint
	}
	return nil
}

func (m *Unit) GetDutCoverageConstraint() *DUTCoverageConstraint {
	if m != nil {
		return m.DutCoverageConstraint
	}
	return nil
}

func (m *Unit) GetCodeCoverage() *CodeCoverage {
	if m != nil {
		return m.CodeCoverage
	}
	return nil
}

func (m *Unit) GetExclusions() []*Exclusion {
	if m != nil {
		return m.Exclusions
	}
	return nil
}

// Selects the test.metadata.Test to include in a test plan unit.
type TestConstraint struct {
	// A Common Expression Language (CEL) expression to specify set of tests that
	// are included in a test plan unit.
	//
	// Test Platform MUST effectively evaluate `expression` with the following
	// declarations in scope for every test and include the test for which
	// `expression` evaluates to true in the test plan unit.
	//
	// - Constant: `test` of type TestConstraint.Test defined below,
	//   populated with metadata for a particular test.
	//
	// The full CEL spec can be found at https://github.com/google/cel-spec.
	//
	// TODO(crbug.com/1051689) Add reference to the metadata validator package.
	//
	// ## Examples
	//
	// Typical instructive examples of expressions are:
	//
	// - Tauto dummy tests
	//     "suite:dummy" in test.attributes
	// - Tast's crosbolt tests
	//     !("disabled" in test.attributes)
	//     && "group:crosbolt" in test.attributes
	//     && "crosbolt_perbuild" in test.attributes
	// - network Tauto tests, selected by name
	//     test.name.startsWith("network_")
	//
	// ## CEL support
	//
	// All standard CEL syntax, macros and functions MUST be supported.
	Expression           string   `protobuf:"bytes,1,opt,name=expression,proto3" json:"expression,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_TestConstraint proto.InternalMessageInfo

func (m *TestConstraint) GetExpression() string {
	if m != nil {
		return m.Expression
	}
	return ""
}

type TestConstraint_Test struct {
	// Name of the test as specified in test.metadata.Test.name
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// The test attribute name as specified in the test.metadata.Attribute.name
	//
	// attributes are populated from test.metadata.Test.attributes.
	Attributes           []string `protobuf:"bytes,2,rep,name=attributes,proto3" json:"attributes,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_TestConstraint_Test proto.InternalMessageInfo

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

func (m *TestConstraint_Test) GetAttributes() []string {
	if m != nil {
		return m.Attributes
	}
	return nil
}

// Selects sets of Devices Under Test to run the tests on in a test plan unit.
type DUTCoverageConstraint struct {
	// A Common Expression Language (CEL) expression to specify set of DUTs that
	// provide the necessary coverage. `expression` MUST evaluate to a boolean
	// value in the evaluation context described below.
	//
	// Test Platform MUST support scheduling test requests on a set of Devices
	// Under Test that satisfy some constraints on their Chrome OS configuration.
	//
	// Test Platform MUST effectively evaluate `expression` with the following
	// declarations in scope for each possible subset of Devices Under Test and
	// ensure that the test is scheduled on a set of Devices Under Test for which
	// `expression` evaluates to true.
	//
	// - Constant: `duts` of type repeated DUTConfigConstraint.DUT defined below,
	//   each entry in `duts` set to the Chrome OS configuration payload of a
	//   particular Device Under Test.
	// - Types: Protobuf messages from `chromiumos.config.api.*`
	//   - Additionally available with the short-hand `api.*`
	// - Types: Protobuf messages from `test.fleet.v1.*`
	//   - Additionally available with the short-hand `fleet.*`
	//
	// The full CEL spec can be found at https://github.com/google/cel-spec.
	// This API only supports a sub-set of the CEL features as described here.
	// Test Platform MUST validate the expression and reject use of unsupported
	// features.
	//
	// TODO(crbug.com/1051689) Add reference to the metadata validator package.
	//
	// ## Examples
	//
	// Typical instructive examples of expressions are:
	//
	// - Constraints: All pre-F20 plans only specify constraints on what devices
	//   may be used, e.g.:
	//    - Run each test on one DUT with model 'nautilus'.
	//        TODO(pprabhu, shapiroc): Need a way to specify model for migration.
	//        duts.all(dut, dut.id.model_id.value = 'nautilus') && size(duts) == 1
	//    - Run each test on one DUT with a stylus.
	//        (duts.all(dut, dut.hardware_features.stylus
	//                       == api.HardwareFeatures.Present.PRESENT))
	//         && size(duts) == 1)
	//  - Fanout (not yet supported): In addition to constraints, the
	//    plan may want to ensure coverage across some device features.
	//    TODO(pprabhu) This is an instructive example. We can't say what arch
	//    yet.
	//    - Run each test on one x86 and ARM DUT with a specific camera.
	//        (duts.all(dut, dut.hardware_toplogy.camera.id != "gomoe")
	//         && duts.exist(dut,
	//                       dut.cpu = api.Component.Soc.Architecture.X86)
	//         && duts.exist(dut,
	//                       dut.cpu = api.Component.Soc.Architecture.ARM))
	//      Note that this expression does not have a clause for size(duts). Thus
	//      Test Platform may satisfy this expression by running the test on more
	//      than two DUTs. This behaviour can be unexpected, especially if the
	//      plan fails due to an error on test execution on one of the selected
	//      devices, even though it passed on other devices in the set such that
	//      the expression was satsifed by the passing subset. Selection of a
	//      minimal set of devices to run the plan is best effort.
	//
	// Currently, only single-DUT constraints are supported by the Test Platform.
	// i.e., `expression` MUST be of the form:
	//   duts.all(DUT_SELECTOR) && size(duts) == 1
	// where DUT_SELECTOR is an expression that does not refer to `duts`.
	// This restriction will be lifted as this API matures.
	//
	// ## CEL support
	//
	// The full CEL spec can be found at https://github.com/google/cel-spec.
	//
	// Current support for `expression` evaluation is very restricted due to
	// limitations in the scheduling infrastructure used by Test Platform.
	//
	// As this API matures, features will be added to the scheduling
	// infrastructure of Test Platform and restrictions here will be lifted based
	// on requirements collected from test authors. See milestones in
	// go/cros-f20-plan for expected feature iterations. Test Lab Environments
	// SHOULD validate the expression and reject use of unsupported features.
	//
	// TODO(crbug.com/1051689) Add reference to the metadata validator package.
	//
	// ### Syntax
	//
	// See full syntax definition at
	// https://github.com/google/cel-spec/blob/master/doc/langdef.md#syntax
	//
	// CEL standard syntax allows expressions that evaluate to errors (e.g.,
	// syntax allows negation of lists, which has no semantics in CEL).
	// Thus, this spec does not attempt to restrict the syntax, but specifies what
	// operations are unsupported to aid metadata producers. Ultimately, the
	// reference metadata validator is the authority on what expressions are
	// allowed.
	//
	// Unsupported standard CEL semantics:
	//   - Binary arithmetic operations
	//     e.g.: +, *, /, % ...
	//   - Relational Operators beyond (in)equality are not supported.
	//     e.g.: (>, <, >=, <= ...)
	//   - Logical OR in expressions is not supported.
	//     e.g.: (a || b), !(a && b) ...
	//
	// ### Macros
	//
	// See full macro definition at
	// https://github.com/google/cel-spec/blob/master/doc/langdef.md#macros
	//
	// Supported macros: has(), e.all()
	// Unsupported macros: e.exists(), e.exists_one(), e.map(), e.filter()
	//
	// ### Standard functions
	//
	// See full list of standard definitions at
	// https://github.com/google/cel-spec/blob/master/doc/langdef.md#standard-definitions
	//
	// Most standard functions are not supported.
	//
	// - Supported operators: !_, -_, _!=_, _&&_, _=_, _[_]
	//   - All other operators are not supported.
	// - All other standard functions are not supported. In particular:
	//   - size() is not supported.
	//   - string functions like endsWith() and contains() are not supported.
	//   - type conversions like int() and string() are not supported.
	//   - reflection with type(), null_type() and dyn() is not supported.
	Expression           string   `protobuf:"bytes,1,opt,name=expression,proto3" json:"expression,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_DUTCoverageConstraint proto.InternalMessageInfo

func (m *DUTCoverageConstraint) GetExpression() string {
	if m != nil {
		return m.Expression
	}
	return ""
}

// The evaluation context for `expression` MUST include the Chrome OS
// configuration payload for a set of Devices Under Test as a typed
// constant of the following type.
//
//   repeated DUT duts = 1;
//
type DUTCoverageConstraint_DUT struct {
	// Configuration information about the lab deployment of the device.
	FleetDut             *v1.DeviceUnderTest   `protobuf:"bytes,1,opt,name=fleet_dut,json=fleetDut,proto3" json:"fleet_dut,omitempty"`
	HardwareFeatures     *api.HardwareFeatures `protobuf:"bytes,2,opt,name=hardware_features,json=hardwareFeatures,proto3" json:"hardware_features,omitempty"`
	XXX_NoUnkeyedLiteral struct{}              `json:"-"`
	XXX_unrecognized     []byte                `json:"-"`
	XXX_sizecache        int32                 `json:"-"`
}

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

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

var xxx_messageInfo_DUTCoverageConstraint_DUT proto.InternalMessageInfo

func (m *DUTCoverageConstraint_DUT) GetFleetDut() *v1.DeviceUnderTest {
	if m != nil {
		return m.FleetDut
	}
	return nil
}

func (m *DUTCoverageConstraint_DUT) GetHardwareFeatures() *api.HardwareFeatures {
	if m != nil {
		return m.HardwareFeatures
	}
	return nil
}

// Exlclusion is used to record exceptions to the test plan
// specification for devices that are known to cause test failures for some
// temporary or permanent reasons.
type Exclusion struct {
	// Required.
	Type   Exclusion_Type   `protobuf:"varint,1,opt,name=type,proto3,enum=test.plan.v1.Exclusion_Type" json:"type,omitempty"`
	Action Exclusion_Action `protobuf:"varint,5,opt,name=action,proto3,enum=test.plan.v1.Exclusion_Action" json:"action,omitempty"`
	// The tests this exclusion applies to, within a test plan unit.
	//
	// Tests selected by this condition that are not in the test plan unit are
	// ignored. e.g., simply selecting all tests via the test_constraint will
	// apply this exclusion to all tests in the test plan unit.
	TestConstraint *TestConstraint `protobuf:"bytes,2,opt,name=test_constraint,json=testConstraint,proto3" json:"test_constraint,omitempty"`
	// Constraints to exclude particular Device Under Test from being considered
	// to satisfy the test plan.
	//
	// Effectively, the negation of the constraint is added to the dut_constraints
	// for each selected test.
	DutConstraint *DUTExclusionConstraint `protobuf:"bytes,3,opt,name=dut_constraint,json=dutConstraint,proto3" json:"dut_constraint,omitempty"`
	// External references useful for archeology for this exclusion.
	//
	// PERMANENT exclusions MUST add references for the decision to make the
	// exclusion PERMANENT.
	//
	// References should be links with more context behind the decision.
	// Suggested forms:
	// * Monorail bug: https://bugs.chromium.org/p/chromium/issues/detail?id=XXX
	// * Buganizer bug: https://b.corp.google.com/issues/XXX
	References           []string `protobuf:"bytes,4,rep,name=references,proto3" json:"references,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *Exclusion) Reset()         { *m = Exclusion{} }
func (m *Exclusion) String() string { return proto.CompactTextString(m) }
func (*Exclusion) ProtoMessage()    {}
func (*Exclusion) Descriptor() ([]byte, []int) {
	return fileDescriptor_1a74b4d4119f628f, []int{5}
}

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

var xxx_messageInfo_Exclusion proto.InternalMessageInfo

func (m *Exclusion) GetType() Exclusion_Type {
	if m != nil {
		return m.Type
	}
	return Exclusion_TYPE_UNSPECIFIED
}

func (m *Exclusion) GetAction() Exclusion_Action {
	if m != nil {
		return m.Action
	}
	return Exclusion_ACTION_UNSPECIFIED
}

func (m *Exclusion) GetTestConstraint() *TestConstraint {
	if m != nil {
		return m.TestConstraint
	}
	return nil
}

func (m *Exclusion) GetDutConstraint() *DUTExclusionConstraint {
	if m != nil {
		return m.DutConstraint
	}
	return nil
}

func (m *Exclusion) GetReferences() []string {
	if m != nil {
		return m.References
	}
	return nil
}

// Conditions to be met for the Chrome OS configuration of a Device Under
// Test for it to be excluded from consideration to satisfy a test plan unit.
type DUTExclusionConstraint struct {
	// A Common Expression Language (CEL) expression to specify constraints on a
	// Device Under Test's Chrome OS configuration payload. `expression` MUST
	// evaluate to a boolean value in the evaluation context described below.
	//
	// Test Lab Environments may optionally support excluding specific Devices
	// Under Test from being considered for a test plan unit.
	// When supported, the Test Lab Environment MUST effectively evaluate
	// `expression` with the following declarations in scope for each available
	// Device Under Test and ensure that the test is *not* scheduled on a Device
	// Under Test for which `expression` evaluates to true.
	//
	// - Constant: `dut` of type DUTConfigConstraint.DUT defined below, set to the
	//   Chrome OS configuration payload of a particular Device Under Test.
	// - Types: Protobuf messages from `chromiumos.config.api.*`
	//   - Additionally available with the short-hand `api.*`
	//
	// ## Examples
	//
	// Typical examples of expressions are:
	//
	// - Must not run on a device with a given screen size:
	//     dut.hardware_features.screen.milliinch.value == 14000
	// - TODO: Add model / build target example.
	//
	// ## CEL support
	//
	// The full CEL spec can be found at https://github.com/google/cel-spec.
	//
	// Current support for `expression` evaluation is very restricted due to
	// limitations in the scheduling infrastructure used by Test Platform.
	//
	// As this API matures, features will be added to the scheduling
	// infrastructure of Test Platform and restrictions here will be lifted based
	// on requirements collected from test authors. See milestones in
	// go/cros-f20-plan for expected feature iterations. Test Lab Environments
	// SHOULD validate the expression and reject use of unsupported features.
	//
	// TODO(crbug.com/1051689) Add reference to the metadata validator package.
	//
	// ### Syntax
	//
	// See full syntax definition at
	// https://github.com/google/cel-spec/blob/master/doc/langdef.md#syntax
	//
	// CEL standard syntax allows expressions that evaluate to errors (e.g.,
	// syntax allows negation of lists, which has no semantics in CEL).
	// Thus, this spec does not attempt to restrict the syntax, but specifies what
	// operations are unsupported to aid metadata producers. Ultimately, the
	// reference metadata validator is the authority on what expressions are
	// allowed.
	//
	// Unsupported standard CEL semantics:
	//   - Binary arithmetic operations
	//     e.g.: +, *, /, % ...
	//   - Relational Operators beyond (in)equality are not supported.
	//     e.g.: (>, <, >=, <= ...)
	//   - Logical OR in expressions is not supported.
	//     e.g.: (a || b), !(a && b) ...
	//
	// ### Macros
	//
	// See full macro definition at
	// https://github.com/google/cel-spec/blob/master/doc/langdef.md#macros
	//
	// Supported macros: has(), e.all()
	// Unsupported macros: e.exists(), e.exists_one(), e.map(), e.filter()
	//
	// ### Standard functions
	//
	// See full list of standard definitions at
	// https://github.com/google/cel-spec/blob/master/doc/langdef.md#standard-definitions
	//
	// Most standard functions are not supported.
	//
	// - Supported operators: !_, -_, _!=_, _&&_, _=_, _[_]
	//   - All other operators are not supported.
	// - All other standard functions are not supported. In particular:
	//   - size() is not supported.
	//   - string functions like endsWith() and contains() are not supported.
	//   - type conversions like int() and string() are not supported.
	//   - reflection with type(), null_type() and dyn() is not supported.
	Expression           string   `protobuf:"bytes,1,opt,name=expression,proto3" json:"expression,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *DUTExclusionConstraint) Reset()         { *m = DUTExclusionConstraint{} }
func (m *DUTExclusionConstraint) String() string { return proto.CompactTextString(m) }
func (*DUTExclusionConstraint) ProtoMessage()    {}
func (*DUTExclusionConstraint) Descriptor() ([]byte, []int) {
	return fileDescriptor_1a74b4d4119f628f, []int{6}
}

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

var xxx_messageInfo_DUTExclusionConstraint proto.InternalMessageInfo

func (m *DUTExclusionConstraint) GetExpression() string {
	if m != nil {
		return m.Expression
	}
	return ""
}

// The evaluation context for `expression` MUST include the Chrome OS
// configuration payload for a particular Device Under Test as a typed
// constant of the following type.
type DUTExclusionConstraint_DUT struct {
	HardwareFeatures     *api.HardwareFeatures `protobuf:"bytes,1,opt,name=hardware_features,json=hardwareFeatures,proto3" json:"hardware_features,omitempty"`
	XXX_NoUnkeyedLiteral struct{}              `json:"-"`
	XXX_unrecognized     []byte                `json:"-"`
	XXX_sizecache        int32                 `json:"-"`
}

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

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

var xxx_messageInfo_DUTExclusionConstraint_DUT proto.InternalMessageInfo

func (m *DUTExclusionConstraint_DUT) GetHardwareFeatures() *api.HardwareFeatures {
	if m != nil {
		return m.HardwareFeatures
	}
	return nil
}

// Specifies platforms software covered by a test plan unit.
type CodeCoverage struct {
	// A Common Expression Language (CEL) expression to specify Chrome OS platform
	// sources covered by a test plan unit.
	//
	// Test Platform may optionally support skipping test plan units that are not
	// applicable for incoming changes to Chrome OS. If this feature is supported,
	// and if a non-empty blamelist is available, Test Platform MUST effectively
	// evaluate `expression` with the following declarations in scope for the
	// blamelist only include the test plan unit if the `expression` evaluates to
	// true.
	//
	// - Constant: `blamelist` of type CodeCoverage.Blamelist defined below,
	//   populated with blamelist attached to the request, if blamelist is
	//   non-empty.
	//
	// The full CEL spec can be found at https://github.com/google/cel-spec.
	//
	// TODO(crbug.com/1051689) Add reference to the metadata validator package.
	//
	// ## Examples
	//
	// Typical instructive examples of expressions are:
	//
	// - Only include test plan unit if there are changes to chromite
	//     blamelist.repo_paths.exists(p, p.startsWith("chromite"))
	// - Only include test plan unit if there are changes to chromite or autotest
	//     blamelist.repo_paths.exists(p, [
	//         "src/third_party/autotest/files",
	//         "chromite"
	//       ].exists(s, p.startsWith(s)))
	// - Do not include test plan unit if there are changes to private overlays
	//     blamelist.repo_paths.all(p, !p.contains("private-overlays"))
	//
	// ## CEL support
	//
	// All standard CEL syntax, macros and functions MUST be supported.
	Expression           string   `protobuf:"bytes,1,opt,name=expression,proto3" json:"expression,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *CodeCoverage) Reset()         { *m = CodeCoverage{} }
func (m *CodeCoverage) String() string { return proto.CompactTextString(m) }
func (*CodeCoverage) ProtoMessage()    {}
func (*CodeCoverage) Descriptor() ([]byte, []int) {
	return fileDescriptor_1a74b4d4119f628f, []int{7}
}

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

var xxx_messageInfo_CodeCoverage proto.InternalMessageInfo

func (m *CodeCoverage) GetExpression() string {
	if m != nil {
		return m.Expression
	}
	return ""
}

type CodeCoverage_Blamelist struct {
	// Changed paths (usually directories) in a typical checkout of the Chrome
	// OS source tree.
	//
	// Paths are relative to `repo` root. e.g., `src/platform2/shill`.
	RepoPaths            []string `protobuf:"bytes,1,rep,name=repo_paths,json=repoPaths,proto3" json:"repo_paths,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_CodeCoverage_Blamelist proto.InternalMessageInfo

func (m *CodeCoverage_Blamelist) GetRepoPaths() []string {
	if m != nil {
		return m.RepoPaths
	}
	return nil
}

func init() {
	proto.RegisterEnum("test.plan.v1.Exclusion_Type", Exclusion_Type_name, Exclusion_Type_value)
	proto.RegisterEnum("test.plan.v1.Exclusion_Action", Exclusion_Action_name, Exclusion_Action_value)
	proto.RegisterType((*Specification)(nil), "test.plan.v1.Specification")
	proto.RegisterType((*Plan)(nil), "test.plan.v1.Plan")
	proto.RegisterType((*Unit)(nil), "test.plan.v1.Unit")
	proto.RegisterType((*TestConstraint)(nil), "test.plan.v1.TestConstraint")
	proto.RegisterType((*TestConstraint_Test)(nil), "test.plan.v1.TestConstraint.Test")
	proto.RegisterType((*DUTCoverageConstraint)(nil), "test.plan.v1.DUTCoverageConstraint")
	proto.RegisterType((*DUTCoverageConstraint_DUT)(nil), "test.plan.v1.DUTCoverageConstraint.DUT")
	proto.RegisterType((*Exclusion)(nil), "test.plan.v1.Exclusion")
	proto.RegisterType((*DUTExclusionConstraint)(nil), "test.plan.v1.DUTExclusionConstraint")
	proto.RegisterType((*DUTExclusionConstraint_DUT)(nil), "test.plan.v1.DUTExclusionConstraint.DUT")
	proto.RegisterType((*CodeCoverage)(nil), "test.plan.v1.CodeCoverage")
	proto.RegisterType((*CodeCoverage_Blamelist)(nil), "test.plan.v1.CodeCoverage.Blamelist")
}

func init() { proto.RegisterFile("test/plan/v1/plan.proto", fileDescriptor_1a74b4d4119f628f) }

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