const (
	Default_SatParameters_Name                                           = string("")
	Default_SatParameters_PreferredVariableOrder                         = SatParameters_IN_ORDER
	Default_SatParameters_InitialPolarity                                = SatParameters_POLARITY_FALSE
	Default_SatParameters_UsePhaseSaving                                 = bool(true)
	Default_SatParameters_PolarityRephaseIncrement                       = int32(1000)
	Default_SatParameters_RandomPolarityRatio                            = float64(0)
	Default_SatParameters_RandomBranchesRatio                            = float64(0)
	Default_SatParameters_UseErwaHeuristic                               = bool(false)
	Default_SatParameters_InitialVariablesActivity                       = float64(0)
	Default_SatParameters_AlsoBumpVariablesInConflictReasons             = bool(false)
	Default_SatParameters_MinimizationAlgorithm                          = SatParameters_RECURSIVE
	Default_SatParameters_BinaryMinimizationAlgorithm                    = SatParameters_BINARY_MINIMIZATION_FIRST
	Default_SatParameters_SubsumptionDuringConflictAnalysis              = bool(true)
	Default_SatParameters_ClauseCleanupPeriod                            = int32(10000)
	Default_SatParameters_ClauseCleanupTarget                            = int32(10000)
	Default_SatParameters_ClauseCleanupProtection                        = SatParameters_PROTECTION_NONE
	Default_SatParameters_ClauseCleanupLbdBound                          = int32(5)
	Default_SatParameters_ClauseCleanupOrdering                          = SatParameters_CLAUSE_ACTIVITY
	Default_SatParameters_PbCleanupIncrement                             = int32(200)
	Default_SatParameters_PbCleanupRatio                                 = float64(0.5)
	Default_SatParameters_MinimizeWithPropagationRestartPeriod           = int32(10)
	Default_SatParameters_MinimizeWithPropagationNumDecisions            = int32(1000)
	Default_SatParameters_VariableActivityDecay                          = float64(0.8)
	Default_SatParameters_MaxVariableActivityValue                       = float64(1e+100)
	Default_SatParameters_GlucoseMaxDecay                                = float64(0.95)
	Default_SatParameters_GlucoseDecayIncrement                          = float64(0.01)
	Default_SatParameters_GlucoseDecayIncrementPeriod                    = int32(5000)
	Default_SatParameters_ClauseActivityDecay                            = float64(0.999)
	Default_SatParameters_MaxClauseActivityValue                         = float64(1e+20)
	Default_SatParameters_DefaultRestartAlgorithms                       = string("LUBY_RESTART,LBD_MOVING_AVERAGE_RESTART,DL_MOVING_AVERAGE_RESTART")
	Default_SatParameters_RestartPeriod                                  = int32(50)
	Default_SatParameters_RestartRunningWindowSize                       = int32(50)
	Default_SatParameters_RestartDlAverageRatio                          = float64(1)
	Default_SatParameters_RestartLbdAverageRatio                         = float64(1)
	Default_SatParameters_UseBlockingRestart                             = bool(false)
	Default_SatParameters_BlockingRestartWindowSize                      = int32(5000)
	Default_SatParameters_BlockingRestartMultiplier                      = float64(1.4)
	Default_SatParameters_NumConflictsBeforeStrategyChanges              = int32(0)
	Default_SatParameters_StrategyChangeIncreaseRatio                    = float64(0)
	Default_SatParameters_MaxNumberOfConflicts                           = int64(9223372036854775807)
	Default_SatParameters_MaxMemoryInMb                                  = int64(10000)
	Default_SatParameters_AbsoluteGapLimit                               = float64(0)
	Default_SatParameters_RelativeGapLimit                               = float64(0)
	Default_SatParameters_TreatBinaryClausesSeparately                   = bool(true)
	Default_SatParameters_RandomSeed                                     = int32(1)
	Default_SatParameters_PermuteVariableRandomly                        = bool(false)
	Default_SatParameters_PermutePresolveConstraintOrder                 = bool(false)
	Default_SatParameters_UseAbslRandom                                  = bool(false)
	Default_SatParameters_LogSearchProgress                              = bool(false)
	Default_SatParameters_LogPrefix                                      = string("")
	Default_SatParameters_LogToStdout                                    = bool(true)
	Default_SatParameters_LogToResponse                                  = bool(false)
	Default_SatParameters_UsePbResolution                                = bool(false)
	Default_SatParameters_MinimizeReductionDuringPbResolution            = bool(false)
	Default_SatParameters_CountAssumptionLevelsInLbd                     = bool(true)
	Default_SatParameters_PresolveBveThreshold                           = int32(500)
	Default_SatParameters_PresolveBveClauseWeight                        = int32(3)
	Default_SatParameters_PresolveProbingDeterministicTimeLimit          = float64(30)
	Default_SatParameters_PresolveBlockedClause                          = bool(true)
	Default_SatParameters_PresolveUseBva                                 = bool(true)
	Default_SatParameters_PresolveBvaThreshold                           = int32(1)
	Default_SatParameters_MaxPresolveIterations                          = int32(3)
	Default_SatParameters_CpModelPresolve                                = bool(true)
	Default_SatParameters_CpModelPostsolveWithFullSolver                 = bool(false)
	Default_SatParameters_CpModelMaxNumPresolveOperations                = int32(0)
	Default_SatParameters_CpModelProbingLevel                            = int32(2)
	Default_SatParameters_CpModelUseSatPresolve                          = bool(true)
	Default_SatParameters_UseSatInprocessing                             = bool(false)
	Default_SatParameters_ExpandElementConstraints                       = bool(true)
	Default_SatParameters_ExpandAutomatonConstraints                     = bool(true)
	Default_SatParameters_ExpandTableConstraints                         = bool(true)
	Default_SatParameters_ExpandAlldiffConstraints                       = bool(false)
	Default_SatParameters_ExpandReservoirConstraints                     = bool(true)
	Default_SatParameters_DisableConstraintExpansion                     = bool(false)
	Default_SatParameters_MergeNoOverlapWorkLimit                        = float64(1e+12)
	Default_SatParameters_MergeAtMostOneWorkLimit                        = float64(1e+08)
	Default_SatParameters_PresolveSubstitutionLevel                      = int32(1)
	Default_SatParameters_PresolveExtractIntegerEnforcement              = bool(false)
	Default_SatParameters_UseOptimizationHints                           = bool(true)
	Default_SatParameters_MinimizeCore                                   = bool(true)
	Default_SatParameters_FindMultipleCores                              = bool(true)
	Default_SatParameters_CoverOptimization                              = bool(true)
	Default_SatParameters_MaxSatAssumptionOrder                          = SatParameters_DEFAULT_ASSUMPTION_ORDER
	Default_SatParameters_MaxSatReverseAssumptionOrder                   = bool(false)
	Default_SatParameters_MaxSatStratification                           = SatParameters_STRATIFICATION_DESCENT
	Default_SatParameters_UsePrecedencesInDisjunctiveConstraint          = bool(true)
	Default_SatParameters_UseOverloadCheckerInCumulativeConstraint       = bool(false)
	Default_SatParameters_UseTimetableEdgeFindingInCumulativeConstraint  = bool(false)
	Default_SatParameters_UseDisjunctiveConstraintInCumulativeConstraint = bool(true)
	Default_SatParameters_LinearizationLevel                             = int32(1)
	Default_SatParameters_BooleanEncodingLevel                           = int32(1)
	Default_SatParameters_MaxNumCuts                                     = int32(10000)
	Default_SatParameters_OnlyAddCutsAtLevelZero                         = bool(false)
	Default_SatParameters_AddKnapsackCuts                                = bool(false)
	Default_SatParameters_AddCgCuts                                      = bool(true)
	Default_SatParameters_AddMirCuts                                     = bool(true)
	Default_SatParameters_AddZeroHalfCuts                                = bool(true)
	Default_SatParameters_AddCliqueCuts                                  = bool(true)
	Default_SatParameters_MaxAllDiffCutSize                              = int32(7)
	Default_SatParameters_AddLinMaxCuts                                  = bool(true)
	Default_SatParameters_MaxIntegerRoundingScaling                      = int32(600)
	Default_SatParameters_AddLpConstraintsLazily                         = bool(true)
	Default_SatParameters_MinOrthogonalityForLpConstraints               = float64(0.05)
	Default_SatParameters_MaxCutRoundsAtLevelZero                        = int32(1)
	Default_SatParameters_MaxConsecutiveInactiveCount                    = int32(100)
	Default_SatParameters_CutMaxActiveCountValue                         = float64(1e+10)
	Default_SatParameters_CutActiveCountDecay                            = float64(0.8)
	Default_SatParameters_CutCleanupTarget                               = int32(1000)
	Default_SatParameters_NewConstraintsBatchSize                        = int32(50)
	Default_SatParameters_SearchBranching                                = SatParameters_AUTOMATIC_SEARCH
	Default_SatParameters_HintConflictLimit                              = int32(10)
	Default_SatParameters_RepairHint                                     = bool(false)
	Default_SatParameters_ExploitIntegerLpSolution                       = bool(true)
	Default_SatParameters_ExploitAllLpSolution                           = bool(true)
	Default_SatParameters_ExploitBestSolution                            = bool(false)
	Default_SatParameters_ExploitRelaxationSolution                      = bool(false)
	Default_SatParameters_ExploitObjective                               = bool(true)
	Default_SatParameters_ProbingPeriodAtRoot                            = int64(0)
	Default_SatParameters_UseProbingSearch                               = bool(false)
	Default_SatParameters_PseudoCostReliabilityThreshold                 = int64(100)
	Default_SatParameters_OptimizeWithCore                               = bool(false)
	Default_SatParameters_BinarySearchNumConflicts                       = int32(-1)
	Default_SatParameters_OptimizeWithMaxHs                              = bool(false)
	Default_SatParameters_EnumerateAllSolutions                          = bool(false)
	Default_SatParameters_KeepAllFeasibleSolutionsInPresolve             = bool(false)
	Default_SatParameters_FillTightenedDomainsInResponse                 = bool(false)
	Default_SatParameters_InstantiateAllVariables                        = bool(true)
	Default_SatParameters_AutoDetectGreaterThanAtLeastOneOf              = bool(true)
	Default_SatParameters_StopAfterFirstSolution                         = bool(false)
	Default_SatParameters_StopAfterPresolve                              = bool(false)
	Default_SatParameters_NumSearchWorkers                               = int32(1)
	Default_SatParameters_InterleaveSearch                               = bool(false)
	Default_SatParameters_InterleaveBatchSize                            = int32(1)
	Default_SatParameters_ReduceMemoryUsageInInterleaveMode              = bool(false)
	Default_SatParameters_ShareObjectiveBounds                           = bool(true)
	Default_SatParameters_ShareLevelZeroBounds                           = bool(true)
	Default_SatParameters_UseLnsOnly                                     = bool(false)
	Default_SatParameters_LnsFocusOnDecisionVariables                    = bool(false)
	Default_SatParameters_LnsExpandIntervalsInConstraintGraph            = bool(true)
	Default_SatParameters_UseRinsLns                                     = bool(true)
	Default_SatParameters_UseFeasibilityPump                             = bool(true)
	Default_SatParameters_FpRounding                                     = SatParameters_PROPAGATION_ASSISTED
	Default_SatParameters_UseRelaxationLns                               = bool(false)
	Default_SatParameters_DiversifyLnsParams                             = bool(false)
	Default_SatParameters_RandomizeSearch                                = bool(false)
	Default_SatParameters_SearchRandomizationTolerance                   = int64(0)
	Default_SatParameters_UseOptionalVariables                           = bool(true)
	Default_SatParameters_UseExactLpReason                               = bool(true)
	Default_SatParameters_UseBranchingInLp                               = bool(false)
	Default_SatParameters_UseCombinedNoOverlap                           = bool(false)
	Default_SatParameters_CatchSigintSignal                              = bool(true)
	Default_SatParameters_UseImpliedBounds                               = bool(true)
	Default_SatParameters_PolishLpSolution                               = bool(false)
	Default_SatParameters_ConvertIntervals                               = bool(false)
	Default_SatParameters_SymmetryLevel                                  = int32(2)
	Default_SatParameters_MipMaxBound                                    = float64(1e+07)
	Default_SatParameters_MipVarScaling                                  = float64(1)
	Default_SatParameters_MipAutomaticallyScaleVariables                 = bool(true)
	Default_SatParameters_MipWantedPrecision                             = float64(1e-06)
	Default_SatParameters_MipMaxActivityExponent                         = int32(53)
	Default_SatParameters_MipCheckPrecision                              = float64(0.0001)
)

var (
	CpSolverStatus_name = map[int32]string{
		0: "UNKNOWN",
		1: "MODEL_INVALID",
		2: "FEASIBLE",
		3: "INFEASIBLE",
		4: "OPTIMAL",
	}
	CpSolverStatus_value = map[string]int32{
		"UNKNOWN":       0,
		"MODEL_INVALID": 1,
		"FEASIBLE":      2,
		"INFEASIBLE":    3,
		"OPTIMAL":       4,
	}
)

var (
	DecisionStrategyProto_VariableSelectionStrategy_name = map[int32]string{
		0: "CHOOSE_FIRST",
		1: "CHOOSE_LOWEST_MIN",
		2: "CHOOSE_HIGHEST_MAX",
		3: "CHOOSE_MIN_DOMAIN_SIZE",
		4: "CHOOSE_MAX_DOMAIN_SIZE",
	}
	DecisionStrategyProto_VariableSelectionStrategy_value = map[string]int32{
		"CHOOSE_FIRST":           0,
		"CHOOSE_LOWEST_MIN":      1,
		"CHOOSE_HIGHEST_MAX":     2,
		"CHOOSE_MIN_DOMAIN_SIZE": 3,
		"CHOOSE_MAX_DOMAIN_SIZE": 4,
	}
)

var (
	DecisionStrategyProto_DomainReductionStrategy_name = map[int32]string{
		0: "SELECT_MIN_VALUE",
		1: "SELECT_MAX_VALUE",
		2: "SELECT_LOWER_HALF",
		3: "SELECT_UPPER_HALF",
		4: "SELECT_MEDIAN_VALUE",
	}
	DecisionStrategyProto_DomainReductionStrategy_value = map[string]int32{
		"SELECT_MIN_VALUE":    0,
		"SELECT_MAX_VALUE":    1,
		"SELECT_LOWER_HALF":   2,
		"SELECT_UPPER_HALF":   3,
		"SELECT_MEDIAN_VALUE": 4,
	}
)

var (
	SatParameters_VariableOrder_name = map[int32]string{
		0: "IN_ORDER",
		1: "IN_REVERSE_ORDER",
		2: "IN_RANDOM_ORDER",
	}
	SatParameters_VariableOrder_value = map[string]int32{
		"IN_ORDER":         0,
		"IN_REVERSE_ORDER": 1,
		"IN_RANDOM_ORDER":  2,
	}
)

var (
	SatParameters_Polarity_name = map[int32]string{
		0: "POLARITY_TRUE",
		1: "POLARITY_FALSE",
		2: "POLARITY_RANDOM",
		3: "POLARITY_WEIGHTED_SIGN",
		4: "POLARITY_REVERSE_WEIGHTED_SIGN",
	}
	SatParameters_Polarity_value = map[string]int32{
		"POLARITY_TRUE":                  0,
		"POLARITY_FALSE":                 1,
		"POLARITY_RANDOM":                2,
		"POLARITY_WEIGHTED_SIGN":         3,
		"POLARITY_REVERSE_WEIGHTED_SIGN": 4,
	}
)

var (
	SatParameters_ConflictMinimizationAlgorithm_name = map[int32]string{
		0: "NONE",
		1: "SIMPLE",
		2: "RECURSIVE",
		3: "EXPERIMENTAL",
	}
	SatParameters_ConflictMinimizationAlgorithm_value = map[string]int32{
		"NONE":         0,
		"SIMPLE":       1,
		"RECURSIVE":    2,
		"EXPERIMENTAL": 3,
	}
)

var (
	SatParameters_BinaryMinizationAlgorithm_name = map[int32]string{
		0: "NO_BINARY_MINIMIZATION",
		1: "BINARY_MINIMIZATION_FIRST",
		4: "BINARY_MINIMIZATION_FIRST_WITH_TRANSITIVE_REDUCTION",
		2: "BINARY_MINIMIZATION_WITH_REACHABILITY",
		3: "EXPERIMENTAL_BINARY_MINIMIZATION",
	}
	SatParameters_BinaryMinizationAlgorithm_value = map[string]int32{
		"NO_BINARY_MINIMIZATION":                              0,
		"BINARY_MINIMIZATION_FIRST":                           1,
		"BINARY_MINIMIZATION_FIRST_WITH_TRANSITIVE_REDUCTION": 4,
		"BINARY_MINIMIZATION_WITH_REACHABILITY":               2,
		"EXPERIMENTAL_BINARY_MINIMIZATION":                    3,
	}
)

var (
	SatParameters_ClauseProtection_name = map[int32]string{
		0: "PROTECTION_NONE",
		1: "PROTECTION_ALWAYS",
		2: "PROTECTION_LBD",
	}
	SatParameters_ClauseProtection_value = map[string]int32{
		"PROTECTION_NONE":   0,
		"PROTECTION_ALWAYS": 1,
		"PROTECTION_LBD":    2,
	}
)

var (
	SatParameters_ClauseOrdering_name = map[int32]string{
		0: "CLAUSE_ACTIVITY",
		1: "CLAUSE_LBD",
	}
	SatParameters_ClauseOrdering_value = map[string]int32{
		"CLAUSE_ACTIVITY": 0,
		"CLAUSE_LBD":      1,
	}
)

var (
	SatParameters_RestartAlgorithm_name = map[int32]string{
		0: "NO_RESTART",
		1: "LUBY_RESTART",
		2: "DL_MOVING_AVERAGE_RESTART",
		3: "LBD_MOVING_AVERAGE_RESTART",
		4: "FIXED_RESTART",
	}
	SatParameters_RestartAlgorithm_value = map[string]int32{
		"NO_RESTART":                 0,
		"LUBY_RESTART":               1,
		"DL_MOVING_AVERAGE_RESTART":  2,
		"LBD_MOVING_AVERAGE_RESTART": 3,
		"FIXED_RESTART":              4,
	}
)

var (
	SatParameters_MaxSatAssumptionOrder_name = map[int32]string{
		0: "DEFAULT_ASSUMPTION_ORDER",
		1: "ORDER_ASSUMPTION_BY_DEPTH",
		2: "ORDER_ASSUMPTION_BY_WEIGHT",
	}
	SatParameters_MaxSatAssumptionOrder_value = map[string]int32{
		"DEFAULT_ASSUMPTION_ORDER":   0,
		"ORDER_ASSUMPTION_BY_DEPTH":  1,
		"ORDER_ASSUMPTION_BY_WEIGHT": 2,
	}
)

var (
	SatParameters_MaxSatStratificationAlgorithm_name = map[int32]string{
		0: "STRATIFICATION_NONE",
		1: "STRATIFICATION_DESCENT",
		2: "STRATIFICATION_ASCENT",
	}
	SatParameters_MaxSatStratificationAlgorithm_value = map[string]int32{
		"STRATIFICATION_NONE":    0,
		"STRATIFICATION_DESCENT": 1,
		"STRATIFICATION_ASCENT":  2,
	}
)

var (
	SatParameters_SearchBranching_name = map[int32]string{
		0: "AUTOMATIC_SEARCH",
		1: "FIXED_SEARCH",
		2: "PORTFOLIO_SEARCH",
		3: "LP_SEARCH",
		4: "PSEUDO_COST_SEARCH",
		5: "PORTFOLIO_WITH_QUICK_RESTART_SEARCH",
		6: "HINT_SEARCH",
	}
	SatParameters_SearchBranching_value = map[string]int32{
		"AUTOMATIC_SEARCH":                    0,
		"FIXED_SEARCH":                        1,
		"PORTFOLIO_SEARCH":                    2,
		"LP_SEARCH":                           3,
		"PSEUDO_COST_SEARCH":                  4,
		"PORTFOLIO_WITH_QUICK_RESTART_SEARCH": 5,
		"HINT_SEARCH":                         6,
	}
)

var (
	SatParameters_FPRoundingMethod_name = map[int32]string{
		0: "NEAREST_INTEGER",
		1: "LOCK_BASED",
		3: "ACTIVE_LOCK_BASED",
		2: "PROPAGATION_ASSISTED",
	}
	SatParameters_FPRoundingMethod_value = map[string]int32{
		"NEAREST_INTEGER":      0,
		"LOCK_BASED":           1,
		"ACTIVE_LOCK_BASED":    3,
		"PROPAGATION_ASSISTED": 2,
	}
)

var (
	Default_SatParameters_MaxTimeInSeconds     = float64(math.Inf(+1))
	Default_SatParameters_MaxDeterministicTime = float64(math.Inf(+1))
)

var File_cp_model_proto protoreflect.FileDescriptor

var File_sat_parameters_proto protoreflect.FileDescriptor

type AllDifferentConstraintProto struct {
	Vars []int32 `protobuf:"varint,1,rep,packed,name=vars,proto3" json:"vars,omitempty"`
	// contains filtered or unexported fields
}

type AutomatonConstraintProto struct {

	// A state is identified by a non-negative number. It is preferable to keep
	// all the states dense in says [0, num_states). The automaton starts at
	// starting_state and must finish in any of the final states.
	StartingState int64   `protobuf:"varint,2,opt,name=starting_state,json=startingState,proto3" json:"starting_state,omitempty"`
	FinalStates   []int64 `protobuf:"varint,3,rep,packed,name=final_states,json=finalStates,proto3" json:"final_states,omitempty"`
	// List of transitions (all 3 vectors have the same size). Both tail and head
	// are states, label is any variable value. No two outgoing transitions from
	// the same state can have the same label.
	TransitionTail  []int64 `protobuf:"varint,4,rep,packed,name=transition_tail,json=transitionTail,proto3" json:"transition_tail,omitempty"`
	TransitionHead  []int64 `protobuf:"varint,5,rep,packed,name=transition_head,json=transitionHead,proto3" json:"transition_head,omitempty"`
	TransitionLabel []int64 `protobuf:"varint,6,rep,packed,name=transition_label,json=transitionLabel,proto3" json:"transition_label,omitempty"`
	// The sequence of variables. The automaton is ran for vars_size() "steps" and
	// the value of vars[i] corresponds to the transition label at step i.
	Vars []int32 `protobuf:"varint,7,rep,packed,name=vars,proto3" json:"vars,omitempty"`
	// contains filtered or unexported fields
}

type BoolArgumentProto struct {
	Literals []int32 `protobuf:"varint,1,rep,packed,name=literals,proto3" json:"literals,omitempty"`
	// contains filtered or unexported fields
}

type CircuitConstraintProto struct {
	Tails    []int32 `protobuf:"varint,3,rep,packed,name=tails,proto3" json:"tails,omitempty"`
	Heads    []int32 `protobuf:"varint,4,rep,packed,name=heads,proto3" json:"heads,omitempty"`
	Literals []int32 `protobuf:"varint,5,rep,packed,name=literals,proto3" json:"literals,omitempty"`
	// contains filtered or unexported fields
}

type ConstraintProto struct {

	// For debug/logging only. Can be empty.
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// The constraint will be enforced iff all literals listed here are true. If
	// this is empty, then the constraint will always be enforced. An enforced
	// constraint must be satisfied, and an un-enforced one will simply be
	// ignored.
	//
	// This is also called half-reification. To have an equivalence between a
	// literal and a constraint (full reification), one must add both a constraint
	// (controlled by a literal l) and its negation (controlled by the negation of
	// l).
	//
	// Important: as of September 2018, only a few constraint support enforcement:
	// - bool_or, bool_and, linear: fully supported.
	// - interval: only support a single enforcement literal.
	// - other: no support (but can be added on a per-demand basis).
	EnforcementLiteral []int32 `protobuf:"varint,2,rep,packed,name=enforcement_literal,json=enforcementLiteral,proto3" json:"enforcement_literal,omitempty"`
	// The actual constraint with its arguments.
	//
	// Types that are assignable to Constraint:
	//	*ConstraintProto_BoolOr
	//	*ConstraintProto_BoolAnd
	//	*ConstraintProto_AtMostOne
	//	*ConstraintProto_ExactlyOne
	//	*ConstraintProto_BoolXor
	//	*ConstraintProto_IntDiv
	//	*ConstraintProto_IntMod
	//	*ConstraintProto_IntMax
	//	*ConstraintProto_LinMax
	//	*ConstraintProto_IntMin
	//	*ConstraintProto_LinMin
	//	*ConstraintProto_IntProd
	//	*ConstraintProto_Linear
	//	*ConstraintProto_AllDiff
	//	*ConstraintProto_Element
	//	*ConstraintProto_Circuit
	//	*ConstraintProto_Routes
	//	*ConstraintProto_Table
	//	*ConstraintProto_Automaton
	//	*ConstraintProto_Inverse
	//	*ConstraintProto_Reservoir
	//	*ConstraintProto_Interval
	//	*ConstraintProto_NoOverlap
	//	*ConstraintProto_NoOverlap_2D
	//	*ConstraintProto_Cumulative
	Constraint isConstraintProto_Constraint `protobuf_oneof:"constraint"`
	// contains filtered or unexported fields
}

type ConstraintProto_AllDiff struct {
	// The all_diff constraint forces all variables to take different values.
	AllDiff *AllDifferentConstraintProto `protobuf:"bytes,13,opt,name=all_diff,json=allDiff,proto3,oneof"`
}

type ConstraintProto_AtMostOne struct {
	// The at_most_one constraint enforces that no more than one literal is
	// true at the same time.
	//
	// Note that an at most one constraint of length n could be encoded with n
	// bool_and constraint with n-1 term on the right hand side. So in a sense,
	// this constraint contribute directly to the "implication-graph" or the
	// 2-SAT part of the model.
	//
	// This constraint does not support enforcement_literal. Just use a linear
	// constraint if you need to enforce it. You also do not need to use it
	// directly, we will extract it from the model in most situations.
	AtMostOne *BoolArgumentProto `protobuf:"bytes,26,opt,name=at_most_one,json=atMostOne,proto3,oneof"`
}

type ConstraintProto_Automaton struct {
	// The automaton constraint forces a sequence of variables to be accepted
	// by an automaton.
	Automaton *AutomatonConstraintProto `protobuf:"bytes,17,opt,name=automaton,proto3,oneof"`
}

type ConstraintProto_BoolAnd struct {
	// The bool_and constraint forces all of the literals to be true.
	//
	// This is a "redundant" constraint in the sense that this can easily be
	// encoded with many bool_or or at_most_one. It is just more space efficient
	// and handled slightly differently internally.
	BoolAnd *BoolArgumentProto `protobuf:"bytes,4,opt,name=bool_and,json=boolAnd,proto3,oneof"`
}

type ConstraintProto_BoolOr struct {
	// The bool_or constraint forces at least one literal to be true.
	BoolOr *BoolArgumentProto `protobuf:"bytes,3,opt,name=bool_or,json=boolOr,proto3,oneof"`
}

type ConstraintProto_BoolXor struct {
	// The bool_xor constraint forces an odd number of the literals to be true.
	BoolXor *BoolArgumentProto `protobuf:"bytes,5,opt,name=bool_xor,json=boolXor,proto3,oneof"`
}

type ConstraintProto_Circuit struct {
	// The circuit constraint takes a graph and forces the arcs present
	// (with arc presence indicated by a literal) to form a unique cycle.
	Circuit *CircuitConstraintProto `protobuf:"bytes,15,opt,name=circuit,proto3,oneof"`
}

type ConstraintProto_Cumulative struct {
	// The cumulative constraint ensures that for any integer point, the sum
	// of the demands of the intervals containing that point does not exceed
	// the capacity.
	Cumulative *CumulativeConstraintProto `protobuf:"bytes,22,opt,name=cumulative,proto3,oneof"`
}

type ConstraintProto_Element struct {
	// The element constraint forces the variable with the given index
	// to be equal to the target.
	Element *ElementConstraintProto `protobuf:"bytes,14,opt,name=element,proto3,oneof"`
}

type ConstraintProto_ExactlyOne struct {
	// The exactly_one constraint force exactly one literal to true and no more.
	//
	// Anytime a bool_or (it could have been called at_least_one) is included
	// into an at_most_one, then the bool_or is actually an exactly one
	// constraint, and the extra literal in the at_most_one can be set to false.
	// So in this sense, this constraint is not really needed. it is just here
	// for a better description of the problem structure and to facilitate some
	// algorithm.
	//
	// This constraint does not support enforcement_literal. Just use a linear
	// constraint if you need to enforce it. You also do not need to use it
	// directly, we will extract it from the model in most situations.
	ExactlyOne *BoolArgumentProto `protobuf:"bytes,29,opt,name=exactly_one,json=exactlyOne,proto3,oneof"`
}

type ConstraintProto_IntDiv struct {
	// The int_div constraint forces the target to equal vars[0] / vars[1].
	// In particular, vars[1] can never take the value 0.
	IntDiv *IntegerArgumentProto `protobuf:"bytes,7,opt,name=int_div,json=intDiv,proto3,oneof"`
}

type ConstraintProto_IntMax struct {
	// The int_max constraint forces the target to equal the maximum of all
	// variables.
	//
	// The lin_max constraint forces the target to equal the maximum of all
	// linear expressions.
	//
	// TODO(user): Remove int_max in favor of lin_max.
	IntMax *IntegerArgumentProto `protobuf:"bytes,9,opt,name=int_max,json=intMax,proto3,oneof"`
}

type ConstraintProto_IntMin struct {
	// The int_min constraint forces the target to equal the minimum of all
	// variables.
	//
	// The lin_min constraint forces the target to equal the minimum of all
	// linear expressions.
	//
	// TODO(user): Remove int_min in favor of lin_min.
	IntMin *IntegerArgumentProto `protobuf:"bytes,10,opt,name=int_min,json=intMin,proto3,oneof"`
}

type ConstraintProto_IntMod struct {
	// The int_mod constraint forces the target to equal vars[0] % vars[1].
	// The domain of vars[1] must be strictly positive.
	IntMod *IntegerArgumentProto `protobuf:"bytes,8,opt,name=int_mod,json=intMod,proto3,oneof"`
}

type ConstraintProto_IntProd struct {
	// The int_prod constraint forces the target to equal the product of all
	// variables. By convention, because we can just remove term equal to one,
	// the empty product forces the target to be one.
	//
	// TODO(user): Support more than two terms in the product.
	IntProd *IntegerArgumentProto `protobuf:"bytes,11,opt,name=int_prod,json=intProd,proto3,oneof"`
}

type ConstraintProto_Interval struct {
	// The interval constraint takes a start, end, and size, and forces
	// start + size == end.
	Interval *IntervalConstraintProto `protobuf:"bytes,19,opt,name=interval,proto3,oneof"`
}

type ConstraintProto_Inverse struct {
	// The inverse constraint forces two arrays to be inverses of each other:
	// the values of one are the indices of the other, and vice versa.
	Inverse *InverseConstraintProto `protobuf:"bytes,18,opt,name=inverse,proto3,oneof"`
}

type ConstraintProto_LinMax struct {
	LinMax *LinearArgumentProto `protobuf:"bytes,27,opt,name=lin_max,json=linMax,proto3,oneof"`
}

type ConstraintProto_LinMin struct {
	LinMin *LinearArgumentProto `protobuf:"bytes,28,opt,name=lin_min,json=linMin,proto3,oneof"`
}

type ConstraintProto_Linear struct {
	// The linear constraint enforces a linear inequality among the variables,
	// such as 0 <= x + 2y <= 10.
	Linear *LinearConstraintProto `protobuf:"bytes,12,opt,name=linear,proto3,oneof"`
}

type ConstraintProto_NoOverlap struct {
	// The no_overlap constraint prevents a set of intervals from
	// overlapping; in scheduling, this is called a disjunctive
	// constraint.
	NoOverlap *NoOverlapConstraintProto `protobuf:"bytes,20,opt,name=no_overlap,json=noOverlap,proto3,oneof"`
}

type ConstraintProto_NoOverlap_2D struct {
	// The no_overlap_2d constraint prevents a set of boxes from overlapping.
	NoOverlap_2D *NoOverlap2DConstraintProto `protobuf:"bytes,21,opt,name=no_overlap_2d,json=noOverlap2d,proto3,oneof"`
}

type ConstraintProto_Reservoir struct {
	// The reservoir constraint forces the sum of a set of active demands
	// to always be between a specified minimum and maximum value during
	// specific times.
	Reservoir *ReservoirConstraintProto `protobuf:"bytes,24,opt,name=reservoir,proto3,oneof"`
}

type ConstraintProto_Routes struct {
	// The routes constraint implements the vehicle routing problem.
	Routes *RoutesConstraintProto `protobuf:"bytes,23,opt,name=routes,proto3,oneof"`
}

type ConstraintProto_Table struct {
	// The table constraint enforces what values a tuple of variables may
	// take.
	Table *TableConstraintProto `protobuf:"bytes,16,opt,name=table,proto3,oneof"`
}

type CpModelProto struct {

	// For debug/logging only. Can be empty.
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// The associated Protos should be referred by their index in these fields.
	Variables   []*IntegerVariableProto `protobuf:"bytes,2,rep,name=variables,proto3" json:"variables,omitempty"`
	Constraints []*ConstraintProto      `protobuf:"bytes,3,rep,name=constraints,proto3" json:"constraints,omitempty"`
	// The objective to minimize. Can be empty for pure decision problems.
	Objective *CpObjectiveProto `protobuf:"bytes,4,opt,name=objective,proto3" json:"objective,omitempty"`
	// Defines the strategy that the solver should follow when the
	// search_branching parameter is set to FIXED_SEARCH. Note that this strategy
	// is also used as a heuristic when we are not in fixed search.
	//
	// Advanced Usage: if not all variables appears and the parameter
	// "instantiate_all_variables" is set to false, then the solver will not try
	// to instantiate the variables that do not appear. Thus, at the end of the
	// search, not all variables may be fixed and this is why we have the
	// solution_lower_bounds and solution_upper_bounds fields in the
	// CpSolverResponse.
	SearchStrategy []*DecisionStrategyProto `protobuf:"bytes,5,rep,name=search_strategy,json=searchStrategy,proto3" json:"search_strategy,omitempty"`
	// Solution hint.
	//
	// If a feasible or almost-feasible solution to the problem is already known,
	// it may be helpful to pass it to the solver so that it can be used. The
	// solver will try to use this information to create its initial feasible
	// solution.
	//
	// Note that it may not always be faster to give a hint like this to the
	// solver. There is also no guarantee that the solver will use this hint or
	// try to return a solution "close" to this assignment in case of multiple
	// optimal solutions.
	SolutionHint *PartialVariableAssignment `protobuf:"bytes,6,opt,name=solution_hint,json=solutionHint,proto3" json:"solution_hint,omitempty"`
	// A list of literals. The model will be solved assuming all these literals
	// are true. Compared to just fixing the domain of these literals, using this
	// mechanism is slower but allows in case the model is INFEASIBLE to get a
	// potentially small subset of them that can be used to explain the
	// infeasibility.
	//
	// Think (IIS), except when you are only concerned by the provided
	// assumptions. This is powerful as it allows to group a set of logicially
	// related constraint under only one enforcement literal which can potentially
	// give you a good and interpretable explanation for infeasiblity.
	//
	// Such infeasibility explanation will be available in the
	// sufficient_assumptions_for_infeasibility response field.
	Assumptions []int32 `protobuf:"varint,7,rep,packed,name=assumptions,proto3" json:"assumptions,omitempty"`
	// For now, this is not meant to be filled by a client writing a model, but
	// by our preprocessing step.
	//
	// Information about the symmetries of the feasible solution space.
	// These usually leaves the objective invariant.
	Symmetry *SymmetryProto `protobuf:"bytes,8,opt,name=symmetry,proto3" json:"symmetry,omitempty"`
	// contains filtered or unexported fields
}

type CpObjectiveProto struct {

	// The linear terms of the objective to minimize.
	// For a maximization problem, one can negate all coefficients in the
	// objective and set a scaling_factor to -1.
	Vars   []int32 `protobuf:"varint,1,rep,packed,name=vars,proto3" json:"vars,omitempty"`
	Coeffs []int64 `protobuf:"varint,4,rep,packed,name=coeffs,proto3" json:"coeffs,omitempty"`
	// The displayed objective is always:
	//   scaling_factor * (sum(coefficients[i] * objective_vars[i]) + offset).
	// This is needed to have a consistent objective after presolve or when
	// scaling a double problem to express it with integers.
	//
	// Note that if scaling_factor is zero, then it is assumed to be 1, so that by
	// default these fields have no effect.
	Offset        float64 `protobuf:"fixed64,2,opt,name=offset,proto3" json:"offset,omitempty"`
	ScalingFactor float64 `protobuf:"fixed64,3,opt,name=scaling_factor,json=scalingFactor,proto3" json:"scaling_factor,omitempty"`
	// If non-empty, only look for an objective value in the given domain.
	// Note that this does not depend on the offset or scaling factor, it is a
	// domain on the sum of the objective terms only.
	Domain []int64 `protobuf:"varint,5,rep,packed,name=domain,proto3" json:"domain,omitempty"`
	// contains filtered or unexported fields
}

type CpSolverResponse struct {

	// The status of the solve.
	Status CpSolverStatus `protobuf:"varint,1,opt,name=status,proto3,enum=operations_research.sat.CpSolverStatus" json:"status,omitempty"`
	// A feasible solution to the given problem. Depending on the returned status
	// it may be optimal or just feasible. This is in one-to-one correspondence
	// with a CpModelProto::variables repeated field and list the values of all
	// the variables.
	Solution []int64 `protobuf:"varint,2,rep,packed,name=solution,proto3" json:"solution,omitempty"`
	// Only make sense for an optimization problem. The objective value of the
	// returned solution if it is non-empty. If there is no solution, then for a
	// minimization problem, this will be an upper-bound of the objective of any
	// feasible solution, and a lower-bound for a maximization problem.
	ObjectiveValue float64 `protobuf:"fixed64,3,opt,name=objective_value,json=objectiveValue,proto3" json:"objective_value,omitempty"`
	// Only make sense for an optimization problem. A proven lower-bound on the
	// objective for a minimization problem, or a proven upper-bound for a
	// maximization problem.
	BestObjectiveBound float64 `protobuf:"fixed64,4,opt,name=best_objective_bound,json=bestObjectiveBound,proto3" json:"best_objective_bound,omitempty"`
	// Advanced usage.
	//
	// If the problem has some variables that are not fixed at the end of the
	// search (because of a particular search strategy in the CpModelProto) then
	// this will be used instead of filling the solution above. The two fields
	// will then contains the lower and upper bounds of each variable as they were
	// when the best "solution" was found.
	SolutionLowerBounds []int64 `protobuf:"varint,18,rep,packed,name=solution_lower_bounds,json=solutionLowerBounds,proto3" json:"solution_lower_bounds,omitempty"`
	SolutionUpperBounds []int64 `protobuf:"varint,19,rep,packed,name=solution_upper_bounds,json=solutionUpperBounds,proto3" json:"solution_upper_bounds,omitempty"`
	// Advanced usage.
	//
	// If the option fill_tightened_domains_in_response is set, then this field
	// will be a copy of the CpModelProto.variables where each domain has been
	// reduced using the information the solver was able to derive. Note that this
	// is only filled with the info derived during a normal search and we do not
	// have any dedicated algorithm to improve it.
	//
	// If the problem is a feasibility problem, then these bounds will be valid
	// for any feasible solution. If the problem is an optimization problem, then
	// these bounds will only be valid for any OPTIMAL solutions, it can exclude
	// sub-optimal feasible ones.
	TightenedVariables []*IntegerVariableProto `protobuf:"bytes,21,rep,name=tightened_variables,json=tightenedVariables,proto3" json:"tightened_variables,omitempty"`
	// A subset of the model "assumptions" field. This will only be filled if the
	// status is INFEASIBLE. This subset of assumption will be enough to still get
	// an infeasible problem.
	//
	// This is related to what is called the irreducible inconsistent subsystem or
	// IIS. Except one is only concerned by the provided assumptions. There is
	// also no guarantee that we return an irreducible (aka minimal subset).
	// However, this is based on SAT explanation and there is a good chance it is
	// not too large.
	//
	// If you really want a minimal subset, a possible way to get one is by
	// changing your model to minimize the number of assumptions at false, but
	// this is likely an harder problem to solve.
	//
	// TODO(user): Allows for returning multiple core at once.
	SufficientAssumptionsForInfeasibility []int32 `protobuf:"varint,23,rep,packed,name=sufficient_assumptions_for_infeasibility,json=sufficientAssumptionsForInfeasibility,proto3" json:"sufficient_assumptions_for_infeasibility,omitempty"`
	// This will be true iff the solver was asked to find all solutions to a
	// satisfiability problem (or all optimal solutions to an optimization
	// problem), and it was successful in doing so.
	//
	// TODO(user): Remove as we also use the OPTIMAL vs FEASIBLE status for that.
	AllSolutionsWereFound bool `protobuf:"varint,5,opt,name=all_solutions_were_found,json=allSolutionsWereFound,proto3" json:"all_solutions_were_found,omitempty"`
	// Some statistics about the solve.
	NumBooleans            int64   `protobuf:"varint,10,opt,name=num_booleans,json=numBooleans,proto3" json:"num_booleans,omitempty"`
	NumConflicts           int64   `protobuf:"varint,11,opt,name=num_conflicts,json=numConflicts,proto3" json:"num_conflicts,omitempty"`
	NumBranches            int64   `protobuf:"varint,12,opt,name=num_branches,json=numBranches,proto3" json:"num_branches,omitempty"`
	NumBinaryPropagations  int64   `protobuf:"varint,13,opt,name=num_binary_propagations,json=numBinaryPropagations,proto3" json:"num_binary_propagations,omitempty"`
	NumIntegerPropagations int64   `protobuf:"varint,14,opt,name=num_integer_propagations,json=numIntegerPropagations,proto3" json:"num_integer_propagations,omitempty"`
	NumRestarts            int64   `protobuf:"varint,24,opt,name=num_restarts,json=numRestarts,proto3" json:"num_restarts,omitempty"`
	NumLpIterations        int64   `protobuf:"varint,25,opt,name=num_lp_iterations,json=numLpIterations,proto3" json:"num_lp_iterations,omitempty"`
	WallTime               float64 `protobuf:"fixed64,15,opt,name=wall_time,json=wallTime,proto3" json:"wall_time,omitempty"`
	UserTime               float64 `protobuf:"fixed64,16,opt,name=user_time,json=userTime,proto3" json:"user_time,omitempty"`
	DeterministicTime      float64 `protobuf:"fixed64,17,opt,name=deterministic_time,json=deterministicTime,proto3" json:"deterministic_time,omitempty"`
	PrimalIntegral         float64 `protobuf:"fixed64,22,opt,name=primal_integral,json=primalIntegral,proto3" json:"primal_integral,omitempty"`
	// Additional information about how the solution was found.
	SolutionInfo string `protobuf:"bytes,20,opt,name=solution_info,json=solutionInfo,proto3" json:"solution_info,omitempty"`
	// The solve log will be filled if the parameter log_to_response is set to
	// true.
	SolveLog string `protobuf:"bytes,26,opt,name=solve_log,json=solveLog,proto3" json:"solve_log,omitempty"`
	// contains filtered or unexported fields
}

type CpSolverStatus int32

const (
	// The status of the model is still unknown. A search limit has been reached
	// before any of the statuses below could be determined.
	CpSolverStatus_UNKNOWN CpSolverStatus = 0
	// The given CpModelProto didn't pass the validation step. You can get a
	// detailed error by calling ValidateCpModel(model_proto).
	CpSolverStatus_MODEL_INVALID CpSolverStatus = 1
	// A feasible solution has been found. But the search was stopped before we
	// could prove optimality or before we enumerated all solutions of a
	// feasibility problem (if asked).
	CpSolverStatus_FEASIBLE CpSolverStatus = 2
	// The problem has been proven infeasible.
	CpSolverStatus_INFEASIBLE CpSolverStatus = 3
	// An optimal feasible solution has been found.
	//
	// More generally, this status represent a success. So we also return OPTIMAL
	// if we find a solution for a pure feasiblity problem or if a gap limit has
	// been specified and we return a solution within this limit. In the case
	// where we need to return all the feasible solution, this status will only be
	// returned if we enumerated all of them; If we stopped before, we will return
	// FEASIBLE.
	CpSolverStatus_OPTIMAL CpSolverStatus = 4
)

type CumulativeConstraintProto struct {
	Capacity  int32   `protobuf:"varint,1,opt,name=capacity,proto3" json:"capacity,omitempty"`
	Intervals []int32 `protobuf:"varint,2,rep,packed,name=intervals,proto3" json:"intervals,omitempty"`
	Demands   []int32 `protobuf:"varint,3,rep,packed,name=demands,proto3" json:"demands,omitempty"` // Same size as intervals.
	// contains filtered or unexported fields
}

type DecisionStrategyProto struct {

	// The variables to be considered for the next decision. The order matter and
	// is always used as a tie-breaker after the variable selection strategy
	// criteria defined below.
	Variables                 []int32                                         `protobuf:"varint,1,rep,packed,name=variables,proto3" json:"variables,omitempty"`
	VariableSelectionStrategy DecisionStrategyProto_VariableSelectionStrategy `protobuf:"varint,2,opt,name=variable_selection_strategy,json=variableSelectionStrategy,proto3,enum=operations_research.sat.DecisionStrategyProto_VariableSelectionStrategy" json:"variable_selection_strategy,omitempty"`
	DomainReductionStrategy   DecisionStrategyProto_DomainReductionStrategy   `protobuf:"varint,3,opt,name=domain_reduction_strategy,json=domainReductionStrategy,proto3,enum=operations_research.sat.DecisionStrategyProto_DomainReductionStrategy" json:"domain_reduction_strategy,omitempty"`
	Transformations           []*DecisionStrategyProto_AffineTransformation   `protobuf:"bytes,4,rep,name=transformations,proto3" json:"transformations,omitempty"`
	// contains filtered or unexported fields
}

type DecisionStrategyProto_AffineTransformation struct {
	Index         int32 `protobuf:"varint,1,opt,name=index,proto3" json:"index,omitempty"`
	Offset        int64 `protobuf:"varint,2,opt,name=offset,proto3" json:"offset,omitempty"`
	PositiveCoeff int64 `protobuf:"varint,3,opt,name=positive_coeff,json=positiveCoeff,proto3" json:"positive_coeff,omitempty"`
	// contains filtered or unexported fields
}

type DecisionStrategyProto_DomainReductionStrategy int32

const (
	DecisionStrategyProto_SELECT_MIN_VALUE    DecisionStrategyProto_DomainReductionStrategy = 0
	DecisionStrategyProto_SELECT_MAX_VALUE    DecisionStrategyProto_DomainReductionStrategy = 1
	DecisionStrategyProto_SELECT_LOWER_HALF   DecisionStrategyProto_DomainReductionStrategy = 2
	DecisionStrategyProto_SELECT_UPPER_HALF   DecisionStrategyProto_DomainReductionStrategy = 3
	DecisionStrategyProto_SELECT_MEDIAN_VALUE DecisionStrategyProto_DomainReductionStrategy = 4
)

type DecisionStrategyProto_VariableSelectionStrategy int32

const (
	DecisionStrategyProto_CHOOSE_FIRST           DecisionStrategyProto_VariableSelectionStrategy = 0
	DecisionStrategyProto_CHOOSE_LOWEST_MIN      DecisionStrategyProto_VariableSelectionStrategy = 1
	DecisionStrategyProto_CHOOSE_HIGHEST_MAX     DecisionStrategyProto_VariableSelectionStrategy = 2
	DecisionStrategyProto_CHOOSE_MIN_DOMAIN_SIZE DecisionStrategyProto_VariableSelectionStrategy = 3
	DecisionStrategyProto_CHOOSE_MAX_DOMAIN_SIZE DecisionStrategyProto_VariableSelectionStrategy = 4
)

type DenseMatrixProto struct {
	NumRows int32   `protobuf:"varint,1,opt,name=num_rows,json=numRows,proto3" json:"num_rows,omitempty"`
	NumCols int32   `protobuf:"varint,2,opt,name=num_cols,json=numCols,proto3" json:"num_cols,omitempty"`
	Entries []int32 `protobuf:"varint,3,rep,packed,name=entries,proto3" json:"entries,omitempty"`
	// contains filtered or unexported fields
}

type ElementConstraintProto struct {
	Index  int32   `protobuf:"varint,1,opt,name=index,proto3" json:"index,omitempty"`
	Target int32   `protobuf:"varint,2,opt,name=target,proto3" json:"target,omitempty"`
	Vars   []int32 `protobuf:"varint,3,rep,packed,name=vars,proto3" json:"vars,omitempty"`
	// contains filtered or unexported fields
}

type IntegerArgumentProto struct {
	Target int32   `protobuf:"varint,1,opt,name=target,proto3" json:"target,omitempty"`
	Vars   []int32 `protobuf:"varint,2,rep,packed,name=vars,proto3" json:"vars,omitempty"`
	// contains filtered or unexported fields
}

type IntegerVariableProto struct {

	// For debug/logging only. Can be empty.
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// The variable domain given as a sorted list of n disjoint intervals
	// [min, max] and encoded as [min_0, max_0,  ..., min_{n-1}, max_{n-1}].
	//
	// The most common example being just [min, max].
	// If min == max, then this is a constant variable.
	//
	// We have:
	//  - domain_size() is always even.
	//  - min == domain.front();
	//  - max == domain.back();
	//  - for all i < n   :      min_i <= max_i
	//  - for all i < n-1 :  max_i + 1 < min_{i+1}.
	//
	// Note that we check at validation that a variable domain is small enough so
	// that we don't run into integer overflow in our algorithms. Because of that,
	// you cannot just have "unbounded" variable like [0, kint64max] and should
	// try to specify tighter domains.
	Domain []int64 `protobuf:"varint,2,rep,packed,name=domain,proto3" json:"domain,omitempty"`
	// contains filtered or unexported fields
}

type IntervalConstraintProto struct {
	Start int32 `protobuf:"varint,1,opt,name=start,proto3" json:"start,omitempty"`
	End   int32 `protobuf:"varint,2,opt,name=end,proto3" json:"end,omitempty"`
	Size  int32 `protobuf:"varint,3,opt,name=size,proto3" json:"size,omitempty"`
	// EXPERIMENTAL: This will become the new way to specify an interval.
	// Depending on the parameters, the presolve will convert the old way to the
	// new way. Do not forget to add an associated linear constraint if you use
	// this directly.
	//
	// If any of this field is set, then all must be set and the ones above will
	// be ignored.
	//
	// IMPORTANT: For now, this constraint do not enforce any relations on the
	// view, and a linear constraint must be added together with this to enforce
	// enforcement => start_view + size_view == end_view. An enforcement =>
	// size_view >=0 might also be needed.
	//
	// IMPORTANT: For now, we just support affine relation. We could easily
	// create an intermediate variable to support full linear expression, but this
	// isn't done currently.
	StartView *LinearExpressionProto `protobuf:"bytes,4,opt,name=start_view,json=startView,proto3" json:"start_view,omitempty"`
	EndView   *LinearExpressionProto `protobuf:"bytes,5,opt,name=end_view,json=endView,proto3" json:"end_view,omitempty"`
	SizeView  *LinearExpressionProto `protobuf:"bytes,6,opt,name=size_view,json=sizeView,proto3" json:"size_view,omitempty"`
	// contains filtered or unexported fields
}

type InverseConstraintProto struct {
	FDirect  []int32 `protobuf:"varint,1,rep,packed,name=f_direct,json=fDirect,proto3" json:"f_direct,omitempty"`
	FInverse []int32 `protobuf:"varint,2,rep,packed,name=f_inverse,json=fInverse,proto3" json:"f_inverse,omitempty"`
	// contains filtered or unexported fields
}

type LinearArgumentProto struct {
	Target *LinearExpressionProto   `protobuf:"bytes,1,opt,name=target,proto3" json:"target,omitempty"`
	Exprs  []*LinearExpressionProto `protobuf:"bytes,2,rep,name=exprs,proto3" json:"exprs,omitempty"`
	// contains filtered or unexported fields
}

type LinearConstraintProto struct {
	Vars   []int32 `protobuf:"varint,1,rep,packed,name=vars,proto3" json:"vars,omitempty"`
	Coeffs []int64 `protobuf:"varint,2,rep,packed,name=coeffs,proto3" json:"coeffs,omitempty"` // Same size as vars.
	Domain []int64 `protobuf:"varint,3,rep,packed,name=domain,proto3" json:"domain,omitempty"`
	// contains filtered or unexported fields
}

type LinearExpressionProto struct {
	Vars   []int32 `protobuf:"varint,1,rep,packed,name=vars,proto3" json:"vars,omitempty"`
	Coeffs []int64 `protobuf:"varint,2,rep,packed,name=coeffs,proto3" json:"coeffs,omitempty"`
	Offset int64   `protobuf:"varint,3,opt,name=offset,proto3" json:"offset,omitempty"`
	// contains filtered or unexported fields
}

type NoOverlap2DConstraintProto struct {
	XIntervals                  []int32 `protobuf:"varint,1,rep,packed,name=x_intervals,json=xIntervals,proto3" json:"x_intervals,omitempty"`
	YIntervals                  []int32 `protobuf:"varint,2,rep,packed,name=y_intervals,json=yIntervals,proto3" json:"y_intervals,omitempty"` // Same size as x_intervals.
	BoxesWithNullAreaCanOverlap bool    `protobuf:"varint,3,opt,name=boxes_with_null_area_can_overlap,json=boxesWithNullAreaCanOverlap,proto3" json:"boxes_with_null_area_can_overlap,omitempty"`
	// contains filtered or unexported fields
}

type NoOverlapConstraintProto struct {
	Intervals []int32 `protobuf:"varint,1,rep,packed,name=intervals,proto3" json:"intervals,omitempty"`
	// contains filtered or unexported fields
}

type PartialVariableAssignment struct {
	Vars   []int32 `protobuf:"varint,1,rep,packed,name=vars,proto3" json:"vars,omitempty"`
	Values []int64 `protobuf:"varint,2,rep,packed,name=values,proto3" json:"values,omitempty"`
	// contains filtered or unexported fields
}

type ReservoirConstraintProto struct {
	MinLevel int64   `protobuf:"varint,1,opt,name=min_level,json=minLevel,proto3" json:"min_level,omitempty"`
	MaxLevel int64   `protobuf:"varint,2,opt,name=max_level,json=maxLevel,proto3" json:"max_level,omitempty"`
	Times    []int32 `protobuf:"varint,3,rep,packed,name=times,proto3" json:"times,omitempty"`     // variables.
	Demands  []int64 `protobuf:"varint,4,rep,packed,name=demands,proto3" json:"demands,omitempty"` // constants, can be negative.
	Actives  []int32 `protobuf:"varint,5,rep,packed,name=actives,proto3" json:"actives,omitempty"` // literals.
	// contains filtered or unexported fields
}

type RoutesConstraintProto struct {
	Tails    []int32 `protobuf:"varint,1,rep,packed,name=tails,proto3" json:"tails,omitempty"`
	Heads    []int32 `protobuf:"varint,2,rep,packed,name=heads,proto3" json:"heads,omitempty"`
	Literals []int32 `protobuf:"varint,3,rep,packed,name=literals,proto3" json:"literals,omitempty"`
	// Experimental. The demands for each node, and the maximum capacity for each
	// route. Note that this is currently only used for the LP relaxation and one
	// need to add the corresponding constraint to enforce this outside of the LP.
	//
	// TODO(user): Ideally, we should be able to extract any dimension like these
	// (i.e. capacity, route_length, etc..) automatically from the encoding. The
	// classical way to encode that is to have "current_capacity" variables along
	// the route and linear equations of the form:
	//   arc_literal => (current_capacity_tail + demand <= current_capacity_head)
	Demands  []int32 `protobuf:"varint,4,rep,packed,name=demands,proto3" json:"demands,omitempty"`
	Capacity int64   `protobuf:"varint,5,opt,name=capacity,proto3" json:"capacity,omitempty"`
	// contains filtered or unexported fields
}

type SatParameters struct {

	// In some context, like in a portfolio of search, it makes sense to name a
	// given parameters set for logging purpose.
	Name                   *string                      `protobuf:"bytes,171,opt,name=name,def=" json:"name,omitempty"`
	PreferredVariableOrder *SatParameters_VariableOrder `protobuf:"varint,1,opt,name=preferred_variable_order,json=preferredVariableOrder,enum=operations_research.sat.SatParameters_VariableOrder,def=0" json:"preferred_variable_order,omitempty"`
	InitialPolarity        *SatParameters_Polarity      `protobuf:"varint,2,opt,name=initial_polarity,json=initialPolarity,enum=operations_research.sat.SatParameters_Polarity,def=1" json:"initial_polarity,omitempty"`
	// If this is true, then the polarity of a variable will be the last value it
	// was assigned to, or its default polarity if it was never assigned since the
	// call to ResetDecisionHeuristic().
	//
	// Actually, we use a newer version where we follow the last value in the
	// longest non-conflicting partial assignment in the current phase.
	//
	// This is called 'literal phase saving'. For details see 'A Lightweight
	// Component Caching Scheme for Satisfiability Solvers' K. Pipatsrisawat and
	// A.Darwiche, In 10th International Conference on Theory and Applications of
	// Satisfiability Testing, 2007.
	UsePhaseSaving *bool `protobuf:"varint,44,opt,name=use_phase_saving,json=usePhaseSaving,def=1" json:"use_phase_saving,omitempty"`
	// If non-zero, then we change the polarity heuristic after that many number
	// of conflicts in an arithmetically increasing fashion. So x the first time,
	// 2 * x the second time, etc...
	PolarityRephaseIncrement *int32 `protobuf:"varint,168,opt,name=polarity_rephase_increment,json=polarityRephaseIncrement,def=1000" json:"polarity_rephase_increment,omitempty"`
	// The proportion of polarity chosen at random. Note that this take
	// precedence over the phase saving heuristic. This is different from
	// initial_polarity:POLARITY_RANDOM because it will select a new random
	// polarity each time the variable is branched upon instead of selecting one
	// initially and then always taking this choice.
	RandomPolarityRatio *float64 `protobuf:"fixed64,45,opt,name=random_polarity_ratio,json=randomPolarityRatio,def=0" json:"random_polarity_ratio,omitempty"`
	// A number between 0 and 1 that indicates the proportion of branching
	// variables that are selected randomly instead of choosing the first variable
	// from the given variable_ordering strategy.
	RandomBranchesRatio *float64 `protobuf:"fixed64,32,opt,name=random_branches_ratio,json=randomBranchesRatio,def=0" json:"random_branches_ratio,omitempty"`
	// Whether we use the ERWA (Exponential Recency Weighted Average) heuristic as
	// described in "Learning Rate Based Branching Heuristic for SAT solvers",
	// J.H.Liang, V. Ganesh, P. Poupart, K.Czarnecki, SAT 2016.
	UseErwaHeuristic *bool `protobuf:"varint,75,opt,name=use_erwa_heuristic,json=useErwaHeuristic,def=0" json:"use_erwa_heuristic,omitempty"`
	// The initial value of the variables activity. A non-zero value only make
	// sense when use_erwa_heuristic is true. Experiments with a value of 1e-2
	// together with the ERWA heuristic showed slighthly better result than simply
	// using zero. The idea is that when the "learning rate" of a variable becomes
	// lower than this value, then we prefer to branch on never explored before
	// variables. This is not in the ERWA paper.
	InitialVariablesActivity *float64 `protobuf:"fixed64,76,opt,name=initial_variables_activity,json=initialVariablesActivity,def=0" json:"initial_variables_activity,omitempty"`
	// When this is true, then the variables that appear in any of the reason of
	// the variables in a conflict have their activity bumped. This is addition to
	// the variables in the conflict, and the one that were used during conflict
	// resolution.
	AlsoBumpVariablesInConflictReasons *bool                                        `protobuf:"varint,77,opt,name=also_bump_variables_in_conflict_reasons,json=alsoBumpVariablesInConflictReasons,def=0" json:"also_bump_variables_in_conflict_reasons,omitempty"`
	MinimizationAlgorithm              *SatParameters_ConflictMinimizationAlgorithm `protobuf:"varint,4,opt,name=minimization_algorithm,json=minimizationAlgorithm,enum=operations_research.sat.SatParameters_ConflictMinimizationAlgorithm,def=2" json:"minimization_algorithm,omitempty"`
	BinaryMinimizationAlgorithm        *SatParameters_BinaryMinizationAlgorithm     `protobuf:"varint,34,opt,name=binary_minimization_algorithm,json=binaryMinimizationAlgorithm,enum=operations_research.sat.SatParameters_BinaryMinizationAlgorithm,def=1" json:"binary_minimization_algorithm,omitempty"`
	// At a really low cost, during the 1-UIP conflict computation, it is easy to
	// detect if some of the involved reasons are subsumed by the current
	// conflict. When this is true, such clauses are detached and later removed
	// from the problem.
	SubsumptionDuringConflictAnalysis *bool `protobuf:"varint,56,opt,name=subsumption_during_conflict_analysis,json=subsumptionDuringConflictAnalysis,def=1" json:"subsumption_during_conflict_analysis,omitempty"`
	// Trigger a cleanup when this number of "deletable" clauses is learned.
	ClauseCleanupPeriod *int32 `protobuf:"varint,11,opt,name=clause_cleanup_period,json=clauseCleanupPeriod,def=10000" json:"clause_cleanup_period,omitempty"`
	// During a cleanup, we will always keep that number of "deletable" clauses.
	// Note that this doesn't include the "protected" clauses.
	ClauseCleanupTarget     *int32                          `protobuf:"varint,13,opt,name=clause_cleanup_target,json=clauseCleanupTarget,def=10000" json:"clause_cleanup_target,omitempty"`
	ClauseCleanupProtection *SatParameters_ClauseProtection `protobuf:"varint,58,opt,name=clause_cleanup_protection,json=clauseCleanupProtection,enum=operations_research.sat.SatParameters_ClauseProtection,def=0" json:"clause_cleanup_protection,omitempty"`
	// All the clauses with a LBD (literal blocks distance) lower or equal to this
	// parameters will always be kept.
	ClauseCleanupLbdBound *int32                        `protobuf:"varint,59,opt,name=clause_cleanup_lbd_bound,json=clauseCleanupLbdBound,def=5" json:"clause_cleanup_lbd_bound,omitempty"`
	ClauseCleanupOrdering *SatParameters_ClauseOrdering `protobuf:"varint,60,opt,name=clause_cleanup_ordering,json=clauseCleanupOrdering,enum=operations_research.sat.SatParameters_ClauseOrdering,def=0" json:"clause_cleanup_ordering,omitempty"`
	// Same as for the clauses, but for the learned pseudo-Boolean constraints.
	PbCleanupIncrement *int32   `protobuf:"varint,46,opt,name=pb_cleanup_increment,json=pbCleanupIncrement,def=200" json:"pb_cleanup_increment,omitempty"`
	PbCleanupRatio     *float64 `protobuf:"fixed64,47,opt,name=pb_cleanup_ratio,json=pbCleanupRatio,def=0.5" json:"pb_cleanup_ratio,omitempty"`
	// Parameters for an heuristic similar to the one descibed in "An effective
	// learnt clause minimization approach for CDCL Sat Solvers",
	// https://www.ijcai.org/proceedings/2017/0098.pdf
	//
	// For now, we have a somewhat simpler implementation where every x restart we
	// spend y decisions on clause minimization. The minimization technique is the
	// same as the one used to minimize core in max-sat. We also minimize problem
	// clauses and not just the learned clause that we keep forever like in the
	// paper.
	//
	// Changing these parameters or the kind of clause we minimize seems to have
	// a big impact on the overall perf on our benchmarks. So this technique seems
	// definitely useful, but it is hard to tune properly.
	MinimizeWithPropagationRestartPeriod *int32 `protobuf:"varint,96,opt,name=minimize_with_propagation_restart_period,json=minimizeWithPropagationRestartPeriod,def=10" json:"minimize_with_propagation_restart_period,omitempty"`
	MinimizeWithPropagationNumDecisions  *int32 `protobuf:"varint,97,opt,name=minimize_with_propagation_num_decisions,json=minimizeWithPropagationNumDecisions,def=1000" json:"minimize_with_propagation_num_decisions,omitempty"`
	// Each time a conflict is found, the activities of some variables are
	// increased by one. Then, the activity of all variables are multiplied by
	// variable_activity_decay.
	//
	// To implement this efficiently, the activity of all the variables is not
	// decayed at each conflict. Instead, the activity increment is multiplied by
	// 1 / decay. When an activity reach max_variable_activity_value, all the
	// activity are multiplied by 1 / max_variable_activity_value.
	VariableActivityDecay    *float64 `protobuf:"fixed64,15,opt,name=variable_activity_decay,json=variableActivityDecay,def=0.8" json:"variable_activity_decay,omitempty"`
	MaxVariableActivityValue *float64 `protobuf:"fixed64,16,opt,name=max_variable_activity_value,json=maxVariableActivityValue,def=1e+100" json:"max_variable_activity_value,omitempty"`
	// The activity starts at 0.8 and increment by 0.01 every 5000 conflicts until
	// 0.95. This "hack" seems to work well and comes from:
	//
	// Glucose 2.3 in the SAT 2013 Competition - SAT Competition 2013
	// http://edacc4.informatik.uni-ulm.de/SC13/solver-description-download/136
	GlucoseMaxDecay             *float64 `protobuf:"fixed64,22,opt,name=glucose_max_decay,json=glucoseMaxDecay,def=0.95" json:"glucose_max_decay,omitempty"`
	GlucoseDecayIncrement       *float64 `protobuf:"fixed64,23,opt,name=glucose_decay_increment,json=glucoseDecayIncrement,def=0.01" json:"glucose_decay_increment,omitempty"`
	GlucoseDecayIncrementPeriod *int32   `protobuf:"varint,24,opt,name=glucose_decay_increment_period,json=glucoseDecayIncrementPeriod,def=5000" json:"glucose_decay_increment_period,omitempty"`
	// Clause activity parameters (same effect as the one on the variables).
	ClauseActivityDecay    *float64 `protobuf:"fixed64,17,opt,name=clause_activity_decay,json=clauseActivityDecay,def=0.999" json:"clause_activity_decay,omitempty"`
	MaxClauseActivityValue *float64 `protobuf:"fixed64,18,opt,name=max_clause_activity_value,json=maxClauseActivityValue,def=1e+20" json:"max_clause_activity_value,omitempty"`
	// The restart strategies will change each time the strategy_counter is
	// increased. The current strategy will simply be the one at index
	// strategy_counter modulo the number of strategy. Note that if this list
	// includes a NO_RESTART, nothing will change when it is reached because the
	// strategy_counter will only increment after a restart.
	//
	// The idea of switching of search strategy tailored for SAT/UNSAT comes from
	// Chanseok Oh with his COMiniSatPS solver, see http://cs.nyu.edu/~chanseok/.
	// But more generally, it seems REALLY beneficial to try different strategy.
	RestartAlgorithms        []SatParameters_RestartAlgorithm `protobuf:"varint,61,rep,name=restart_algorithms,json=restartAlgorithms,enum=operations_research.sat.SatParameters_RestartAlgorithm" json:"restart_algorithms,omitempty"`
	DefaultRestartAlgorithms *string                          `protobuf:"bytes,70,opt,name=default_restart_algorithms,json=defaultRestartAlgorithms,def=LUBY_RESTART,LBD_MOVING_AVERAGE_RESTART,DL_MOVING_AVERAGE_RESTART" json:"default_restart_algorithms,omitempty"`
	// Restart period for the FIXED_RESTART strategy. This is also the multiplier
	// used by the LUBY_RESTART strategy.
	RestartPeriod *int32 `protobuf:"varint,30,opt,name=restart_period,json=restartPeriod,def=50" json:"restart_period,omitempty"`
	// Size of the window for the moving average restarts.
	RestartRunningWindowSize *int32 `protobuf:"varint,62,opt,name=restart_running_window_size,json=restartRunningWindowSize,def=50" json:"restart_running_window_size,omitempty"`
	// In the moving average restart algorithms, a restart is triggered if the
	// window average times this ratio is greater that the global average.
	RestartDlAverageRatio  *float64 `protobuf:"fixed64,63,opt,name=restart_dl_average_ratio,json=restartDlAverageRatio,def=1" json:"restart_dl_average_ratio,omitempty"`
	RestartLbdAverageRatio *float64 `protobuf:"fixed64,71,opt,name=restart_lbd_average_ratio,json=restartLbdAverageRatio,def=1" json:"restart_lbd_average_ratio,omitempty"`
	// Block a moving restart algorithm if the trail size of the current conflict
	// is greater than the multiplier times the moving average of the trail size
	// at the previous conflicts.
	UseBlockingRestart        *bool    `protobuf:"varint,64,opt,name=use_blocking_restart,json=useBlockingRestart,def=0" json:"use_blocking_restart,omitempty"`
	BlockingRestartWindowSize *int32   `protobuf:"varint,65,opt,name=blocking_restart_window_size,json=blockingRestartWindowSize,def=5000" json:"blocking_restart_window_size,omitempty"`
	BlockingRestartMultiplier *float64 `protobuf:"fixed64,66,opt,name=blocking_restart_multiplier,json=blockingRestartMultiplier,def=1.4" json:"blocking_restart_multiplier,omitempty"`
	// After each restart, if the number of conflict since the last strategy
	// change is greater that this, then we increment a "strategy_counter" that
	// can be use to change the search strategy used by the following restarts.
	NumConflictsBeforeStrategyChanges *int32 `protobuf:"varint,68,opt,name=num_conflicts_before_strategy_changes,json=numConflictsBeforeStrategyChanges,def=0" json:"num_conflicts_before_strategy_changes,omitempty"`
	// The parameter num_conflicts_before_strategy_changes is increased by that
	// much after each strategy change.
	StrategyChangeIncreaseRatio *float64 `protobuf:"fixed64,69,opt,name=strategy_change_increase_ratio,json=strategyChangeIncreaseRatio,def=0" json:"strategy_change_increase_ratio,omitempty"`
	// Maximum time allowed in seconds to solve a problem.
	// The counter will starts at the beginning of the Solve() call.
	MaxTimeInSeconds *float64 `protobuf:"fixed64,36,opt,name=max_time_in_seconds,json=maxTimeInSeconds,def=inf" json:"max_time_in_seconds,omitempty"`
	// Maximum time allowed in deterministic time to solve a problem.
	// The deterministic time should be correlated with the real time used by the
	// solver, the time unit being as close as possible to a second.
	MaxDeterministicTime *float64 `protobuf:"fixed64,67,opt,name=max_deterministic_time,json=maxDeterministicTime,def=inf" json:"max_deterministic_time,omitempty"`
	// Maximum number of conflicts allowed to solve a problem.
	//
	// TODO(user,user): Maybe change the way the conflict limit is enforced?
	// currently it is enforced on each independent internal SAT solve, rather
	// than on the overall number of conflicts across all solves. So in the
	// context of an optimization problem, this is not really usable directly by a
	// client.
	MaxNumberOfConflicts *int64 `protobuf:"varint,37,opt,name=max_number_of_conflicts,json=maxNumberOfConflicts,def=9223372036854775807" json:"max_number_of_conflicts,omitempty"` // kint64max
	// Maximum memory allowed for the whole thread containing the solver. The
	// solver will abort as soon as it detects that this limit is crossed. As a
	// result, this limit is approximative, but usually the solver will not go too
	// much over.
	MaxMemoryInMb *int64 `protobuf:"varint,40,opt,name=max_memory_in_mb,json=maxMemoryInMb,def=10000" json:"max_memory_in_mb,omitempty"`
	// Stop the search when the gap between the best feasible objective (O) and
	// our best objective bound (B) is smaller than a limit.
	// The exact definition is:
	// - Absolute: abs(O - B)
	// - Relative: abs(O - B) / max(1, abs(O)).
	//
	// Important: The relative gap depends on the objective offset! If you
	// artificially shift the objective, you will get widely different value of
	// the relative gap.
	//
	// Note that if the gap is reached, the search status will be OPTIMAL. But
	// one can check the best objective bound to see the actual gap.
	AbsoluteGapLimit *float64 `protobuf:"fixed64,159,opt,name=absolute_gap_limit,json=absoluteGapLimit,def=0" json:"absolute_gap_limit,omitempty"`
	RelativeGapLimit *float64 `protobuf:"fixed64,160,opt,name=relative_gap_limit,json=relativeGapLimit,def=0" json:"relative_gap_limit,omitempty"`
	// If true, the binary clauses are treated separately from the others. This
	// should be faster and uses less memory. However it changes the propagation
	// order.
	TreatBinaryClausesSeparately *bool `protobuf:"varint,33,opt,name=treat_binary_clauses_separately,json=treatBinaryClausesSeparately,def=1" json:"treat_binary_clauses_separately,omitempty"`
	// At the beginning of each solve, the random number generator used in some
	// part of the solver is reinitialized to this seed. If you change the random
	// seed, the solver may make different choices during the solving process.
	//
	// For some problems, the running time may vary a lot depending on small
	// change in the solving algorithm. Running the solver with different seeds
	// enables to have more robust benchmarks when evaluating new features.
	RandomSeed *int32 `protobuf:"varint,31,opt,name=random_seed,json=randomSeed,def=1" json:"random_seed,omitempty"`
	// This is mainly here to test the solver variability. Note that in tests, if
	// not explicitly set to false, all 3 options will be set to true so that
	// clients do not rely on the solver returning a specific solution if they are
	// many equivalent optimal solutions.
	PermuteVariableRandomly        *bool `protobuf:"varint,178,opt,name=permute_variable_randomly,json=permuteVariableRandomly,def=0" json:"permute_variable_randomly,omitempty"`
	PermutePresolveConstraintOrder *bool `protobuf:"varint,179,opt,name=permute_presolve_constraint_order,json=permutePresolveConstraintOrder,def=0" json:"permute_presolve_constraint_order,omitempty"`
	UseAbslRandom                  *bool `protobuf:"varint,180,opt,name=use_absl_random,json=useAbslRandom,def=0" json:"use_absl_random,omitempty"`
	// Whether the solver should log the search progress. By default, it logs to
	// LOG(INFO). This can be overwritten by the log_destination parameter.
	LogSearchProgress *bool `protobuf:"varint,41,opt,name=log_search_progress,json=logSearchProgress,def=0" json:"log_search_progress,omitempty"`
	// Add a prefix to all logs.
	LogPrefix *string `protobuf:"bytes,185,opt,name=log_prefix,json=logPrefix,def=" json:"log_prefix,omitempty"`
	// Log to stdout.
	LogToStdout *bool `protobuf:"varint,186,opt,name=log_to_stdout,json=logToStdout,def=1" json:"log_to_stdout,omitempty"`
	// Log to response proto.
	LogToResponse *bool `protobuf:"varint,187,opt,name=log_to_response,json=logToResponse,def=0" json:"log_to_response,omitempty"`
	// Whether to use pseudo-Boolean resolution to analyze a conflict. Note that
	// this option only make sense if your problem is modelized using
	// pseudo-Boolean constraints. If you only have clauses, this shouldn't change
	// anything (except slow the solver down).
	UsePbResolution *bool `protobuf:"varint,43,opt,name=use_pb_resolution,json=usePbResolution,def=0" json:"use_pb_resolution,omitempty"`
	// A different algorithm during PB resolution. It minimizes the number of
	// calls to ReduceCoefficients() which can be time consuming. However, the
	// search space will be different and if the coefficients are large, this may
	// lead to integer overflows that could otherwise be prevented.
	MinimizeReductionDuringPbResolution *bool `protobuf:"varint,48,opt,name=minimize_reduction_during_pb_resolution,json=minimizeReductionDuringPbResolution,def=0" json:"minimize_reduction_during_pb_resolution,omitempty"`
	// Whether or not the assumption levels are taken into account during the LBD
	// computation. According to the reference below, not counting them improves
	// the solver in some situation. Note that this only impact solves under
	// assumptions.
	//
	// Gilles Audemard, Jean-Marie Lagniez, Laurent Simon, "Improving Glucose for
	// Incremental SAT Solving with Assumptions: Application to MUS Extraction"
	// Theory and Applications of Satisfiability Testing - SAT 2013, Lecture Notes
	// in Computer Science Volume 7962, 2013, pp 309-317.
	CountAssumptionLevelsInLbd *bool `protobuf:"varint,49,opt,name=count_assumption_levels_in_lbd,json=countAssumptionLevelsInLbd,def=1" json:"count_assumption_levels_in_lbd,omitempty"`
	// During presolve, only try to perform the bounded variable elimination (BVE)
	// of a variable x if the number of occurrences of x times the number of
	// occurrences of not(x) is not greater than this parameter.
	PresolveBveThreshold *int32 `protobuf:"varint,54,opt,name=presolve_bve_threshold,json=presolveBveThreshold,def=500" json:"presolve_bve_threshold,omitempty"`
	// During presolve, we apply BVE only if this weight times the number of
	// clauses plus the number of clause literals is not increased.
	PresolveBveClauseWeight *int32 `protobuf:"varint,55,opt,name=presolve_bve_clause_weight,json=presolveBveClauseWeight,def=3" json:"presolve_bve_clause_weight,omitempty"`
	// The maximum "deterministic" time limit to spend in probing. A value of
	// zero will disable the probing.
	PresolveProbingDeterministicTimeLimit *float64 `protobuf:"fixed64,57,opt,name=presolve_probing_deterministic_time_limit,json=presolveProbingDeterministicTimeLimit,def=30" json:"presolve_probing_deterministic_time_limit,omitempty"`
	// Whether we use an heuristic to detect some basic case of blocked clause
	// in the SAT presolve.
	PresolveBlockedClause *bool `protobuf:"varint,88,opt,name=presolve_blocked_clause,json=presolveBlockedClause,def=1" json:"presolve_blocked_clause,omitempty"`
	// Whether or not we use Bounded Variable Addition (BVA) in the presolve.
	PresolveUseBva *bool `protobuf:"varint,72,opt,name=presolve_use_bva,json=presolveUseBva,def=1" json:"presolve_use_bva,omitempty"`
	// Apply Bounded Variable Addition (BVA) if the number of clauses is reduced
	// by stricly more than this threshold. The algorithm described in the paper
	// uses 0, but quick experiments showed that 1 is a good value. It may not be
	// worth it to add a new variable just to remove one clause.
	PresolveBvaThreshold *int32 `protobuf:"varint,73,opt,name=presolve_bva_threshold,json=presolveBvaThreshold,def=1" json:"presolve_bva_threshold,omitempty"`
	// In case of large reduction in a presolve iteration, we perform multiple
	// presolve iterations. This parameter controls the maximum number of such
	// presolve iterations.
	MaxPresolveIterations *int32 `protobuf:"varint,138,opt,name=max_presolve_iterations,json=maxPresolveIterations,def=3" json:"max_presolve_iterations,omitempty"`
	// Whether we presolve the cp_model before solving it.
	CpModelPresolve *bool `protobuf:"varint,86,opt,name=cp_model_presolve,json=cpModelPresolve,def=1" json:"cp_model_presolve,omitempty"`
	// Advanced usage. We have two different postsolve code. The default one
	// should be better and it allows for a more powerful presolve, but some
	// rarely used features like not fully assigning all variables require the
	// other one.
	CpModelPostsolveWithFullSolver *bool `protobuf:"varint,162,opt,name=cp_model_postsolve_with_full_solver,json=cpModelPostsolveWithFullSolver,def=0" json:"cp_model_postsolve_with_full_solver,omitempty"`
	// If positive, try to stop just after that many presolve rules have been
	// applied. This is mainly useful for debugging presolve.
	CpModelMaxNumPresolveOperations *int32 `protobuf:"varint,151,opt,name=cp_model_max_num_presolve_operations,json=cpModelMaxNumPresolveOperations,def=0" json:"cp_model_max_num_presolve_operations,omitempty"`
	// How much effort do we spend on probing. 0 disables it completely.
	CpModelProbingLevel *int32 `protobuf:"varint,110,opt,name=cp_model_probing_level,json=cpModelProbingLevel,def=2" json:"cp_model_probing_level,omitempty"`
	// Whether we also use the sat presolve when cp_model_presolve is true.
	CpModelUseSatPresolve *bool `protobuf:"varint,93,opt,name=cp_model_use_sat_presolve,json=cpModelUseSatPresolve,def=1" json:"cp_model_use_sat_presolve,omitempty"`
	UseSatInprocessing    *bool `protobuf:"varint,163,opt,name=use_sat_inprocessing,json=useSatInprocessing,def=0" json:"use_sat_inprocessing,omitempty"`
	// If true, the element constraints are expanded into many
	// linear constraints of the form (index == i) => (element[i] == target).
	ExpandElementConstraints *bool `protobuf:"varint,140,opt,name=expand_element_constraints,json=expandElementConstraints,def=1" json:"expand_element_constraints,omitempty"`
	// If true, the automaton constraints are expanded.
	ExpandAutomatonConstraints *bool `protobuf:"varint,143,opt,name=expand_automaton_constraints,json=expandAutomatonConstraints,def=1" json:"expand_automaton_constraints,omitempty"`
	// If true, the positive table constraints are expanded.
	// Note that currently, negative table constraints are always expanded.
	ExpandTableConstraints *bool `protobuf:"varint,158,opt,name=expand_table_constraints,json=expandTableConstraints,def=1" json:"expand_table_constraints,omitempty"`
	// If true, expand all_different constraints that are not permutations.
	// Permutations (#Variables = #Values) are always expanded.
	ExpandAlldiffConstraints *bool `protobuf:"varint,170,opt,name=expand_alldiff_constraints,json=expandAlldiffConstraints,def=0" json:"expand_alldiff_constraints,omitempty"`
	// If true, expand the reservoir constraints by creating booleans for all
	// possible precedences between event and encoding the constraint.
	ExpandReservoirConstraints *bool `protobuf:"varint,182,opt,name=expand_reservoir_constraints,json=expandReservoirConstraints,def=1" json:"expand_reservoir_constraints,omitempty"`
	// If true, it disable all constraint expansion.
	// This should only be used to test the presolve of expanded constraints.
	DisableConstraintExpansion *bool `protobuf:"varint,181,opt,name=disable_constraint_expansion,json=disableConstraintExpansion,def=0" json:"disable_constraint_expansion,omitempty"`
	// During presolve, we use a maximum clique heuristic to merge together
	// no-overlap constraints or at most one constraints. This code can be slow,
	// so we have a limit in place on the number of explored nodes in the
	// underlying graph. The internal limit is an int64, but we use double here to
	// simplify manual input.
	MergeNoOverlapWorkLimit *float64 `protobuf:"fixed64,145,opt,name=merge_no_overlap_work_limit,json=mergeNoOverlapWorkLimit,def=1e+12" json:"merge_no_overlap_work_limit,omitempty"`
	MergeAtMostOneWorkLimit *float64 `protobuf:"fixed64,146,opt,name=merge_at_most_one_work_limit,json=mergeAtMostOneWorkLimit,def=1e+08" json:"merge_at_most_one_work_limit,omitempty"`
	// How much substitution (also called free variable aggregation in MIP
	// litterature) should we perform at presolve. This currently only concerns
	// variable appearing only in linear constraints. For now the value 0 turns it
	// off and any positive value performs substitution.
	PresolveSubstitutionLevel *int32 `protobuf:"varint,147,opt,name=presolve_substitution_level,json=presolveSubstitutionLevel,def=1" json:"presolve_substitution_level,omitempty"`
	// If true, we will extract from linear constraints, enforcement literals of
	// the form "integer variable at bound => simplified constraint". This should
	// always be beneficial except that we don't always handle them as efficiently
	// as we could for now. This causes problem on manna81.mps (LP relaxation not
	// as tight it seems) and on neos-3354841-apure.mps.gz (too many literals
	// created this way).
	PresolveExtractIntegerEnforcement *bool `protobuf:"varint,174,opt,name=presolve_extract_integer_enforcement,json=presolveExtractIntegerEnforcement,def=0" json:"presolve_extract_integer_enforcement,omitempty"`
	// For an optimization problem, whether we follow some hints in order to find
	// a better first solution. For a variable with hint, the solver will always
	// try to follow the hint. It will revert to the variable_branching default
	// otherwise.
	UseOptimizationHints *bool `protobuf:"varint,35,opt,name=use_optimization_hints,json=useOptimizationHints,def=1" json:"use_optimization_hints,omitempty"`
	// Whether we use a simple heuristic to try to minimize an UNSAT core.
	MinimizeCore *bool `protobuf:"varint,50,opt,name=minimize_core,json=minimizeCore,def=1" json:"minimize_core,omitempty"`
	// Whether we try to find more independent cores for a given set of
	// assumptions in the core based max-SAT algorithms.
	FindMultipleCores *bool `protobuf:"varint,84,opt,name=find_multiple_cores,json=findMultipleCores,def=1" json:"find_multiple_cores,omitempty"`
	// If true, when the max-sat algo find a core, we compute the minimal number
	// of literals in the core that needs to be true to have a feasible solution.
	CoverOptimization     *bool                                `protobuf:"varint,89,opt,name=cover_optimization,json=coverOptimization,def=1" json:"cover_optimization,omitempty"`
	MaxSatAssumptionOrder *SatParameters_MaxSatAssumptionOrder `protobuf:"varint,51,opt,name=max_sat_assumption_order,json=maxSatAssumptionOrder,enum=operations_research.sat.SatParameters_MaxSatAssumptionOrder,def=0" json:"max_sat_assumption_order,omitempty"`
	// If true, adds the assumption in the reverse order of the one defined by
	// max_sat_assumption_order.
	MaxSatReverseAssumptionOrder *bool                                        `protobuf:"varint,52,opt,name=max_sat_reverse_assumption_order,json=maxSatReverseAssumptionOrder,def=0" json:"max_sat_reverse_assumption_order,omitempty"`
	MaxSatStratification         *SatParameters_MaxSatStratificationAlgorithm `protobuf:"varint,53,opt,name=max_sat_stratification,json=maxSatStratification,enum=operations_research.sat.SatParameters_MaxSatStratificationAlgorithm,def=1" json:"max_sat_stratification,omitempty"`
	// When this is true, then a disjunctive constraint will try to use the
	// precedence relations between time intervals to propagate their bounds
	// further. For instance if task A and B are both before C and task A and B
	// are in disjunction, then we can deduce that task C must start after
	// duration(A) + duration(B) instead of simply max(duration(A), duration(B)),
	// provided that the start time for all task was currently zero.
	//
	// This always result in better propagation, but it is usually slow, so
	// depending on the problem, turning this off may lead to a faster solution.
	UsePrecedencesInDisjunctiveConstraint *bool `protobuf:"varint,74,opt,name=use_precedences_in_disjunctive_constraint,json=usePrecedencesInDisjunctiveConstraint,def=1" json:"use_precedences_in_disjunctive_constraint,omitempty"`
	// When this is true, the cumulative constraint is reinforced with overload
	// checking, i.e., an additional level of reasoning based on energy. This
	// additional level supplements the default level of reasoning as well as
	// timetable edge finding.
	//
	// This always result in better propagation, but it is usually slow, so
	// depending on the problem, turning this off may lead to a faster solution.
	UseOverloadCheckerInCumulativeConstraint *bool `protobuf:"varint,78,opt,name=use_overload_checker_in_cumulative_constraint,json=useOverloadCheckerInCumulativeConstraint,def=0" json:"use_overload_checker_in_cumulative_constraint,omitempty"`
	// When this is true, the cumulative constraint is reinforced with timetable
	// edge finding, i.e., an additional level of reasoning based on the
	// conjunction of energy and mandatory parts. This additional level
	// supplements the default level of reasoning as well as overload_checker.
	//
	// This always result in better propagation, but it is usually slow, so
	// depending on the problem, turning this off may lead to a faster solution.
	UseTimetableEdgeFindingInCumulativeConstraint *bool `protobuf:"varint,79,opt,name=use_timetable_edge_finding_in_cumulative_constraint,json=useTimetableEdgeFindingInCumulativeConstraint,def=0" json:"use_timetable_edge_finding_in_cumulative_constraint,omitempty"`
	// When this is true, the cumulative constraint is reinforced with propagators
	// from the disjunctive constraint to improve the inference on a set of tasks
	// that are disjunctive at the root of the problem. This additional level
	// supplements the default level of reasoning.
	//
	// Propagators of the cumulative constraint will not be used at all if all the
	// tasks are disjunctive at root node.
	//
	// This always result in better propagation, but it is usually slow, so
	// depending on the problem, turning this off may lead to a faster solution.
	UseDisjunctiveConstraintInCumulativeConstraint *bool `protobuf:"varint,80,opt,name=use_disjunctive_constraint_in_cumulative_constraint,json=useDisjunctiveConstraintInCumulativeConstraint,def=1" json:"use_disjunctive_constraint_in_cumulative_constraint,omitempty"`
	// A non-negative level indicating the type of constraints we consider in the
	// LP relaxation. At level zero, no LP relaxation is used. At level 1, only
	// the linear constraint and full encoding are added. At level 2, we also add
	// all the Boolean constraints.
	LinearizationLevel *int32 `protobuf:"varint,90,opt,name=linearization_level,json=linearizationLevel,def=1" json:"linearization_level,omitempty"`
	// A non-negative level indicating how much we should try to fully encode
	// Integer variables as Boolean.
	BooleanEncodingLevel *int32 `protobuf:"varint,107,opt,name=boolean_encoding_level,json=booleanEncodingLevel,def=1" json:"boolean_encoding_level,omitempty"`
	// The limit on the number of cuts in our cut pool. When this is reached we do
	// not generate cuts anymore.
	//
	// TODO(user): We should probably remove this parameters, and just always
	// generate cuts but only keep the best n or something.
	MaxNumCuts *int32 `protobuf:"varint,91,opt,name=max_num_cuts,json=maxNumCuts,def=10000" json:"max_num_cuts,omitempty"`
	// For the cut that can be generated at any level, this control if we only
	// try to generate them at the root node.
	OnlyAddCutsAtLevelZero *bool `protobuf:"varint,92,opt,name=only_add_cuts_at_level_zero,json=onlyAddCutsAtLevelZero,def=0" json:"only_add_cuts_at_level_zero,omitempty"`
	// Whether we generate knapsack cuts. Note that in our setting where all
	// variables are integer and bounded on both side, such a cut could be applied
	// to any constraint.
	AddKnapsackCuts *bool `protobuf:"varint,111,opt,name=add_knapsack_cuts,json=addKnapsackCuts,def=0" json:"add_knapsack_cuts,omitempty"`
	// Whether we generate and add Chvatal-Gomory cuts to the LP at root node.
	// Note that for now, this is not heavily tuned.
	AddCgCuts *bool `protobuf:"varint,117,opt,name=add_cg_cuts,json=addCgCuts,def=1" json:"add_cg_cuts,omitempty"`
	// Whether we generate MIR cuts at root node.
	// Note that for now, this is not heavily tuned.
	AddMirCuts *bool `protobuf:"varint,120,opt,name=add_mir_cuts,json=addMirCuts,def=1" json:"add_mir_cuts,omitempty"`
	// Whether we generate Zero-Half cuts at root node.
	// Note that for now, this is not heavily tuned.
	AddZeroHalfCuts *bool `protobuf:"varint,169,opt,name=add_zero_half_cuts,json=addZeroHalfCuts,def=1" json:"add_zero_half_cuts,omitempty"`
	// Whether we generate clique cuts from the binary implication graph. Note
	// that as the search goes on, this graph will contains new binary clauses
	// learned by the SAT engine.
	AddCliqueCuts *bool `protobuf:"varint,172,opt,name=add_clique_cuts,json=addCliqueCuts,def=1" json:"add_clique_cuts,omitempty"`
	// Cut generator for all diffs can add too many cuts for large all_diff
	// constraints. This parameter restricts the large all_diff constraints to
	// have a cut generator.
	MaxAllDiffCutSize *int32 `protobuf:"varint,148,opt,name=max_all_diff_cut_size,json=maxAllDiffCutSize,def=7" json:"max_all_diff_cut_size,omitempty"`
	// For the lin max constraints, generates the cuts described in "Strong
	// mixed-integer programming formulations for trained neural networks" by Ross
	// Anderson et. (https://arxiv.org/pdf/1811.01988.pdf)
	AddLinMaxCuts *bool `protobuf:"varint,152,opt,name=add_lin_max_cuts,json=addLinMaxCuts,def=1" json:"add_lin_max_cuts,omitempty"`
	// In the integer rounding procedure used for MIR and Gomory cut, the maximum
	// "scaling" we use (must be positive). The lower this is, the lower the
	// integer coefficients of the cut will be. Note that cut generated by lower
	// values are not necessarily worse than cut generated by larger value. There
	// is no strict dominance relationship.
	//
	// Setting this to 2 result in the "strong fractional rouding" of Letchford
	// and Lodi.
	MaxIntegerRoundingScaling *int32 `protobuf:"varint,119,opt,name=max_integer_rounding_scaling,json=maxIntegerRoundingScaling,def=600" json:"max_integer_rounding_scaling,omitempty"`
	// If true, we start by an empty LP, and only add constraints not satisfied
	// by the current LP solution batch by batch. A constraint that is only added
	// like this is known as a "lazy" constraint in the literature, except that we
	// currently consider all constraints as lazy here.
	AddLpConstraintsLazily *bool `protobuf:"varint,112,opt,name=add_lp_constraints_lazily,json=addLpConstraintsLazily,def=1" json:"add_lp_constraints_lazily,omitempty"`
	// While adding constraints, skip the constraints which have orthogonality
	// less than 'min_orthogonality_for_lp_constraints' with already added
	// constraints during current call. Orthogonality is defined as 1 -
	// cosine(vector angle between constraints). A value of zero disable this
	// feature.
	MinOrthogonalityForLpConstraints *float64 `protobuf:"fixed64,115,opt,name=min_orthogonality_for_lp_constraints,json=minOrthogonalityForLpConstraints,def=0.05" json:"min_orthogonality_for_lp_constraints,omitempty"`
	// Max number of time we perform cut generation and resolve the LP at level 0.
	MaxCutRoundsAtLevelZero *int32 `protobuf:"varint,154,opt,name=max_cut_rounds_at_level_zero,json=maxCutRoundsAtLevelZero,def=1" json:"max_cut_rounds_at_level_zero,omitempty"`
	// If a constraint/cut in LP is not active for that many consecutive OPTIMAL
	// solves, remove it from the LP. Note that it might be added again later if
	// it become violated by the current LP solution.
	MaxConsecutiveInactiveCount *int32 `protobuf:"varint,121,opt,name=max_consecutive_inactive_count,json=maxConsecutiveInactiveCount,def=100" json:"max_consecutive_inactive_count,omitempty"`
	// These parameters are similar to sat clause management activity parameters.
	// They are effective only if the number of generated cuts exceed the storage
	// limit. Default values are based on a few experiments on miplib instances.
	CutMaxActiveCountValue *float64 `protobuf:"fixed64,155,opt,name=cut_max_active_count_value,json=cutMaxActiveCountValue,def=1e+10" json:"cut_max_active_count_value,omitempty"`
	CutActiveCountDecay    *float64 `protobuf:"fixed64,156,opt,name=cut_active_count_decay,json=cutActiveCountDecay,def=0.8" json:"cut_active_count_decay,omitempty"`
	// Target number of constraints to remove during cleanup.
	CutCleanupTarget *int32 `protobuf:"varint,157,opt,name=cut_cleanup_target,json=cutCleanupTarget,def=1000" json:"cut_cleanup_target,omitempty"`
	// Add that many lazy constraints (or cuts) at once in the LP. Note that at
	// the beginning of the solve, we do add more than this.
	NewConstraintsBatchSize *int32                         `protobuf:"varint,122,opt,name=new_constraints_batch_size,json=newConstraintsBatchSize,def=50" json:"new_constraints_batch_size,omitempty"`
	SearchBranching         *SatParameters_SearchBranching `protobuf:"varint,82,opt,name=search_branching,json=searchBranching,enum=operations_research.sat.SatParameters_SearchBranching,def=0" json:"search_branching,omitempty"`
	// Conflict limit used in the phase that exploit the solution hint.
	HintConflictLimit *int32 `protobuf:"varint,153,opt,name=hint_conflict_limit,json=hintConflictLimit,def=10" json:"hint_conflict_limit,omitempty"`
	// If true, the solver tries to repair the solution given in the hint. This
	// search terminates after the 'hint_conflict_limit' is reached and the solver
	// switches to regular search. If false, then  we do a FIXED_SEARCH using the
	// hint until the hint_conflict_limit is reached.
	RepairHint *bool `protobuf:"varint,167,opt,name=repair_hint,json=repairHint,def=0" json:"repair_hint,omitempty"`
	// If true and the Lp relaxation of the problem has an integer optimal
	// solution, try to exploit it. Note that since the LP relaxation may not
	// contain all the constraints, such a solution is not necessarily a solution
	// of the full problem.
	ExploitIntegerLpSolution *bool `protobuf:"varint,94,opt,name=exploit_integer_lp_solution,json=exploitIntegerLpSolution,def=1" json:"exploit_integer_lp_solution,omitempty"`
	// If true and the Lp relaxation of the problem has a solution, try to exploit
	// it. This is same as above except in this case the lp solution might not be
	// an integer solution.
	ExploitAllLpSolution *bool `protobuf:"varint,116,opt,name=exploit_all_lp_solution,json=exploitAllLpSolution,def=1" json:"exploit_all_lp_solution,omitempty"`
	// When branching on a variable, follow the last best solution value.
	ExploitBestSolution *bool `protobuf:"varint,130,opt,name=exploit_best_solution,json=exploitBestSolution,def=0" json:"exploit_best_solution,omitempty"`
	// When branching on a variable, follow the last best relaxation solution
	// value. We use the relaxation with the tightest bound on the objective as
	// the best relaxation solution.
	ExploitRelaxationSolution *bool `protobuf:"varint,161,opt,name=exploit_relaxation_solution,json=exploitRelaxationSolution,def=0" json:"exploit_relaxation_solution,omitempty"`
	// When branching an a variable that directly affect the objective,
	// branch on the value that lead to the best objective first.
	ExploitObjective *bool `protobuf:"varint,131,opt,name=exploit_objective,json=exploitObjective,def=1" json:"exploit_objective,omitempty"`
	// If set at zero (the default), it is disabled. Otherwise the solver attempts
	// probing at every 'probing_period' root node. Period of 1 enables probing at
	// every root node.
	ProbingPeriodAtRoot *int64 `protobuf:"varint,142,opt,name=probing_period_at_root,json=probingPeriodAtRoot,def=0" json:"probing_period_at_root,omitempty"`
	// If true, search will continuously probe Boolean variables, and integer
	// variable bounds.
	UseProbingSearch *bool `protobuf:"varint,176,opt,name=use_probing_search,json=useProbingSearch,def=0" json:"use_probing_search,omitempty"`
	// The solver ignores the pseudo costs of variables with number of recordings
	// less than this threshold.
	PseudoCostReliabilityThreshold *int64 `protobuf:"varint,123,opt,name=pseudo_cost_reliability_threshold,json=pseudoCostReliabilityThreshold,def=100" json:"pseudo_cost_reliability_threshold,omitempty"`
	// The default optimization method is a simple "linear scan", each time trying
	// to find a better solution than the previous one. If this is true, then we
	// use a core-based approach (like in max-SAT) when we try to increase the
	// lower bound instead.
	OptimizeWithCore *bool `protobuf:"varint,83,opt,name=optimize_with_core,json=optimizeWithCore,def=0" json:"optimize_with_core,omitempty"`
	// If non-negative, perform a binary search on the objective variable in order
	// to find an [min, max] interval outside of which the solver proved unsat/sat
	// under this amount of conflict. This can quickly reduce the objective domain
	// on some problems.
	BinarySearchNumConflicts *int32 `protobuf:"varint,99,opt,name=binary_search_num_conflicts,json=binarySearchNumConflicts,def=-1" json:"binary_search_num_conflicts,omitempty"`
	// This has no effect if optimize_with_core is false. If true, use a different
	// core-based algorithm similar to the max-HS algo for max-SAT. This is a
	// hybrid MIP/CP approach and it uses a MIP solver in addition to the CP/SAT
	// one. This is also related to the PhD work of tobyodavies@
	// "Automatic Logic-Based Benders Decomposition with MiniZinc"
	// http://aaai.org/ocs/index.php/AAAI/AAAI17/paper/view/14489
	OptimizeWithMaxHs *bool `protobuf:"varint,85,opt,name=optimize_with_max_hs,json=optimizeWithMaxHs,def=0" json:"optimize_with_max_hs,omitempty"`
	// Whether we enumerate all solutions of a problem without objective. Note
	// that setting this to true automatically disable the presolve. This is
	// because the presolve rules only guarantee the existence of one feasible
	// solution to the presolved problem.
	//
	// TODO(user): Do not disable the presolve and let the user choose what
	// behavior is best by setting keep_all_feasible_solutions_in_presolve.
	EnumerateAllSolutions *bool `protobuf:"varint,87,opt,name=enumerate_all_solutions,json=enumerateAllSolutions,def=0" json:"enumerate_all_solutions,omitempty"`
	// If true, we disable the presolve reductions that remove feasible solutions
	// from the search space. Such solution are usually dominated by a "better"
	// solution that is kept, but depending on the situation, we might want to
	// keep all solutions.
	//
	// A trivial example is when a variable is unused. If this is true, then the
	// presolve will not fix it to an arbitrary value and it will stay in the
	// search space.
	KeepAllFeasibleSolutionsInPresolve *bool `protobuf:"varint,173,opt,name=keep_all_feasible_solutions_in_presolve,json=keepAllFeasibleSolutionsInPresolve,def=0" json:"keep_all_feasible_solutions_in_presolve,omitempty"`
	// If true, add information about the derived variable domains to the
	// CpSolverResponse. It is an option because it makes the response slighly
	// bigger and there is a bit more work involved during the postsolve to
	// construct it, but it should still have a low overhead. See the
	// tightened_variables field in CpSolverResponse for more details.
	FillTightenedDomainsInResponse *bool `protobuf:"varint,132,opt,name=fill_tightened_domains_in_response,json=fillTightenedDomainsInResponse,def=0" json:"fill_tightened_domains_in_response,omitempty"`
	// If true, the solver will add a default integer branching strategy to the
	// already defined search strategy.
	InstantiateAllVariables *bool `protobuf:"varint,106,opt,name=instantiate_all_variables,json=instantiateAllVariables,def=1" json:"instantiate_all_variables,omitempty"`
	// If true, then the precedences propagator try to detect for each variable if
	// it has a set of "optional incoming arc" for which at least one of them is
	// present. This is usually useful to have but can be slow on model with a lot
	// of precedence.
	AutoDetectGreaterThanAtLeastOneOf *bool `protobuf:"varint,95,opt,name=auto_detect_greater_than_at_least_one_of,json=autoDetectGreaterThanAtLeastOneOf,def=1" json:"auto_detect_greater_than_at_least_one_of,omitempty"`
	// For an optimization problem, stop the solver as soon as we have a solution.
	StopAfterFirstSolution *bool `protobuf:"varint,98,opt,name=stop_after_first_solution,json=stopAfterFirstSolution,def=0" json:"stop_after_first_solution,omitempty"`
	// Mainly used when improving the presolver. When true, stops the solver after
	// the presolve is complete.
	StopAfterPresolve *bool `protobuf:"varint,149,opt,name=stop_after_presolve,json=stopAfterPresolve,def=0" json:"stop_after_presolve,omitempty"`
	// Specify the number of parallel workers to use during search.
	// A number <= 1 means no parallelism.
	// As of 2020-04-10, if you're using SAT via MPSolver (to solve integer
	// programs) this field is overridden with a value of 8, if the field is not
	// set *explicitly*. Thus, always set this field explicitly or via
	// MPSolver::SetNumThreads().
	NumSearchWorkers *int32 `protobuf:"varint,100,opt,name=num_search_workers,json=numSearchWorkers,def=1" json:"num_search_workers,omitempty"`
	// Experimental. If this is true, then we interleave all our major search
	// strategy and distribute the work amongst num_search_workers.
	//
	// The search is deterministic (independently of num_search_workers!), and we
	// schedule and wait for interleave_batch_size task to be completed before
	// synchronizing and scheduling the next batch of tasks.
	InterleaveSearch    *bool  `protobuf:"varint,136,opt,name=interleave_search,json=interleaveSearch,def=0" json:"interleave_search,omitempty"`
	InterleaveBatchSize *int32 `protobuf:"varint,134,opt,name=interleave_batch_size,json=interleaveBatchSize,def=1" json:"interleave_batch_size,omitempty"`
	// Temporary parameter until the memory usage is more optimized.
	ReduceMemoryUsageInInterleaveMode *bool `protobuf:"varint,141,opt,name=reduce_memory_usage_in_interleave_mode,json=reduceMemoryUsageInInterleaveMode,def=0" json:"reduce_memory_usage_in_interleave_mode,omitempty"`
	// Allows objective sharing between workers.
	ShareObjectiveBounds *bool `protobuf:"varint,113,opt,name=share_objective_bounds,json=shareObjectiveBounds,def=1" json:"share_objective_bounds,omitempty"`
	// Allows sharing of the bounds of modified variables at level 0.
	ShareLevelZeroBounds *bool `protobuf:"varint,114,opt,name=share_level_zero_bounds,json=shareLevelZeroBounds,def=1" json:"share_level_zero_bounds,omitempty"`
	// LNS parameters.
	UseLnsOnly                          *bool `protobuf:"varint,101,opt,name=use_lns_only,json=useLnsOnly,def=0" json:"use_lns_only,omitempty"`
	LnsFocusOnDecisionVariables         *bool `protobuf:"varint,105,opt,name=lns_focus_on_decision_variables,json=lnsFocusOnDecisionVariables,def=0" json:"lns_focus_on_decision_variables,omitempty"`
	LnsExpandIntervalsInConstraintGraph *bool `protobuf:"varint,184,opt,name=lns_expand_intervals_in_constraint_graph,json=lnsExpandIntervalsInConstraintGraph,def=1" json:"lns_expand_intervals_in_constraint_graph,omitempty"`
	// Turns on relaxation induced neighborhood generator.
	UseRinsLns *bool `protobuf:"varint,129,opt,name=use_rins_lns,json=useRinsLns,def=1" json:"use_rins_lns,omitempty"`
	// Adds a feasibility pump subsolver along with lns subsolvers.
	UseFeasibilityPump *bool                           `protobuf:"varint,164,opt,name=use_feasibility_pump,json=useFeasibilityPump,def=1" json:"use_feasibility_pump,omitempty"`
	FpRounding         *SatParameters_FPRoundingMethod `protobuf:"varint,165,opt,name=fp_rounding,json=fpRounding,enum=operations_research.sat.SatParameters_FPRoundingMethod,def=2" json:"fp_rounding,omitempty"`
	// Turns on a lns worker which solves relaxed version of the original problem
	// by removing constraints from the problem in order to get better bounds.
	UseRelaxationLns *bool `protobuf:"varint,150,opt,name=use_relaxation_lns,json=useRelaxationLns,def=0" json:"use_relaxation_lns,omitempty"`
	// If true, registers more lns subsolvers with different parameters.
	DiversifyLnsParams *bool `protobuf:"varint,137,opt,name=diversify_lns_params,json=diversifyLnsParams,def=0" json:"diversify_lns_params,omitempty"`
	// Randomize fixed search.
	RandomizeSearch *bool `protobuf:"varint,103,opt,name=randomize_search,json=randomizeSearch,def=0" json:"randomize_search,omitempty"`
	// Search randomization will collect equivalent 'max valued' variables, and
	// pick one randomly. For instance, if the variable strategy is CHOOSE_FIRST,
	// all unassigned variables are equivalent. If the variable strategy is
	// CHOOSE_LOWEST_MIN, and `lm` is the current lowest min of all unassigned
	// variables, then the set of max valued variables will be all unassigned
	// variables where
	//    lm <= variable min <= lm + search_randomization_tolerance
	SearchRandomizationTolerance *int64 `protobuf:"varint,104,opt,name=search_randomization_tolerance,json=searchRandomizationTolerance,def=0" json:"search_randomization_tolerance,omitempty"`
	// If true, we automatically detect variables whose constraint are always
	// enforced by the same literal and we mark them as optional. This allows
	// to propagate them as if they were present in some situation.
	UseOptionalVariables *bool `protobuf:"varint,108,opt,name=use_optional_variables,json=useOptionalVariables,def=1" json:"use_optional_variables,omitempty"`
	// The solver usually exploit the LP relaxation of a model. If this option is
	// true, then whatever is infered by the LP will be used like an heuristic to
	// compute EXACT propagation on the IP. So with this option, there is no
	// numerical imprecision issues.
	UseExactLpReason *bool `protobuf:"varint,109,opt,name=use_exact_lp_reason,json=useExactLpReason,def=1" json:"use_exact_lp_reason,omitempty"`
	// If true, the solver attemts to generate more info inside lp propagator by
	// branching on some variables if certain criteria are met during the search
	// tree exploration.
	UseBranchingInLp *bool `protobuf:"varint,139,opt,name=use_branching_in_lp,json=useBranchingInLp,def=0" json:"use_branching_in_lp,omitempty"`
	// This can be beneficial if there is a lot of no-overlap constraints but a
	// relatively low number of different intervals in the problem. Like 1000
	// intervals, but 1M intervals in the no-overlap constraints covering them.
	UseCombinedNoOverlap *bool `protobuf:"varint,133,opt,name=use_combined_no_overlap,json=useCombinedNoOverlap,def=0" json:"use_combined_no_overlap,omitempty"`
	// Indicates if the CP-SAT layer should catch Control-C (SIGINT) signals
	// when calling solve. If set, catching the SIGINT signal will terminate the
	// search gracefully, as if a time limit was reached.
	CatchSigintSignal *bool `protobuf:"varint,135,opt,name=catch_sigint_signal,json=catchSigintSignal,def=1" json:"catch_sigint_signal,omitempty"`
	// Stores and exploits "implied-bounds" in the solver. That is, relations of
	// the form literal => (var >= bound). This is currently used to derive
	// stronger cuts.
	UseImpliedBounds *bool `protobuf:"varint,144,opt,name=use_implied_bounds,json=useImpliedBounds,def=1" json:"use_implied_bounds,omitempty"`
	// Whether we try to do a few degenerate iteration at the end of an LP solve
	// to minimize the fractionality of the integer variable in the basis. This
	// helps on some problems, but not so much on others. It also cost of bit of
	// time to do such polish step.
	PolishLpSolution *bool `protobuf:"varint,175,opt,name=polish_lp_solution,json=polishLpSolution,def=0" json:"polish_lp_solution,omitempty"`
	// Temporary flag util the feature is more mature. This convert intervals to
	// the newer proto format that support affine start/var/end instead of just
	// variables. It changes a bit the search and is not always better currently.
	ConvertIntervals *bool `protobuf:"varint,177,opt,name=convert_intervals,json=convertIntervals,def=0" json:"convert_intervals,omitempty"`
	// Whether we try to automatically detect the symmetries in a model and
	// exploit them. Currently, at level 1 we detect them in presolve and try
	// to fix Booleans. At level 2, we also do some form of dynamic symmetry
	// breaking during search.
	SymmetryLevel *int32 `protobuf:"varint,183,opt,name=symmetry_level,json=symmetryLevel,def=2" json:"symmetry_level,omitempty"`
	// We need to bound the maximum magnitude of the variables for CP-SAT, and
	// that is the bound we use. If the MIP model expect larger variable value in
	// the solution, then the converted model will likely not be relevant.
	MipMaxBound *float64 `protobuf:"fixed64,124,opt,name=mip_max_bound,json=mipMaxBound,def=1e+07" json:"mip_max_bound,omitempty"`
	// All continuous variable of the problem will be multiplied by this factor.
	// By default, we don't do any variable scaling and rely on the MIP model to
	// specify continuous variable domain with the wanted precision.
	MipVarScaling *float64 `protobuf:"fixed64,125,opt,name=mip_var_scaling,json=mipVarScaling,def=1" json:"mip_var_scaling,omitempty"`
	// If true, some continuous variable might be automatially scaled. For now,
	// this is only the case where we detect that a variable is actually an
	// integer multiple of a constant. For instance, variables of the form k * 0.5
	// are quite frequent, and if we detect this, we will scale such variable
	// domain by 2 to make it implied integer.
	MipAutomaticallyScaleVariables *bool `protobuf:"varint,166,opt,name=mip_automatically_scale_variables,json=mipAutomaticallyScaleVariables,def=1" json:"mip_automatically_scale_variables,omitempty"`
	// When scaling constraint with double coefficients to integer coefficients,
	// we will multiply by a power of 2 and round the coefficients. We will choose
	// the lowest power such that we have no potential overflow and the worst case
	// constraint activity error do not exceed this threshold relative to the
	// constraint bounds.
	//
	// We also use this to decide by how much we relax the constraint bounds so
	// that we can have a feasible integer solution of constraints involving
	// continuous variable. This is required for instance when you have an == rhs
	// constraint as in many situation you cannot have a perfect equality with
	// integer variables and coefficients.
	MipWantedPrecision *float64 `protobuf:"fixed64,126,opt,name=mip_wanted_precision,json=mipWantedPrecision,def=1e-06" json:"mip_wanted_precision,omitempty"`
	// To avoid integer overflow, we always force the maximum possible constraint
	// activity (and objective value) according to the initial variable domain to
	// be smaller than 2 to this given power. Because of this, we cannot always
	// reach the "mip_wanted_precision" parameter above.
	//
	// This can go as high as 62, but some internal algo currently abort early if
	// they might run into integer overflow, so it is better to keep it a bit
	// lower than this.
	MipMaxActivityExponent *int32 `protobuf:"varint,127,opt,name=mip_max_activity_exponent,json=mipMaxActivityExponent,def=53" json:"mip_max_activity_exponent,omitempty"`
	// As explained in mip_precision and mip_max_activity_exponent, we cannot
	// always reach the wanted precision during scaling. We use this threshold to
	// enphasize in the logs when the precision seems bad.
	MipCheckPrecision *float64 `protobuf:"fixed64,128,opt,name=mip_check_precision,json=mipCheckPrecision,def=0.0001" json:"mip_check_precision,omitempty"`
	// contains filtered or unexported fields
}

type SatParameters_BinaryMinizationAlgorithm int32

const (
	SatParameters_NO_BINARY_MINIMIZATION                              SatParameters_BinaryMinizationAlgorithm = 0
	SatParameters_BINARY_MINIMIZATION_FIRST                           SatParameters_BinaryMinizationAlgorithm = 1
	SatParameters_BINARY_MINIMIZATION_FIRST_WITH_TRANSITIVE_REDUCTION SatParameters_BinaryMinizationAlgorithm = 4
	SatParameters_BINARY_MINIMIZATION_WITH_REACHABILITY               SatParameters_BinaryMinizationAlgorithm = 2
	SatParameters_EXPERIMENTAL_BINARY_MINIMIZATION                    SatParameters_BinaryMinizationAlgorithm = 3
)

type SatParameters_ClauseOrdering int32

const (
	// Order clause by decreasing activity, then by increasing LBD.
	SatParameters_CLAUSE_ACTIVITY SatParameters_ClauseOrdering = 0
	// Order clause by increasing LBD, then by decreasing activity.
	SatParameters_CLAUSE_LBD SatParameters_ClauseOrdering = 1
)

type SatParameters_ClauseProtection int32

const (
	SatParameters_PROTECTION_NONE   SatParameters_ClauseProtection = 0 // No protection.
	SatParameters_PROTECTION_ALWAYS SatParameters_ClauseProtection = 1 // Protect all clauses whose activity is bumped.
	SatParameters_PROTECTION_LBD    SatParameters_ClauseProtection = 2 // Only protect clause with a better LBD.
)

type SatParameters_ConflictMinimizationAlgorithm int32

const (
	SatParameters_NONE         SatParameters_ConflictMinimizationAlgorithm = 0
	SatParameters_SIMPLE       SatParameters_ConflictMinimizationAlgorithm = 1
	SatParameters_RECURSIVE    SatParameters_ConflictMinimizationAlgorithm = 2
	SatParameters_EXPERIMENTAL SatParameters_ConflictMinimizationAlgorithm = 3
)

type SatParameters_FPRoundingMethod int32

const (
	// Rounds to the nearest integer value.
	SatParameters_NEAREST_INTEGER SatParameters_FPRoundingMethod = 0
	// Counts the number of linear constraints restricting the variable in the
	// increasing values (up locks) and decreasing values (down locks). Rounds
	// the variable in the direction of lesser locks.
	SatParameters_LOCK_BASED SatParameters_FPRoundingMethod = 1
	// Similar to lock based rounding except this only considers locks of active
	// constraints from the last lp solve.
	SatParameters_ACTIVE_LOCK_BASED SatParameters_FPRoundingMethod = 3
	// This is expensive rounding algorithm. We round variables one by one and
	// propagate the bounds in between. If none of the rounded values fall in
	// the continuous domain specified by lower and upper bound, we use the
	// current lower/upper bound (whichever one is closest) instead of rounding
	// the fractional lp solution value. If both the rounded values are in the
	// domain, we round to nearest integer.
	SatParameters_PROPAGATION_ASSISTED SatParameters_FPRoundingMethod = 2
)

type SatParameters_MaxSatAssumptionOrder int32

const (
	SatParameters_DEFAULT_ASSUMPTION_ORDER   SatParameters_MaxSatAssumptionOrder = 0
	SatParameters_ORDER_ASSUMPTION_BY_DEPTH  SatParameters_MaxSatAssumptionOrder = 1
	SatParameters_ORDER_ASSUMPTION_BY_WEIGHT SatParameters_MaxSatAssumptionOrder = 2
)

type SatParameters_MaxSatStratificationAlgorithm int32

const (
	// No stratification of the problem.
	SatParameters_STRATIFICATION_NONE SatParameters_MaxSatStratificationAlgorithm = 0
	// Start with literals with the highest weight, and when SAT, add the
	// literals with the next highest weight and so on.
	SatParameters_STRATIFICATION_DESCENT SatParameters_MaxSatStratificationAlgorithm = 1
	// Start with all literals. Each time a core is found with a given minimum
	// weight, do not consider literals with a lower weight for the next core
	// computation. If the subproblem is SAT, do like in STRATIFICATION_DESCENT
	// and just add the literals with the next highest weight.
	SatParameters_STRATIFICATION_ASCENT SatParameters_MaxSatStratificationAlgorithm = 2
)

type SatParameters_Polarity int32

const (
	SatParameters_POLARITY_TRUE   SatParameters_Polarity = 0
	SatParameters_POLARITY_FALSE  SatParameters_Polarity = 1
	SatParameters_POLARITY_RANDOM SatParameters_Polarity = 2
	// Choose the sign that tends to satisfy the most constraints. This is
	// computed using a weighted sum: if a literal l appears in a constraint of
	// the form: ... + coeff * l +... <= rhs with positive coefficients and
	// rhs, then -sign(l) * coeff / rhs is added to the weight of l.variable().
	SatParameters_POLARITY_WEIGHTED_SIGN SatParameters_Polarity = 3
	// The opposite choice of POLARITY_WEIGHTED_SIGN.
	SatParameters_POLARITY_REVERSE_WEIGHTED_SIGN SatParameters_Polarity = 4
)

type SatParameters_RestartAlgorithm int32

const (
	SatParameters_NO_RESTART SatParameters_RestartAlgorithm = 0
	// Just follow a Luby sequence times restart_period.
	SatParameters_LUBY_RESTART SatParameters_RestartAlgorithm = 1
	// Moving average restart based on the decision level of conflicts.
	SatParameters_DL_MOVING_AVERAGE_RESTART SatParameters_RestartAlgorithm = 2
	// Moving average restart based on the LBD of conflicts.
	SatParameters_LBD_MOVING_AVERAGE_RESTART SatParameters_RestartAlgorithm = 3
	// Fixed period restart every restart period.
	SatParameters_FIXED_RESTART SatParameters_RestartAlgorithm = 4
)

type SatParameters_SearchBranching int32

const (
	// Try to fix all literals using the underlying SAT solver's heuristics,
	// then generate and fix literals until integer variables are fixed.
	SatParameters_AUTOMATIC_SEARCH SatParameters_SearchBranching = 0
	// If used then all decisions taken by the solver are made using a fixed
	// order as specified in the API or in the CpModelProto search_strategy
	// field.
	SatParameters_FIXED_SEARCH SatParameters_SearchBranching = 1
	// If used, the solver will use various generic heuristics in turn.
	SatParameters_PORTFOLIO_SEARCH SatParameters_SearchBranching = 2
	// If used, the solver will use heuristics from the LP relaxation. This
	// exploit the reduced costs of the variables in the relaxation.
	//
	// TODO(user): Maybe rename REDUCED_COST_SEARCH?
	SatParameters_LP_SEARCH SatParameters_SearchBranching = 3
	// If used, the solver uses the pseudo costs for branching. Pseudo costs
	// are computed using the historical change in objective bounds when some
	// decision are taken.
	SatParameters_PSEUDO_COST_SEARCH SatParameters_SearchBranching = 4
	// Mainly exposed here for testing. This quickly tries a lot of randomized
	// heuristics with a low conflict limit. It usually provides a good first
	// solution.
	SatParameters_PORTFOLIO_WITH_QUICK_RESTART_SEARCH SatParameters_SearchBranching = 5
	// Mainly used internally. This is like FIXED_SEARCH, except we follow the
	// solution_hint field of the CpModelProto rather than using the information
	// provided in the search_strategy.
	SatParameters_HINT_SEARCH SatParameters_SearchBranching = 6
)

type SatParameters_VariableOrder int32

const (
	SatParameters_IN_ORDER         SatParameters_VariableOrder = 0 // As specified by the problem.
	SatParameters_IN_REVERSE_ORDER SatParameters_VariableOrder = 1
	SatParameters_IN_RANDOM_ORDER  SatParameters_VariableOrder = 2
)

type SparsePermutationProto struct {

	// Each cycle is listed one after the other in the support field.
	// The size of each cycle is given (in order) in the cycle_sizes field.
	Support    []int32 `protobuf:"varint,1,rep,packed,name=support,proto3" json:"support,omitempty"`
	CycleSizes []int32 `protobuf:"varint,2,rep,packed,name=cycle_sizes,json=cycleSizes,proto3" json:"cycle_sizes,omitempty"`
	// contains filtered or unexported fields
}

type SymmetryProto struct {

	// A list of variable indices permutations that leave the feasible space of
	// solution invariant. Usually, we only encode a set of generators of the
	// group.
	Permutations []*SparsePermutationProto `protobuf:"bytes,1,rep,name=permutations,proto3" json:"permutations,omitempty"`
	// An orbitope is a special symmetry structure of the solution space. If the
	// variable indices are arranged in a matrix (with no duplicates), then any
	// permutation of the columns will be a valid permutation of the feasible
	// space.
	//
	// This arise quite often. The typical example is a graph coloring problem
	// where for each node i, you have j booleans to indicate its color. If the
	// variables color_of_i_is_j are arranged in a matrix[i][j], then any columns
	// permutations leave the problem invariant.
	Orbitopes []*DenseMatrixProto `protobuf:"bytes,2,rep,name=orbitopes,proto3" json:"orbitopes,omitempty"`
	// contains filtered or unexported fields
}

type TableConstraintProto struct {
	Vars   []int32 `protobuf:"varint,1,rep,packed,name=vars,proto3" json:"vars,omitempty"`
	Values []int64 `protobuf:"varint,2,rep,packed,name=values,proto3" json:"values,omitempty"`
	// If true, the meaning is "negated", that is we forbid any of the given
	// tuple from a feasible assignment.
	Negated bool `protobuf:"varint,3,opt,name=negated,proto3" json:"negated,omitempty"`
	// contains filtered or unexported fields
}