351 #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
355 private static readonly pb::MessageParser<SatParameters> _parser =
new pb::MessageParser<SatParameters>(() =>
new SatParameters());
356 private pb::UnknownFieldSet _unknownFields;
357 private int _hasBits0;
358 private int _hasBits1;
359 private int _hasBits2;
360 private int _hasBits3;
361 private int _hasBits4;
362 private int _hasBits5;
363 private int _hasBits6;
364 private int _hasBits7;
365 private int _hasBits8;
366 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
367 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
368 public static pb::MessageParser<SatParameters>
Parser {
get {
return _parser; } }
370 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
371 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
372 public static pbr::MessageDescriptor
Descriptor {
373 get {
return global::Google.OrTools.Sat.SatParametersReflection.Descriptor.MessageTypes[0]; }
376 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
377 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
378 pbr::MessageDescriptor pb::IMessage.Descriptor {
382 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
383 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
388 partial
void OnConstruction();
390 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
391 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
393 _hasBits0 = other._hasBits0;
394 _hasBits1 = other._hasBits1;
395 _hasBits2 = other._hasBits2;
396 _hasBits3 = other._hasBits3;
397 _hasBits4 = other._hasBits4;
398 _hasBits5 = other._hasBits5;
399 _hasBits6 = other._hasBits6;
400 _hasBits7 = other._hasBits7;
401 _hasBits8 = other._hasBits8;
403 preferredVariableOrder_ = other.preferredVariableOrder_;
404 initialPolarity_ = other.initialPolarity_;
405 usePhaseSaving_ = other.usePhaseSaving_;
406 polarityRephaseIncrement_ = other.polarityRephaseIncrement_;
407 polarityExploitLsHints_ = other.polarityExploitLsHints_;
408 randomPolarityRatio_ = other.randomPolarityRatio_;
409 randomBranchesRatio_ = other.randomBranchesRatio_;
410 useErwaHeuristic_ = other.useErwaHeuristic_;
411 initialVariablesActivity_ = other.initialVariablesActivity_;
412 alsoBumpVariablesInConflictReasons_ = other.alsoBumpVariablesInConflictReasons_;
413 minimizationAlgorithm_ = other.minimizationAlgorithm_;
414 binaryMinimizationAlgorithm_ = other.binaryMinimizationAlgorithm_;
415 subsumptionDuringConflictAnalysis_ = other.subsumptionDuringConflictAnalysis_;
416 clauseCleanupPeriod_ = other.clauseCleanupPeriod_;
417 clauseCleanupTarget_ = other.clauseCleanupTarget_;
418 clauseCleanupRatio_ = other.clauseCleanupRatio_;
419 clauseCleanupProtection_ = other.clauseCleanupProtection_;
420 clauseCleanupLbdBound_ = other.clauseCleanupLbdBound_;
421 clauseCleanupOrdering_ = other.clauseCleanupOrdering_;
422 pbCleanupIncrement_ = other.pbCleanupIncrement_;
423 pbCleanupRatio_ = other.pbCleanupRatio_;
424 variableActivityDecay_ = other.variableActivityDecay_;
425 maxVariableActivityValue_ = other.maxVariableActivityValue_;
426 glucoseMaxDecay_ = other.glucoseMaxDecay_;
427 glucoseDecayIncrement_ = other.glucoseDecayIncrement_;
428 glucoseDecayIncrementPeriod_ = other.glucoseDecayIncrementPeriod_;
429 clauseActivityDecay_ = other.clauseActivityDecay_;
430 maxClauseActivityValue_ = other.maxClauseActivityValue_;
431 restartAlgorithms_ = other.restartAlgorithms_.Clone();
432 defaultRestartAlgorithms_ = other.defaultRestartAlgorithms_;
433 restartPeriod_ = other.restartPeriod_;
434 restartRunningWindowSize_ = other.restartRunningWindowSize_;
435 restartDlAverageRatio_ = other.restartDlAverageRatio_;
436 restartLbdAverageRatio_ = other.restartLbdAverageRatio_;
437 useBlockingRestart_ = other.useBlockingRestart_;
438 blockingRestartWindowSize_ = other.blockingRestartWindowSize_;
439 blockingRestartMultiplier_ = other.blockingRestartMultiplier_;
440 numConflictsBeforeStrategyChanges_ = other.numConflictsBeforeStrategyChanges_;
441 strategyChangeIncreaseRatio_ = other.strategyChangeIncreaseRatio_;
442 maxTimeInSeconds_ = other.maxTimeInSeconds_;
443 maxDeterministicTime_ = other.maxDeterministicTime_;
444 maxNumDeterministicBatches_ = other.maxNumDeterministicBatches_;
445 maxNumberOfConflicts_ = other.maxNumberOfConflicts_;
446 maxMemoryInMb_ = other.maxMemoryInMb_;
447 absoluteGapLimit_ = other.absoluteGapLimit_;
448 relativeGapLimit_ = other.relativeGapLimit_;
449 randomSeed_ = other.randomSeed_;
450 permuteVariableRandomly_ = other.permuteVariableRandomly_;
451 permutePresolveConstraintOrder_ = other.permutePresolveConstraintOrder_;
452 useAbslRandom_ = other.useAbslRandom_;
453 logSearchProgress_ = other.logSearchProgress_;
454 logSubsolverStatistics_ = other.logSubsolverStatistics_;
455 logPrefix_ = other.logPrefix_;
456 logToStdout_ = other.logToStdout_;
457 logToResponse_ = other.logToResponse_;
458 usePbResolution_ = other.usePbResolution_;
459 minimizeReductionDuringPbResolution_ = other.minimizeReductionDuringPbResolution_;
460 countAssumptionLevelsInLbd_ = other.countAssumptionLevelsInLbd_;
461 presolveBveThreshold_ = other.presolveBveThreshold_;
462 presolveBveClauseWeight_ = other.presolveBveClauseWeight_;
463 probingDeterministicTimeLimit_ = other.probingDeterministicTimeLimit_;
464 presolveProbingDeterministicTimeLimit_ = other.presolveProbingDeterministicTimeLimit_;
465 presolveBlockedClause_ = other.presolveBlockedClause_;
466 presolveUseBva_ = other.presolveUseBva_;
467 presolveBvaThreshold_ = other.presolveBvaThreshold_;
468 maxPresolveIterations_ = other.maxPresolveIterations_;
469 cpModelPresolve_ = other.cpModelPresolve_;
470 cpModelProbingLevel_ = other.cpModelProbingLevel_;
471 cpModelUseSatPresolve_ = other.cpModelUseSatPresolve_;
472 removeFixedVariablesEarly_ = other.removeFixedVariablesEarly_;
473 detectTableWithCost_ = other.detectTableWithCost_;
474 tableCompressionLevel_ = other.tableCompressionLevel_;
475 expandAlldiffConstraints_ = other.expandAlldiffConstraints_;
476 expandReservoirConstraints_ = other.expandReservoirConstraints_;
477 expandReservoirUsingCircuit_ = other.expandReservoirUsingCircuit_;
478 encodeCumulativeAsReservoir_ = other.encodeCumulativeAsReservoir_;
479 maxLinMaxSizeForExpansion_ = other.maxLinMaxSizeForExpansion_;
480 disableConstraintExpansion_ = other.disableConstraintExpansion_;
481 encodeComplexLinearConstraintWithInteger_ = other.encodeComplexLinearConstraintWithInteger_;
482 mergeNoOverlapWorkLimit_ = other.mergeNoOverlapWorkLimit_;
483 mergeAtMostOneWorkLimit_ = other.mergeAtMostOneWorkLimit_;
484 presolveSubstitutionLevel_ = other.presolveSubstitutionLevel_;
485 presolveExtractIntegerEnforcement_ = other.presolveExtractIntegerEnforcement_;
486 presolveInclusionWorkLimit_ = other.presolveInclusionWorkLimit_;
487 ignoreNames_ = other.ignoreNames_;
488 inferAllDiffs_ = other.inferAllDiffs_;
489 findBigLinearOverlap_ = other.findBigLinearOverlap_;
490 useSatInprocessing_ = other.useSatInprocessing_;
491 inprocessingDtimeRatio_ = other.inprocessingDtimeRatio_;
492 inprocessingProbingDtime_ = other.inprocessingProbingDtime_;
493 inprocessingMinimizationDtime_ = other.inprocessingMinimizationDtime_;
494 inprocessingMinimizationUseConflictAnalysis_ = other.inprocessingMinimizationUseConflictAnalysis_;
495 inprocessingMinimizationUseAllOrderings_ = other.inprocessingMinimizationUseAllOrderings_;
496 numWorkers_ = other.numWorkers_;
497 numSearchWorkers_ = other.numSearchWorkers_;
498 numFullSubsolvers_ = other.numFullSubsolvers_;
499 subsolvers_ = other.subsolvers_.Clone();
500 extraSubsolvers_ = other.extraSubsolvers_.Clone();
501 ignoreSubsolvers_ = other.ignoreSubsolvers_.Clone();
502 filterSubsolvers_ = other.filterSubsolvers_.Clone();
503 subsolverParams_ = other.subsolverParams_.Clone();
504 interleaveSearch_ = other.interleaveSearch_;
505 interleaveBatchSize_ = other.interleaveBatchSize_;
506 shareObjectiveBounds_ = other.shareObjectiveBounds_;
507 shareLevelZeroBounds_ = other.shareLevelZeroBounds_;
508 shareBinaryClauses_ = other.shareBinaryClauses_;
509 shareGlueClauses_ = other.shareGlueClauses_;
510 minimizeSharedClauses_ = other.minimizeSharedClauses_;
511 debugPostsolveWithFullSolver_ = other.debugPostsolveWithFullSolver_;
512 debugMaxNumPresolveOperations_ = other.debugMaxNumPresolveOperations_;
513 debugCrashOnBadHint_ = other.debugCrashOnBadHint_;
514 debugCrashIfPresolveBreaksHint_ = other.debugCrashIfPresolveBreaksHint_;
515 useOptimizationHints_ = other.useOptimizationHints_;
516 coreMinimizationLevel_ = other.coreMinimizationLevel_;
517 findMultipleCores_ = other.findMultipleCores_;
518 coverOptimization_ = other.coverOptimization_;
519 maxSatAssumptionOrder_ = other.maxSatAssumptionOrder_;
520 maxSatReverseAssumptionOrder_ = other.maxSatReverseAssumptionOrder_;
521 maxSatStratification_ = other.maxSatStratification_;
522 propagationLoopDetectionFactor_ = other.propagationLoopDetectionFactor_;
523 usePrecedencesInDisjunctiveConstraint_ = other.usePrecedencesInDisjunctiveConstraint_;
524 maxSizeToCreatePrecedenceLiteralsInDisjunctive_ = other.maxSizeToCreatePrecedenceLiteralsInDisjunctive_;
525 useStrongPropagationInDisjunctive_ = other.useStrongPropagationInDisjunctive_;
526 useDynamicPrecedenceInDisjunctive_ = other.useDynamicPrecedenceInDisjunctive_;
527 useDynamicPrecedenceInCumulative_ = other.useDynamicPrecedenceInCumulative_;
528 useOverloadCheckerInCumulative_ = other.useOverloadCheckerInCumulative_;
529 useConservativeScaleOverloadChecker_ = other.useConservativeScaleOverloadChecker_;
530 useTimetableEdgeFindingInCumulative_ = other.useTimetableEdgeFindingInCumulative_;
531 maxNumIntervalsForTimetableEdgeFinding_ = other.maxNumIntervalsForTimetableEdgeFinding_;
532 useHardPrecedencesInCumulative_ = other.useHardPrecedencesInCumulative_;
533 exploitAllPrecedences_ = other.exploitAllPrecedences_;
534 useDisjunctiveConstraintInCumulative_ = other.useDisjunctiveConstraintInCumulative_;
535 useTimetablingInNoOverlap2D_ = other.useTimetablingInNoOverlap2D_;
536 useEnergeticReasoningInNoOverlap2D_ = other.useEnergeticReasoningInNoOverlap2D_;
537 useAreaEnergeticReasoningInNoOverlap2D_ = other.useAreaEnergeticReasoningInNoOverlap2D_;
538 useTryEdgeReasoningInNoOverlap2D_ = other.useTryEdgeReasoningInNoOverlap2D_;
539 maxPairsPairwiseReasoningInNoOverlap2D_ = other.maxPairsPairwiseReasoningInNoOverlap2D_;
540 maximumRegionsToSplitInDisconnectedNoOverlap2D_ = other.maximumRegionsToSplitInDisconnectedNoOverlap2D_;
541 useDualSchedulingHeuristics_ = other.useDualSchedulingHeuristics_;
542 useAllDifferentForCircuit_ = other.useAllDifferentForCircuit_;
543 routingCutSubsetSizeForBinaryRelationBound_ = other.routingCutSubsetSizeForBinaryRelationBound_;
544 routingCutSubsetSizeForTightBinaryRelationBound_ = other.routingCutSubsetSizeForTightBinaryRelationBound_;
545 routingCutDpEffort_ = other.routingCutDpEffort_;
546 searchBranching_ = other.searchBranching_;
547 hintConflictLimit_ = other.hintConflictLimit_;
548 repairHint_ = other.repairHint_;
549 fixVariablesToTheirHintedValue_ = other.fixVariablesToTheirHintedValue_;
550 useProbingSearch_ = other.useProbingSearch_;
551 useExtendedProbing_ = other.useExtendedProbing_;
552 probingNumCombinationsLimit_ = other.probingNumCombinationsLimit_;
553 useShavingInProbingSearch_ = other.useShavingInProbingSearch_;
554 shavingSearchDeterministicTime_ = other.shavingSearchDeterministicTime_;
555 shavingSearchThreshold_ = other.shavingSearchThreshold_;
556 useObjectiveLbSearch_ = other.useObjectiveLbSearch_;
557 useObjectiveShavingSearch_ = other.useObjectiveShavingSearch_;
558 useVariablesShavingSearch_ = other.useVariablesShavingSearch_;
559 pseudoCostReliabilityThreshold_ = other.pseudoCostReliabilityThreshold_;
560 optimizeWithCore_ = other.optimizeWithCore_;
561 optimizeWithLbTreeSearch_ = other.optimizeWithLbTreeSearch_;
562 saveLpBasisInLbTreeSearch_ = other.saveLpBasisInLbTreeSearch_;
563 binarySearchNumConflicts_ = other.binarySearchNumConflicts_;
564 optimizeWithMaxHs_ = other.optimizeWithMaxHs_;
565 useFeasibilityJump_ = other.useFeasibilityJump_;
566 useLsOnly_ = other.useLsOnly_;
567 feasibilityJumpDecay_ = other.feasibilityJumpDecay_;
568 feasibilityJumpLinearizationLevel_ = other.feasibilityJumpLinearizationLevel_;
569 feasibilityJumpRestartFactor_ = other.feasibilityJumpRestartFactor_;
570 feasibilityJumpBatchDtime_ = other.feasibilityJumpBatchDtime_;
571 feasibilityJumpVarRandomizationProbability_ = other.feasibilityJumpVarRandomizationProbability_;
572 feasibilityJumpVarPerburbationRangeRatio_ = other.feasibilityJumpVarPerburbationRangeRatio_;
573 feasibilityJumpEnableRestarts_ = other.feasibilityJumpEnableRestarts_;
574 feasibilityJumpMaxExpandedConstraintSize_ = other.feasibilityJumpMaxExpandedConstraintSize_;
575 numViolationLs_ = other.numViolationLs_;
576 violationLsPerturbationPeriod_ = other.violationLsPerturbationPeriod_;
577 violationLsCompoundMoveProbability_ = other.violationLsCompoundMoveProbability_;
578 sharedTreeNumWorkers_ = other.sharedTreeNumWorkers_;
579 useSharedTreeSearch_ = other.useSharedTreeSearch_;
580 sharedTreeWorkerMinRestartsPerSubtree_ = other.sharedTreeWorkerMinRestartsPerSubtree_;
581 sharedTreeWorkerEnableTrailSharing_ = other.sharedTreeWorkerEnableTrailSharing_;
582 sharedTreeWorkerEnablePhaseSharing_ = other.sharedTreeWorkerEnablePhaseSharing_;
583 sharedTreeOpenLeavesPerWorker_ = other.sharedTreeOpenLeavesPerWorker_;
584 sharedTreeMaxNodesPerWorker_ = other.sharedTreeMaxNodesPerWorker_;
585 sharedTreeSplitStrategy_ = other.sharedTreeSplitStrategy_;
586 sharedTreeBalanceTolerance_ = other.sharedTreeBalanceTolerance_;
587 enumerateAllSolutions_ = other.enumerateAllSolutions_;
588 keepAllFeasibleSolutionsInPresolve_ = other.keepAllFeasibleSolutionsInPresolve_;
589 fillTightenedDomainsInResponse_ = other.fillTightenedDomainsInResponse_;
590 fillAdditionalSolutionsInResponse_ = other.fillAdditionalSolutionsInResponse_;
591 instantiateAllVariables_ = other.instantiateAllVariables_;
592 autoDetectGreaterThanAtLeastOneOf_ = other.autoDetectGreaterThanAtLeastOneOf_;
593 stopAfterFirstSolution_ = other.stopAfterFirstSolution_;
594 stopAfterPresolve_ = other.stopAfterPresolve_;
595 stopAfterRootPropagation_ = other.stopAfterRootPropagation_;
596 lnsInitialDifficulty_ = other.lnsInitialDifficulty_;
597 lnsInitialDeterministicLimit_ = other.lnsInitialDeterministicLimit_;
598 useLns_ = other.useLns_;
599 useLnsOnly_ = other.useLnsOnly_;
600 solutionPoolSize_ = other.solutionPoolSize_;
601 useRinsLns_ = other.useRinsLns_;
602 useFeasibilityPump_ = other.useFeasibilityPump_;
603 useLbRelaxLns_ = other.useLbRelaxLns_;
604 lbRelaxNumWorkersThreshold_ = other.lbRelaxNumWorkersThreshold_;
605 fpRounding_ = other.fpRounding_;
606 diversifyLnsParams_ = other.diversifyLnsParams_;
607 randomizeSearch_ = other.randomizeSearch_;
608 searchRandomVariablePoolSize_ = other.searchRandomVariablePoolSize_;
609 pushAllTasksTowardStart_ = other.pushAllTasksTowardStart_;
610 useOptionalVariables_ = other.useOptionalVariables_;
611 useExactLpReason_ = other.useExactLpReason_;
612 useCombinedNoOverlap_ = other.useCombinedNoOverlap_;
613 atMostOneMaxExpansionSize_ = other.atMostOneMaxExpansionSize_;
614 catchSigintSignal_ = other.catchSigintSignal_;
615 useImpliedBounds_ = other.useImpliedBounds_;
616 polishLpSolution_ = other.polishLpSolution_;
617 lpPrimalTolerance_ = other.lpPrimalTolerance_;
618 lpDualTolerance_ = other.lpDualTolerance_;
619 convertIntervals_ = other.convertIntervals_;
620 symmetryLevel_ = other.symmetryLevel_;
621 useSymmetryInLp_ = other.useSymmetryInLp_;
622 keepSymmetryInPresolve_ = other.keepSymmetryInPresolve_;
623 symmetryDetectionDeterministicTimeLimit_ = other.symmetryDetectionDeterministicTimeLimit_;
624 newLinearPropagation_ = other.newLinearPropagation_;
625 linearSplitSize_ = other.linearSplitSize_;
626 linearizationLevel_ = other.linearizationLevel_;
627 booleanEncodingLevel_ = other.booleanEncodingLevel_;
628 maxDomainSizeWhenEncodingEqNeqConstraints_ = other.maxDomainSizeWhenEncodingEqNeqConstraints_;
629 maxNumCuts_ = other.maxNumCuts_;
630 cutLevel_ = other.cutLevel_;
631 onlyAddCutsAtLevelZero_ = other.onlyAddCutsAtLevelZero_;
632 addObjectiveCut_ = other.addObjectiveCut_;
633 addCgCuts_ = other.addCgCuts_;
634 addMirCuts_ = other.addMirCuts_;
635 addZeroHalfCuts_ = other.addZeroHalfCuts_;
636 addCliqueCuts_ = other.addCliqueCuts_;
637 addRltCuts_ = other.addRltCuts_;
638 maxAllDiffCutSize_ = other.maxAllDiffCutSize_;
639 addLinMaxCuts_ = other.addLinMaxCuts_;
640 maxIntegerRoundingScaling_ = other.maxIntegerRoundingScaling_;
641 addLpConstraintsLazily_ = other.addLpConstraintsLazily_;
642 rootLpIterations_ = other.rootLpIterations_;
643 minOrthogonalityForLpConstraints_ = other.minOrthogonalityForLpConstraints_;
644 maxCutRoundsAtLevelZero_ = other.maxCutRoundsAtLevelZero_;
645 maxConsecutiveInactiveCount_ = other.maxConsecutiveInactiveCount_;
646 cutMaxActiveCountValue_ = other.cutMaxActiveCountValue_;
647 cutActiveCountDecay_ = other.cutActiveCountDecay_;
648 cutCleanupTarget_ = other.cutCleanupTarget_;
649 newConstraintsBatchSize_ = other.newConstraintsBatchSize_;
650 exploitIntegerLpSolution_ = other.exploitIntegerLpSolution_;
651 exploitAllLpSolution_ = other.exploitAllLpSolution_;
652 exploitBestSolution_ = other.exploitBestSolution_;
653 exploitRelaxationSolution_ = other.exploitRelaxationSolution_;
654 exploitObjective_ = other.exploitObjective_;
655 detectLinearizedProduct_ = other.detectLinearizedProduct_;
656 mipMaxBound_ = other.mipMaxBound_;
657 mipVarScaling_ = other.mipVarScaling_;
658 mipScaleLargeDomain_ = other.mipScaleLargeDomain_;
659 mipAutomaticallyScaleVariables_ = other.mipAutomaticallyScaleVariables_;
660 onlySolveIp_ = other.onlySolveIp_;
661 mipWantedPrecision_ = other.mipWantedPrecision_;
662 mipMaxActivityExponent_ = other.mipMaxActivityExponent_;
663 mipCheckPrecision_ = other.mipCheckPrecision_;
664 mipComputeTrueObjectiveBound_ = other.mipComputeTrueObjectiveBound_;
665 mipMaxValidMagnitude_ = other.mipMaxValidMagnitude_;
666 mipTreatHighMagnitudeBoundsAsInfinity_ = other.mipTreatHighMagnitudeBoundsAsInfinity_;
667 mipDropTolerance_ = other.mipDropTolerance_;
668 mipPresolveLevel_ = other.mipPresolveLevel_;
669 _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
672 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
673 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
680 private readonly
static string NameDefaultValue =
"";
682 private string name_;
687 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
688 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
690 get {
return name_ ?? NameDefaultValue; }
692 name_ = pb::ProtoPreconditions.CheckNotNull(value,
"value");
696 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
697 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
699 get {
return name_ !=
null; }
702 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
703 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
710 private readonly
static global::Google.OrTools.Sat.SatParameters.Types.VariableOrder PreferredVariableOrderDefaultValue = global::Google.OrTools.Sat.SatParameters.Types.VariableOrder.InOrder;
712 private global::Google.OrTools.Sat.SatParameters.Types.VariableOrder preferredVariableOrder_;
713 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
714 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
716 get { if ((_hasBits0 & 1) != 0) { return preferredVariableOrder_; } else { return PreferredVariableOrderDefaultValue; } }
719 preferredVariableOrder_ = value;
723 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
724 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
725 public bool HasPreferredVariableOrder {
726 get {
return (_hasBits0 & 1) != 0; }
729 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
730 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
731 public void ClearPreferredVariableOrder() {
736 public const int InitialPolarityFieldNumber = 2;
737 private readonly
static global::Google.OrTools.Sat.SatParameters.Types.Polarity InitialPolarityDefaultValue = global::Google.OrTools.Sat.SatParameters.Types.Polarity.False;
739 private global::Google.OrTools.Sat.SatParameters.Types.Polarity initialPolarity_;
740 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
741 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
743 get { if ((_hasBits0 & 2) != 0) { return initialPolarity_; } else { return InitialPolarityDefaultValue; } }
746 initialPolarity_ = value;
750 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
751 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
752 public bool HasInitialPolarity {
753 get {
return (_hasBits0 & 2) != 0; }
756 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
757 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
758 public void ClearInitialPolarity() {
763 public const int UsePhaseSavingFieldNumber = 44;
764 private readonly
static bool UsePhaseSavingDefaultValue =
true;
766 private bool usePhaseSaving_;
780 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
781 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
783 get {
if ((_hasBits0 & 4194304) != 0) {
return usePhaseSaving_; }
else {
return UsePhaseSavingDefaultValue; } }
785 _hasBits0 |= 4194304;
786 usePhaseSaving_ = value;
790 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
791 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
792 public bool HasUsePhaseSaving {
793 get {
return (_hasBits0 & 4194304) != 0; }
796 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
797 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
799 _hasBits0 &= ~4194304;
804 private readonly
static int PolarityRephaseIncrementDefaultValue = 1000;
806 private int polarityRephaseIncrement_;
812 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
813 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
815 get {
if ((_hasBits4 & 4) != 0) {
return polarityRephaseIncrement_; }
else {
return PolarityRephaseIncrementDefaultValue; } }
818 polarityRephaseIncrement_ = value;
822 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
823 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
824 public bool HasPolarityRephaseIncrement {
825 get {
return (_hasBits4 & 4) != 0; }
828 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
829 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
836 private readonly
static bool PolarityExploitLsHintsDefaultValue =
false;
838 private bool polarityExploitLsHints_;
843 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
844 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
846 get {
if ((_hasBits7 & 134217728) != 0) {
return polarityExploitLsHints_; }
else {
return PolarityExploitLsHintsDefaultValue; } }
848 _hasBits7 |= 134217728;
849 polarityExploitLsHints_ = value;
853 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
854 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
855 public bool HasPolarityExploitLsHints {
856 get {
return (_hasBits7 & 134217728) != 0; }
859 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
860 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
862 _hasBits7 &= ~134217728;
867 private readonly
static double RandomPolarityRatioDefaultValue = 0D;
869 private double randomPolarityRatio_;
877 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
878 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
880 get {
if ((_hasBits0 & 8388608) != 0) {
return randomPolarityRatio_; }
else {
return RandomPolarityRatioDefaultValue; } }
882 _hasBits0 |= 8388608;
883 randomPolarityRatio_ = value;
887 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
888 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
889 public bool HasRandomPolarityRatio {
890 get {
return (_hasBits0 & 8388608) != 0; }
893 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
894 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
896 _hasBits0 &= ~8388608;
901 private readonly
static double RandomBranchesRatioDefaultValue = 0D;
903 private double randomBranchesRatio_;
909 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
910 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
912 get {
if ((_hasBits0 & 16384) != 0) {
return randomBranchesRatio_; }
else {
return RandomBranchesRatioDefaultValue; } }
915 randomBranchesRatio_ = value;
919 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
920 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
921 public bool HasRandomBranchesRatio {
922 get {
return (_hasBits0 & 16384) != 0; }
925 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
926 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
933 private readonly
static bool UseErwaHeuristicDefaultValue =
false;
935 private bool useErwaHeuristic_;
941 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
942 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
944 get {
if ((_hasBits1 & 524288) != 0) {
return useErwaHeuristic_; }
else {
return UseErwaHeuristicDefaultValue; } }
947 useErwaHeuristic_ = value;
951 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
952 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
953 public bool HasUseErwaHeuristic {
954 get {
return (_hasBits1 & 524288) != 0; }
957 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
958 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
960 _hasBits1 &= ~524288;
965 private readonly
static double InitialVariablesActivityDefaultValue = 0D;
967 private double initialVariablesActivity_;
976 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
977 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
979 get {
if ((_hasBits1 & 1048576) != 0) {
return initialVariablesActivity_; }
else {
return InitialVariablesActivityDefaultValue; } }
981 _hasBits1 |= 1048576;
982 initialVariablesActivity_ = value;
986 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
987 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
988 public bool HasInitialVariablesActivity {
989 get {
return (_hasBits1 & 1048576) != 0; }
992 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
993 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
995 _hasBits1 &= ~1048576;
1000 private readonly
static bool AlsoBumpVariablesInConflictReasonsDefaultValue =
false;
1002 private bool alsoBumpVariablesInConflictReasons_;
1009 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1010 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1012 get {
if ((_hasBits1 & 2097152) != 0) {
return alsoBumpVariablesInConflictReasons_; }
else {
return AlsoBumpVariablesInConflictReasonsDefaultValue; } }
1014 _hasBits1 |= 2097152;
1015 alsoBumpVariablesInConflictReasons_ = value;
1019 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1020 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1021 public bool HasAlsoBumpVariablesInConflictReasons {
1022 get {
return (_hasBits1 & 2097152) != 0; }
1025 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1026 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1028 _hasBits1 &= ~2097152;
1033 private readonly
static global::Google.OrTools.Sat.SatParameters.Types.ConflictMinimizationAlgorithm MinimizationAlgorithmDefaultValue = global::Google.OrTools.Sat.SatParameters.Types.ConflictMinimizationAlgorithm.Recursive;
1035 private global::Google.OrTools.Sat.SatParameters.Types.ConflictMinimizationAlgorithm minimizationAlgorithm_;
1036 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1037 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1039 get { if ((_hasBits0 & 4) != 0) { return minimizationAlgorithm_; } else { return MinimizationAlgorithmDefaultValue; } }
1042 minimizationAlgorithm_ = value;
1046 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1047 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1048 public bool HasMinimizationAlgorithm {
1049 get {
return (_hasBits0 & 4) != 0; }
1052 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1053 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1060 private readonly
static global::Google.OrTools.Sat.SatParameters.Types.BinaryMinizationAlgorithm BinaryMinimizationAlgorithmDefaultValue = global::Google.OrTools.Sat.SatParameters.Types.BinaryMinizationAlgorithm.BinaryMinimizationFirst;
1062 private global::Google.OrTools.Sat.SatParameters.Types.BinaryMinizationAlgorithm binaryMinimizationAlgorithm_;
1063 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1064 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1066 get { if ((_hasBits0 & 32768) != 0) { return binaryMinimizationAlgorithm_; } else { return BinaryMinimizationAlgorithmDefaultValue; } }
1069 binaryMinimizationAlgorithm_ = value;
1073 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1074 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1075 public bool HasBinaryMinimizationAlgorithm {
1076 get {
return (_hasBits0 & 32768) != 0; }
1079 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1080 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1082 _hasBits0 &= ~32768;
1087 private readonly
static bool SubsumptionDuringConflictAnalysisDefaultValue =
true;
1089 private bool subsumptionDuringConflictAnalysis_;
1096 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1097 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1099 get {
if ((_hasBits1 & 4) != 0) {
return subsumptionDuringConflictAnalysis_; }
else {
return SubsumptionDuringConflictAnalysisDefaultValue; } }
1102 subsumptionDuringConflictAnalysis_ = value;
1106 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1107 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1108 public bool HasSubsumptionDuringConflictAnalysis {
1109 get {
return (_hasBits1 & 4) != 0; }
1112 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1113 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1120 private readonly
static int ClauseCleanupPeriodDefaultValue = 10000;
1122 private int clauseCleanupPeriod_;
1126 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1127 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1129 get {
if ((_hasBits0 & 8) != 0) {
return clauseCleanupPeriod_; }
else {
return ClauseCleanupPeriodDefaultValue; } }
1132 clauseCleanupPeriod_ = value;
1136 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1137 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1138 public bool HasClauseCleanupPeriod {
1139 get {
return (_hasBits0 & 8) != 0; }
1142 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1143 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1150 private readonly
static int ClauseCleanupTargetDefaultValue = 0;
1152 private int clauseCleanupTarget_;
1157 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1158 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1160 get {
if ((_hasBits0 & 16) != 0) {
return clauseCleanupTarget_; }
else {
return ClauseCleanupTargetDefaultValue; } }
1163 clauseCleanupTarget_ = value;
1167 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1168 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1169 public bool HasClauseCleanupTarget {
1170 get {
return (_hasBits0 & 16) != 0; }
1173 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1174 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1181 private readonly
static double ClauseCleanupRatioDefaultValue = 0.5D;
1183 private double clauseCleanupRatio_;
1189 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1190 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1192 get {
if ((_hasBits4 & 2097152) != 0) {
return clauseCleanupRatio_; }
else {
return ClauseCleanupRatioDefaultValue; } }
1194 _hasBits4 |= 2097152;
1195 clauseCleanupRatio_ = value;
1199 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1200 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1201 public bool HasClauseCleanupRatio {
1202 get {
return (_hasBits4 & 2097152) != 0; }
1205 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1206 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1208 _hasBits4 &= ~2097152;
1213 private readonly
static global::Google.OrTools.Sat.SatParameters.Types.ClauseProtection ClauseCleanupProtectionDefaultValue = global::Google.OrTools.Sat.SatParameters.Types.ClauseProtection.ProtectionNone;
1215 private global::Google.OrTools.Sat.SatParameters.Types.ClauseProtection clauseCleanupProtection_;
1216 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1217 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1219 get { if ((_hasBits1 & 16) != 0) { return clauseCleanupProtection_; } else { return ClauseCleanupProtectionDefaultValue; } }
1222 clauseCleanupProtection_ = value;
1226 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1227 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1228 public bool HasClauseCleanupProtection {
1229 get {
return (_hasBits1 & 16) != 0; }
1232 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1233 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1240 private readonly
static int ClauseCleanupLbdBoundDefaultValue = 5;
1242 private int clauseCleanupLbdBound_;
1247 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1248 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1250 get {
if ((_hasBits1 & 32) != 0) {
return clauseCleanupLbdBound_; }
else {
return ClauseCleanupLbdBoundDefaultValue; } }
1253 clauseCleanupLbdBound_ = value;
1257 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1258 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1259 public bool HasClauseCleanupLbdBound {
1260 get {
return (_hasBits1 & 32) != 0; }
1263 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1264 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1271 private readonly
static global::Google.OrTools.Sat.SatParameters.Types.ClauseOrdering ClauseCleanupOrderingDefaultValue = global::Google.OrTools.Sat.SatParameters.Types.ClauseOrdering.ClauseActivity;
1273 private global::Google.OrTools.Sat.SatParameters.Types.ClauseOrdering clauseCleanupOrdering_;
1274 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1275 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1277 get { if ((_hasBits1 & 64) != 0) { return clauseCleanupOrdering_; } else { return ClauseCleanupOrderingDefaultValue; } }
1280 clauseCleanupOrdering_ = value;
1284 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1285 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1286 public bool HasClauseCleanupOrdering {
1287 get {
return (_hasBits1 & 64) != 0; }
1290 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1291 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1298 private readonly
static int PbCleanupIncrementDefaultValue = 200;
1300 private int pbCleanupIncrement_;
1304 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1305 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1307 get {
if ((_hasBits0 & 16777216) != 0) {
return pbCleanupIncrement_; }
else {
return PbCleanupIncrementDefaultValue; } }
1309 _hasBits0 |= 16777216;
1310 pbCleanupIncrement_ = value;
1314 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1315 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1316 public bool HasPbCleanupIncrement {
1317 get {
return (_hasBits0 & 16777216) != 0; }
1320 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1321 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1323 _hasBits0 &= ~16777216;
1328 private readonly
static double PbCleanupRatioDefaultValue = 0.5D;
1330 private double pbCleanupRatio_;
1331 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1332 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1334 get {
if ((_hasBits0 & 33554432) != 0) {
return pbCleanupRatio_; }
else {
return PbCleanupRatioDefaultValue; } }
1336 _hasBits0 |= 33554432;
1337 pbCleanupRatio_ = value;
1341 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1342 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1343 public bool HasPbCleanupRatio {
1344 get {
return (_hasBits0 & 33554432) != 0; }
1347 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1348 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1350 _hasBits0 &= ~33554432;
1355 private readonly
static double VariableActivityDecayDefaultValue = 0.8D;
1357 private double variableActivityDecay_;
1368 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1369 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1371 get {
if ((_hasBits0 & 32) != 0) {
return variableActivityDecay_; }
else {
return VariableActivityDecayDefaultValue; } }
1374 variableActivityDecay_ = value;
1378 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1379 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1380 public bool HasVariableActivityDecay {
1381 get {
return (_hasBits0 & 32) != 0; }
1384 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1385 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1392 private readonly
static double MaxVariableActivityValueDefaultValue = 1e+100D;
1394 private double maxVariableActivityValue_;
1395 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1396 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1398 get {
if ((_hasBits0 & 64) != 0) {
return maxVariableActivityValue_; }
else {
return MaxVariableActivityValueDefaultValue; } }
1401 maxVariableActivityValue_ = value;
1405 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1406 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1407 public bool HasMaxVariableActivityValue {
1408 get {
return (_hasBits0 & 64) != 0; }
1411 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1412 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1419 private readonly
static double GlucoseMaxDecayDefaultValue = 0.95D;
1421 private double glucoseMaxDecay_;
1429 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1430 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1432 get {
if ((_hasBits0 & 512) != 0) {
return glucoseMaxDecay_; }
else {
return GlucoseMaxDecayDefaultValue; } }
1435 glucoseMaxDecay_ = value;
1439 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1440 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1441 public bool HasGlucoseMaxDecay {
1442 get {
return (_hasBits0 & 512) != 0; }
1445 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1446 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1453 private readonly
static double GlucoseDecayIncrementDefaultValue = 0.01D;
1455 private double glucoseDecayIncrement_;
1456 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1457 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1459 get {
if ((_hasBits0 & 1024) != 0) {
return glucoseDecayIncrement_; }
else {
return GlucoseDecayIncrementDefaultValue; } }
1462 glucoseDecayIncrement_ = value;
1466 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1467 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1468 public bool HasGlucoseDecayIncrement {
1469 get {
return (_hasBits0 & 1024) != 0; }
1472 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1473 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1480 private readonly
static int GlucoseDecayIncrementPeriodDefaultValue = 5000;
1482 private int glucoseDecayIncrementPeriod_;
1483 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1484 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1486 get {
if ((_hasBits0 & 2048) != 0) {
return glucoseDecayIncrementPeriod_; }
else {
return GlucoseDecayIncrementPeriodDefaultValue; } }
1489 glucoseDecayIncrementPeriod_ = value;
1493 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1494 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1495 public bool HasGlucoseDecayIncrementPeriod {
1496 get {
return (_hasBits0 & 2048) != 0; }
1499 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1500 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1507 private readonly
static double ClauseActivityDecayDefaultValue = 0.999D;
1509 private double clauseActivityDecay_;
1513 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1514 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1516 get {
if ((_hasBits0 & 128) != 0) {
return clauseActivityDecay_; }
else {
return ClauseActivityDecayDefaultValue; } }
1519 clauseActivityDecay_ = value;
1523 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1524 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1525 public bool HasClauseActivityDecay {
1526 get {
return (_hasBits0 & 128) != 0; }
1529 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1530 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1537 private readonly
static double MaxClauseActivityValueDefaultValue = 1e+20D;
1539 private double maxClauseActivityValue_;
1540 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1541 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1543 get {
if ((_hasBits0 & 256) != 0) {
return maxClauseActivityValue_; }
else {
return MaxClauseActivityValueDefaultValue; } }
1546 maxClauseActivityValue_ = value;
1550 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1551 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1552 public bool HasMaxClauseActivityValue {
1553 get {
return (_hasBits0 & 256) != 0; }
1556 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1557 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1564 private static readonly pb::FieldCodec<global::Google.OrTools.Sat.SatParameters.Types.RestartAlgorithm> _repeated_restartAlgorithms_codec
1566 private readonly pbc::RepeatedField<global::Google.OrTools.Sat.SatParameters.Types.RestartAlgorithm> restartAlgorithms_ =
new pbc::RepeatedField<global::Google.OrTools.Sat.SatParameters.Types.RestartAlgorithm>();
1578 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1579 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1580 public pbc::RepeatedField<global::Google.OrTools.Sat.SatParameters.Types.RestartAlgorithm>
RestartAlgorithms {
1581 get { return restartAlgorithms_; }
1585 public const int DefaultRestartAlgorithmsFieldNumber = 70;
1586 private readonly
static string DefaultRestartAlgorithmsDefaultValue = global::System.Text.Encoding.UTF8.GetString(global::System.Convert.FromBase64String(
"TFVCWV9SRVNUQVJULExCRF9NT1ZJTkdfQVZFUkFHRV9SRVNUQVJULERMX01PVklOR19BVkVSQUdFX1JFU1RBUlQ="), 0, 65);
1588 private string defaultRestartAlgorithms_;
1589 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1590 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1592 get { return defaultRestartAlgorithms_ ?? DefaultRestartAlgorithmsDefaultValue; }
1594 defaultRestartAlgorithms_ = pb::ProtoPreconditions.CheckNotNull(value,
"value");
1598 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1599 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1601 get {
return defaultRestartAlgorithms_ !=
null; }
1604 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1605 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1607 defaultRestartAlgorithms_ =
null;
1611 public const int RestartPeriodFieldNumber = 30;
1612 private readonly
static int RestartPeriodDefaultValue = 50;
1614 private int restartPeriod_;
1619 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1620 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1622 get {
if ((_hasBits0 & 4096) != 0) {
return restartPeriod_; }
else {
return RestartPeriodDefaultValue; } }
1625 restartPeriod_ = value;
1629 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1630 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1631 public bool HasRestartPeriod {
1632 get {
return (_hasBits0 & 4096) != 0; }
1635 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1636 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1642 public const int RestartRunningWindowSizeFieldNumber = 62;
1643 private readonly
static int RestartRunningWindowSizeDefaultValue = 50;
1645 private int restartRunningWindowSize_;
1649 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1650 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1652 get {
if ((_hasBits1 & 128) != 0) {
return restartRunningWindowSize_; }
else {
return RestartRunningWindowSizeDefaultValue; } }
1655 restartRunningWindowSize_ = value;
1659 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1660 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1661 public bool HasRestartRunningWindowSize {
1662 get {
return (_hasBits1 & 128) != 0; }
1665 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1666 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1672 public const int RestartDlAverageRatioFieldNumber = 63;
1673 private readonly
static double RestartDlAverageRatioDefaultValue = 1D;
1675 private double restartDlAverageRatio_;
1680 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1681 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1683 get {
if ((_hasBits1 & 256) != 0) {
return restartDlAverageRatio_; }
else {
return RestartDlAverageRatioDefaultValue; } }
1686 restartDlAverageRatio_ = value;
1690 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1691 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1692 public bool HasRestartDlAverageRatio {
1693 get {
return (_hasBits1 & 256) != 0; }
1696 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1697 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1703 public const int RestartLbdAverageRatioFieldNumber = 71;
1704 private readonly
static double RestartLbdAverageRatioDefaultValue = 1D;
1706 private double restartLbdAverageRatio_;
1707 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1708 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1710 get {
if ((_hasBits1 & 32768) != 0) {
return restartLbdAverageRatio_; }
else {
return RestartLbdAverageRatioDefaultValue; } }
1713 restartLbdAverageRatio_ = value;
1717 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1718 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1719 public bool HasRestartLbdAverageRatio {
1720 get {
return (_hasBits1 & 32768) != 0; }
1723 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1724 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1726 _hasBits1 &= ~32768;
1730 public const int UseBlockingRestartFieldNumber = 64;
1731 private readonly
static bool UseBlockingRestartDefaultValue =
false;
1733 private bool useBlockingRestart_;
1739 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1740 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1742 get {
if ((_hasBits1 & 512) != 0) {
return useBlockingRestart_; }
else {
return UseBlockingRestartDefaultValue; } }
1745 useBlockingRestart_ = value;
1749 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1750 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1751 public bool HasUseBlockingRestart {
1752 get {
return (_hasBits1 & 512) != 0; }
1755 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1756 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1762 public const int BlockingRestartWindowSizeFieldNumber = 65;
1763 private readonly
static int BlockingRestartWindowSizeDefaultValue = 5000;
1765 private int blockingRestartWindowSize_;
1766 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1767 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1769 get {
if ((_hasBits1 & 1024) != 0) {
return blockingRestartWindowSize_; }
else {
return BlockingRestartWindowSizeDefaultValue; } }
1772 blockingRestartWindowSize_ = value;
1776 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1777 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1778 public bool HasBlockingRestartWindowSize {
1779 get {
return (_hasBits1 & 1024) != 0; }
1782 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1783 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1789 public const int BlockingRestartMultiplierFieldNumber = 66;
1790 private readonly
static double BlockingRestartMultiplierDefaultValue = 1.4D;
1792 private double blockingRestartMultiplier_;
1793 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1794 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1796 get {
if ((_hasBits1 & 2048) != 0) {
return blockingRestartMultiplier_; }
else {
return BlockingRestartMultiplierDefaultValue; } }
1799 blockingRestartMultiplier_ = value;
1803 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1804 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1805 public bool HasBlockingRestartMultiplier {
1806 get {
return (_hasBits1 & 2048) != 0; }
1809 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1810 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1816 public const int NumConflictsBeforeStrategyChangesFieldNumber = 68;
1817 private readonly
static int NumConflictsBeforeStrategyChangesDefaultValue = 0;
1819 private int numConflictsBeforeStrategyChanges_;
1825 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1826 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1828 get {
if ((_hasBits1 & 8192) != 0) {
return numConflictsBeforeStrategyChanges_; }
else {
return NumConflictsBeforeStrategyChangesDefaultValue; } }
1831 numConflictsBeforeStrategyChanges_ = value;
1835 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1836 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1837 public bool HasNumConflictsBeforeStrategyChanges {
1838 get {
return (_hasBits1 & 8192) != 0; }
1841 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1842 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1848 public const int StrategyChangeIncreaseRatioFieldNumber = 69;
1849 private readonly
static double StrategyChangeIncreaseRatioDefaultValue = 0D;
1851 private double strategyChangeIncreaseRatio_;
1856 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1857 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1859 get {
if ((_hasBits1 & 16384) != 0) {
return strategyChangeIncreaseRatio_; }
else {
return StrategyChangeIncreaseRatioDefaultValue; } }
1862 strategyChangeIncreaseRatio_ = value;
1866 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1867 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1868 public bool HasStrategyChangeIncreaseRatio {
1869 get {
return (_hasBits1 & 16384) != 0; }
1872 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1873 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1875 _hasBits1 &= ~16384;
1879 public const int MaxTimeInSecondsFieldNumber = 36;
1880 private readonly
static double MaxTimeInSecondsDefaultValue =
double.PositiveInfinity;
1882 private double maxTimeInSeconds_;
1887 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1888 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1890 get {
if ((_hasBits0 & 131072) != 0) {
return maxTimeInSeconds_; }
else {
return MaxTimeInSecondsDefaultValue; } }
1892 _hasBits0 |= 131072;
1893 maxTimeInSeconds_ = value;
1897 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1898 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1899 public bool HasMaxTimeInSeconds {
1900 get {
return (_hasBits0 & 131072) != 0; }
1903 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1904 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1906 _hasBits0 &= ~131072;
1910 public const int MaxDeterministicTimeFieldNumber = 67;
1911 private readonly
static double MaxDeterministicTimeDefaultValue =
double.PositiveInfinity;
1913 private double maxDeterministicTime_;
1919 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1920 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1922 get {
if ((_hasBits1 & 4096) != 0) {
return maxDeterministicTime_; }
else {
return MaxDeterministicTimeDefaultValue; } }
1925 maxDeterministicTime_ = value;
1929 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1930 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1931 public bool HasMaxDeterministicTime {
1932 get {
return (_hasBits1 & 4096) != 0; }
1935 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1936 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1942 public const int MaxNumDeterministicBatchesFieldNumber = 291;
1943 private readonly
static int MaxNumDeterministicBatchesDefaultValue = 0;
1945 private int maxNumDeterministicBatches_;
1950 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1951 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1953 get {
if ((_hasBits7 & 1024) != 0) {
return maxNumDeterministicBatches_; }
else {
return MaxNumDeterministicBatchesDefaultValue; } }
1956 maxNumDeterministicBatches_ = value;
1960 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1961 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1962 public bool HasMaxNumDeterministicBatches {
1963 get {
return (_hasBits7 & 1024) != 0; }
1966 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1967 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1973 public const int MaxNumberOfConflictsFieldNumber = 37;
1974 private readonly
static long MaxNumberOfConflictsDefaultValue = 9223372036854775807L;
1976 private long maxNumberOfConflicts_;
1986 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1987 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1989 get {
if ((_hasBits0 & 262144) != 0) {
return maxNumberOfConflicts_; }
else {
return MaxNumberOfConflictsDefaultValue; } }
1991 _hasBits0 |= 262144;
1992 maxNumberOfConflicts_ = value;
1996 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1997 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1999 get {
return (_hasBits0 & 262144) != 0; }
2002 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2003 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2004 public void ClearMaxNumberOfConflicts() {
2005 _hasBits0 &= ~262144;
2009 public const int MaxMemoryInMbFieldNumber = 40;
2010 private readonly
static long MaxMemoryInMbDefaultValue = 10000L;
2012 private long maxMemoryInMb_;
2021 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2022 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2024 get {
if ((_hasBits0 & 524288) != 0) {
return maxMemoryInMb_; }
else {
return MaxMemoryInMbDefaultValue; } }
2026 _hasBits0 |= 524288;
2027 maxMemoryInMb_ = value;
2031 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2032 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2034 get {
return (_hasBits0 & 524288) != 0; }
2037 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2038 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2039 public void ClearMaxMemoryInMb() {
2040 _hasBits0 &= ~524288;
2044 public const int AbsoluteGapLimitFieldNumber = 159;
2045 private readonly
static double AbsoluteGapLimitDefaultValue = 0.0001D;
2047 private double absoluteGapLimit_;
2068 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2069 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2071 get {
if ((_hasBits3 & 33554432) != 0) {
return absoluteGapLimit_; }
else {
return AbsoluteGapLimitDefaultValue; } }
2073 _hasBits3 |= 33554432;
2074 absoluteGapLimit_ = value;
2078 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2079 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2080 public bool HasAbsoluteGapLimit {
2081 get {
return (_hasBits3 & 33554432) != 0; }
2084 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2085 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2086 public void ClearAbsoluteGapLimit() {
2087 _hasBits3 &= ~33554432;
2092 private readonly
static double RelativeGapLimitDefaultValue = 0D;
2094 private double relativeGapLimit_;
2095 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2096 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2098 get {
if ((_hasBits3 & 67108864) != 0) {
return relativeGapLimit_; }
else {
return RelativeGapLimitDefaultValue; } }
2100 _hasBits3 |= 67108864;
2101 relativeGapLimit_ = value;
2105 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2106 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2107 public bool HasRelativeGapLimit {
2108 get {
return (_hasBits3 & 67108864) != 0; }
2111 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2112 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2113 public void ClearRelativeGapLimit() {
2114 _hasBits3 &= ~67108864;
2119 private readonly
static int RandomSeedDefaultValue = 1;
2121 private int randomSeed_;
2131 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2132 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2134 get {
if ((_hasBits0 & 8192) != 0) {
return randomSeed_; }
else {
return RandomSeedDefaultValue; } }
2137 randomSeed_ = value;
2141 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2142 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2143 public bool HasRandomSeed {
2144 get {
return (_hasBits0 & 8192) != 0; }
2147 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2148 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2149 public void ClearRandomSeed() {
2154 public const int PermuteVariableRandomlyFieldNumber = 178;
2155 private readonly
static bool PermuteVariableRandomlyDefaultValue =
false;
2157 private bool permuteVariableRandomly_;
2164 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2165 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2167 get {
if ((_hasBits4 & 2048) != 0) {
return permuteVariableRandomly_; }
else {
return PermuteVariableRandomlyDefaultValue; } }
2170 permuteVariableRandomly_ = value;
2174 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2175 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2176 public bool HasPermuteVariableRandomly {
2177 get {
return (_hasBits4 & 2048) != 0; }
2180 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2181 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2182 public void ClearPermuteVariableRandomly() {
2187 public const int PermutePresolveConstraintOrderFieldNumber = 179;
2188 private readonly
static bool PermutePresolveConstraintOrderDefaultValue =
false;
2190 private bool permutePresolveConstraintOrder_;
2191 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2192 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2194 get {
if ((_hasBits4 & 4096) != 0) {
return permutePresolveConstraintOrder_; }
else {
return PermutePresolveConstraintOrderDefaultValue; } }
2197 permutePresolveConstraintOrder_ = value;
2201 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2202 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2203 public bool HasPermutePresolveConstraintOrder {
2204 get {
return (_hasBits4 & 4096) != 0; }
2207 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2208 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2209 public void ClearPermutePresolveConstraintOrder() {
2214 public const int UseAbslRandomFieldNumber = 180;
2215 private readonly
static bool UseAbslRandomDefaultValue =
false;
2217 private bool useAbslRandom_;
2218 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2219 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2221 get {
if ((_hasBits4 & 8192) != 0) {
return useAbslRandom_; }
else {
return UseAbslRandomDefaultValue; } }
2224 useAbslRandom_ = value;
2228 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2229 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2230 public bool HasUseAbslRandom {
2231 get {
return (_hasBits4 & 8192) != 0; }
2234 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2235 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2236 public void ClearUseAbslRandom() {
2241 public const int LogSearchProgressFieldNumber = 41;
2242 private readonly
static bool LogSearchProgressDefaultValue =
false;
2244 private bool logSearchProgress_;
2250 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2251 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2253 get {
if ((_hasBits0 & 1048576) != 0) {
return logSearchProgress_; }
else {
return LogSearchProgressDefaultValue; } }
2255 _hasBits0 |= 1048576;
2256 logSearchProgress_ = value;
2260 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2261 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2262 public bool HasLogSearchProgress {
2263 get {
return (_hasBits0 & 1048576) != 0; }
2266 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2267 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2268 public void ClearLogSearchProgress() {
2269 _hasBits0 &= ~1048576;
2273 public const int LogSubsolverStatisticsFieldNumber = 189;
2274 private readonly
static bool LogSubsolverStatisticsDefaultValue =
false;
2276 private bool logSubsolverStatistics_;
2283 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2284 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2286 get {
if ((_hasBits4 & 1048576) != 0) {
return logSubsolverStatistics_; }
else {
return LogSubsolverStatisticsDefaultValue; } }
2288 _hasBits4 |= 1048576;
2289 logSubsolverStatistics_ = value;
2293 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2294 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2295 public bool HasLogSubsolverStatistics {
2296 get {
return (_hasBits4 & 1048576) != 0; }
2299 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2300 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2301 public void ClearLogSubsolverStatistics() {
2302 _hasBits4 &= ~1048576;
2306 public const int LogPrefixFieldNumber = 185;
2307 private readonly
static string LogPrefixDefaultValue =
"";
2309 private string logPrefix_;
2313 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2314 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2316 get {
return logPrefix_ ?? LogPrefixDefaultValue; }
2318 logPrefix_ = pb::ProtoPreconditions.CheckNotNull(value,
"value");
2322 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2323 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2324 public bool HasLogPrefix {
2325 get {
return logPrefix_ !=
null; }
2328 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2329 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2335 public const int LogToStdoutFieldNumber = 186;
2336 private readonly
static bool LogToStdoutDefaultValue =
true;
2338 private bool logToStdout_;
2342 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2343 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2345 get {
if ((_hasBits4 & 131072) != 0) {
return logToStdout_; }
else {
return LogToStdoutDefaultValue; } }
2347 _hasBits4 |= 131072;
2348 logToStdout_ = value;
2352 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2353 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2354 public bool HasLogToStdout {
2355 get {
return (_hasBits4 & 131072) != 0; }
2358 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2359 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2360 public void ClearLogToStdout() {
2361 _hasBits4 &= ~131072;
2365 public const int LogToResponseFieldNumber = 187;
2366 private readonly
static bool LogToResponseDefaultValue =
false;
2368 private bool logToResponse_;
2372 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2373 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2375 get {
if ((_hasBits4 & 262144) != 0) {
return logToResponse_; }
else {
return LogToResponseDefaultValue; } }
2377 _hasBits4 |= 262144;
2378 logToResponse_ = value;
2382 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2383 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2384 public bool HasLogToResponse {
2385 get {
return (_hasBits4 & 262144) != 0; }
2388 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2389 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2390 public void ClearLogToResponse() {
2391 _hasBits4 &= ~262144;
2395 public const int UsePbResolutionFieldNumber = 43;
2396 private readonly
static bool UsePbResolutionDefaultValue =
false;
2398 private bool usePbResolution_;
2405 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2406 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2408 get {
if ((_hasBits0 & 2097152) != 0) {
return usePbResolution_; }
else {
return UsePbResolutionDefaultValue; } }
2410 _hasBits0 |= 2097152;
2411 usePbResolution_ = value;
2415 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2416 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2417 public bool HasUsePbResolution {
2418 get {
return (_hasBits0 & 2097152) != 0; }
2421 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2422 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2423 public void ClearUsePbResolution() {
2424 _hasBits0 &= ~2097152;
2428 public const int MinimizeReductionDuringPbResolutionFieldNumber = 48;
2429 private readonly
static bool MinimizeReductionDuringPbResolutionDefaultValue =
false;
2431 private bool minimizeReductionDuringPbResolution_;
2438 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2439 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2441 get {
if ((_hasBits0 & 67108864) != 0) {
return minimizeReductionDuringPbResolution_; }
else {
return MinimizeReductionDuringPbResolutionDefaultValue; } }
2443 _hasBits0 |= 67108864;
2444 minimizeReductionDuringPbResolution_ = value;
2448 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2449 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2450 public bool HasMinimizeReductionDuringPbResolution {
2451 get {
return (_hasBits0 & 67108864) != 0; }
2454 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2455 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2456 public void ClearMinimizeReductionDuringPbResolution() {
2457 _hasBits0 &= ~67108864;
2461 public const int CountAssumptionLevelsInLbdFieldNumber = 49;
2462 private readonly
static bool CountAssumptionLevelsInLbdDefaultValue =
true;
2464 private bool countAssumptionLevelsInLbd_;
2476 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2477 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2479 get {
if ((_hasBits0 & 134217728) != 0) {
return countAssumptionLevelsInLbd_; }
else {
return CountAssumptionLevelsInLbdDefaultValue; } }
2481 _hasBits0 |= 134217728;
2482 countAssumptionLevelsInLbd_ = value;
2486 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2487 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2488 public bool HasCountAssumptionLevelsInLbd {
2489 get {
return (_hasBits0 & 134217728) != 0; }
2492 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2493 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2495 _hasBits0 &= ~134217728;
2499 public const int PresolveBveThresholdFieldNumber = 54;
2500 private readonly
static int PresolveBveThresholdDefaultValue = 500;
2502 private int presolveBveThreshold_;
2508 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2509 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2511 get {
if ((_hasBits1 & 1) != 0) {
return presolveBveThreshold_; }
else {
return PresolveBveThresholdDefaultValue; } }
2514 presolveBveThreshold_ = value;
2518 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2519 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2520 public bool HasPresolveBveThreshold {
2521 get {
return (_hasBits1 & 1) != 0; }
2524 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2525 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2531 public const int PresolveBveClauseWeightFieldNumber = 55;
2532 private readonly
static int PresolveBveClauseWeightDefaultValue = 3;
2534 private int presolveBveClauseWeight_;
2539 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2540 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2542 get {
if ((_hasBits1 & 2) != 0) {
return presolveBveClauseWeight_; }
else {
return PresolveBveClauseWeightDefaultValue; } }
2545 presolveBveClauseWeight_ = value;
2549 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2550 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2551 public bool HasPresolveBveClauseWeight {
2552 get {
return (_hasBits1 & 2) != 0; }
2555 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2556 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2562 public const int ProbingDeterministicTimeLimitFieldNumber = 226;
2563 private readonly
static double ProbingDeterministicTimeLimitDefaultValue = 1D;
2565 private double probingDeterministicTimeLimit_;
2573 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2574 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2576 get {
if ((_hasBits5 & 131072) != 0) {
return probingDeterministicTimeLimit_; }
else {
return ProbingDeterministicTimeLimitDefaultValue; } }
2578 _hasBits5 |= 131072;
2579 probingDeterministicTimeLimit_ = value;
2583 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2584 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2585 public bool HasProbingDeterministicTimeLimit {
2586 get {
return (_hasBits5 & 131072) != 0; }
2589 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2590 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2592 _hasBits5 &= ~131072;
2596 public const int PresolveProbingDeterministicTimeLimitFieldNumber = 57;
2597 private readonly
static double PresolveProbingDeterministicTimeLimitDefaultValue = 30D;
2599 private double presolveProbingDeterministicTimeLimit_;
2600 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2601 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2603 get {
if ((_hasBits1 & 8) != 0) {
return presolveProbingDeterministicTimeLimit_; }
else {
return PresolveProbingDeterministicTimeLimitDefaultValue; } }
2606 presolveProbingDeterministicTimeLimit_ = value;
2610 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2611 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2613 get {
return (_hasBits1 & 8) != 0; }
2616 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2617 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2623 public const int PresolveBlockedClauseFieldNumber = 88;
2624 private readonly
static bool PresolveBlockedClauseDefaultValue =
true;
2626 private bool presolveBlockedClause_;
2631 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2632 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2634 get {
if ((_hasBits1 & -2147483648) != 0) {
return presolveBlockedClause_; }
else {
return PresolveBlockedClauseDefaultValue; } }
2636 _hasBits1 |= -2147483648;
2637 presolveBlockedClause_ = value;
2641 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2642 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2643 public bool HasPresolveBlockedClause {
2644 get {
return (_hasBits1 & -2147483648) != 0; }
2647 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2648 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2650 _hasBits1 &= ~-2147483648;
2654 public const int PresolveUseBvaFieldNumber = 72;
2655 private readonly
static bool PresolveUseBvaDefaultValue =
true;
2657 private bool presolveUseBva_;
2661 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2662 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2664 get {
if ((_hasBits1 & 65536) != 0) {
return presolveUseBva_; }
else {
return PresolveUseBvaDefaultValue; } }
2667 presolveUseBva_ = value;
2671 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2672 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2673 public bool HasPresolveUseBva {
2674 get {
return (_hasBits1 & 65536) != 0; }
2677 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2678 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2680 _hasBits1 &= ~65536;
2684 public const int PresolveBvaThresholdFieldNumber = 73;
2685 private readonly
static int PresolveBvaThresholdDefaultValue = 1;
2687 private int presolveBvaThreshold_;
2694 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2695 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2697 get {
if ((_hasBits1 & 131072) != 0) {
return presolveBvaThreshold_; }
else {
return PresolveBvaThresholdDefaultValue; } }
2699 _hasBits1 |= 131072;
2700 presolveBvaThreshold_ = value;
2704 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2705 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2706 public bool HasPresolveBvaThreshold {
2707 get {
return (_hasBits1 & 131072) != 0; }
2710 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2711 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2713 _hasBits1 &= ~131072;
2717 public const int MaxPresolveIterationsFieldNumber = 138;
2718 private readonly
static int MaxPresolveIterationsDefaultValue = 3;
2720 private int maxPresolveIterations_;
2726 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2727 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2729 get {
if ((_hasBits3 & 2048) != 0) {
return maxPresolveIterations_; }
else {
return MaxPresolveIterationsDefaultValue; } }
2732 maxPresolveIterations_ = value;
2736 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2737 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2738 public bool HasMaxPresolveIterations {
2739 get {
return (_hasBits3 & 2048) != 0; }
2742 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2743 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2749 public const int CpModelPresolveFieldNumber = 86;
2750 private readonly
static bool CpModelPresolveDefaultValue =
true;
2752 private bool cpModelPresolve_;
2756 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2757 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2759 get {
if ((_hasBits1 & 536870912) != 0) {
return cpModelPresolve_; }
else {
return CpModelPresolveDefaultValue; } }
2761 _hasBits1 |= 536870912;
2762 cpModelPresolve_ = value;
2766 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2767 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2768 public bool HasCpModelPresolve {
2769 get {
return (_hasBits1 & 536870912) != 0; }
2772 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2773 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2775 _hasBits1 &= ~536870912;
2779 public const int CpModelProbingLevelFieldNumber = 110;
2780 private readonly
static int CpModelProbingLevelDefaultValue = 2;
2782 private int cpModelProbingLevel_;
2786 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2787 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2789 get {
if ((_hasBits2 & 131072) != 0) {
return cpModelProbingLevel_; }
else {
return CpModelProbingLevelDefaultValue; } }
2791 _hasBits2 |= 131072;
2792 cpModelProbingLevel_ = value;
2796 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2797 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2798 public bool HasCpModelProbingLevel {
2799 get {
return (_hasBits2 & 131072) != 0; }
2802 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2803 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2805 _hasBits2 &= ~131072;
2809 public const int CpModelUseSatPresolveFieldNumber = 93;
2810 private readonly
static bool CpModelUseSatPresolveDefaultValue =
true;
2812 private bool cpModelUseSatPresolve_;
2816 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2817 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2819 get {
if ((_hasBits2 & 16) != 0) {
return cpModelUseSatPresolve_; }
else {
return CpModelUseSatPresolveDefaultValue; } }
2822 cpModelUseSatPresolve_ = value;
2826 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2827 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2828 public bool HasCpModelUseSatPresolve {
2829 get {
return (_hasBits2 & 16) != 0; }
2832 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2833 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2839 public const int RemoveFixedVariablesEarlyFieldNumber = 310;
2840 private readonly
static bool RemoveFixedVariablesEarlyDefaultValue =
true;
2842 private bool removeFixedVariablesEarly_;
2849 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2850 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2852 get {
if ((_hasBits7 & 268435456) != 0) {
return removeFixedVariablesEarly_; }
else {
return RemoveFixedVariablesEarlyDefaultValue; } }
2854 _hasBits7 |= 268435456;
2855 removeFixedVariablesEarly_ = value;
2859 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2860 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2861 public bool HasRemoveFixedVariablesEarly {
2862 get {
return (_hasBits7 & 268435456) != 0; }
2865 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2866 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2868 _hasBits7 &= ~268435456;
2872 public const int DetectTableWithCostFieldNumber = 216;
2873 private readonly
static bool DetectTableWithCostDefaultValue =
false;
2875 private bool detectTableWithCost_;
2884 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2885 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2887 get {
if ((_hasBits5 & 512) != 0) {
return detectTableWithCost_; }
else {
return DetectTableWithCostDefaultValue; } }
2890 detectTableWithCost_ = value;
2894 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2895 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2896 public bool HasDetectTableWithCost {
2897 get {
return (_hasBits5 & 512) != 0; }
2900 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2901 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2907 public const int TableCompressionLevelFieldNumber = 217;
2908 private readonly
static int TableCompressionLevelDefaultValue = 2;
2910 private int tableCompressionLevel_;
2917 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2918 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2920 get {
if ((_hasBits5 & 1024) != 0) {
return tableCompressionLevel_; }
else {
return TableCompressionLevelDefaultValue; } }
2923 tableCompressionLevel_ = value;
2927 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2928 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2929 public bool HasTableCompressionLevel {
2930 get {
return (_hasBits5 & 1024) != 0; }
2933 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2934 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2940 public const int ExpandAlldiffConstraintsFieldNumber = 170;
2941 private readonly
static bool ExpandAlldiffConstraintsDefaultValue =
false;
2943 private bool expandAlldiffConstraints_;
2948 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2949 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2951 get {
if ((_hasBits4 & 16) != 0) {
return expandAlldiffConstraints_; }
else {
return ExpandAlldiffConstraintsDefaultValue; } }
2954 expandAlldiffConstraints_ = value;
2958 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2959 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2960 public bool HasExpandAlldiffConstraints {
2961 get {
return (_hasBits4 & 16) != 0; }
2964 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2965 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2971 public const int ExpandReservoirConstraintsFieldNumber = 182;
2972 private readonly
static bool ExpandReservoirConstraintsDefaultValue =
true;
2974 private bool expandReservoirConstraints_;
2979 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2980 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2982 get {
if ((_hasBits4 & 32768) != 0) {
return expandReservoirConstraints_; }
else {
return ExpandReservoirConstraintsDefaultValue; } }
2985 expandReservoirConstraints_ = value;
2989 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2990 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2991 public bool HasExpandReservoirConstraints {
2992 get {
return (_hasBits4 & 32768) != 0; }
2995 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2996 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2998 _hasBits4 &= ~32768;
3002 public const int ExpandReservoirUsingCircuitFieldNumber = 288;
3003 private readonly
static bool ExpandReservoirUsingCircuitDefaultValue =
false;
3005 private bool expandReservoirUsingCircuit_;
3022 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3023 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3025 get {
if ((_hasBits7 & 128) != 0) {
return expandReservoirUsingCircuit_; }
else {
return ExpandReservoirUsingCircuitDefaultValue; } }
3028 expandReservoirUsingCircuit_ = value;
3032 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3033 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3034 public bool HasExpandReservoirUsingCircuit {
3035 get {
return (_hasBits7 & 128) != 0; }
3038 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3039 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3040 public void ClearExpandReservoirUsingCircuit() {
3045 public const int EncodeCumulativeAsReservoirFieldNumber = 287;
3046 private readonly
static bool EncodeCumulativeAsReservoirDefaultValue =
false;
3048 private bool encodeCumulativeAsReservoir_;
3054 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3055 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3057 get {
if ((_hasBits7 & 64) != 0) {
return encodeCumulativeAsReservoir_; }
else {
return EncodeCumulativeAsReservoirDefaultValue; } }
3060 encodeCumulativeAsReservoir_ = value;
3064 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3065 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3066 public bool HasEncodeCumulativeAsReservoir {
3067 get {
return (_hasBits7 & 64) != 0; }
3070 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3071 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3072 public void ClearEncodeCumulativeAsReservoir() {
3077 public const int MaxLinMaxSizeForExpansionFieldNumber = 280;
3078 private readonly
static int MaxLinMaxSizeForExpansionDefaultValue = 0;
3080 private int maxLinMaxSizeForExpansion_;
3088 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3089 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3091 get {
if ((_hasBits6 & -2147483648) != 0) {
return maxLinMaxSizeForExpansion_; }
else {
return MaxLinMaxSizeForExpansionDefaultValue; } }
3093 _hasBits6 |= -2147483648;
3094 maxLinMaxSizeForExpansion_ = value;
3098 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3099 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3100 public bool HasMaxLinMaxSizeForExpansion {
3101 get {
return (_hasBits6 & -2147483648) != 0; }
3104 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3105 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3106 public void ClearMaxLinMaxSizeForExpansion() {
3107 _hasBits6 &= ~-2147483648;
3111 public const int DisableConstraintExpansionFieldNumber = 181;
3112 private readonly
static bool DisableConstraintExpansionDefaultValue =
false;
3114 private bool disableConstraintExpansion_;
3119 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3120 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3122 get {
if ((_hasBits4 & 16384) != 0) {
return disableConstraintExpansion_; }
else {
return DisableConstraintExpansionDefaultValue; } }
3125 disableConstraintExpansion_ = value;
3129 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3130 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3132 get {
return (_hasBits4 & 16384) != 0; }
3135 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3136 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3137 public void ClearDisableConstraintExpansion() {
3138 _hasBits4 &= ~16384;
3142 public const int EncodeComplexLinearConstraintWithIntegerFieldNumber = 223;
3143 private readonly
static bool EncodeComplexLinearConstraintWithIntegerDefaultValue =
false;
3145 private bool encodeComplexLinearConstraintWithInteger_;
3150 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3151 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3153 get {
if ((_hasBits5 & 16384) != 0) {
return encodeComplexLinearConstraintWithInteger_; }
else {
return EncodeComplexLinearConstraintWithIntegerDefaultValue; } }
3156 encodeComplexLinearConstraintWithInteger_ = value;
3160 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3161 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3163 get {
return (_hasBits5 & 16384) != 0; }
3166 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3167 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3168 public void ClearEncodeComplexLinearConstraintWithInteger() {
3169 _hasBits5 &= ~16384;
3173 public const int MergeNoOverlapWorkLimitFieldNumber = 145;
3174 private readonly
static double MergeNoOverlapWorkLimitDefaultValue = 1e+12D;
3176 private double mergeNoOverlapWorkLimit_;
3184 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3185 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3187 get {
if ((_hasBits3 & 8192) != 0) {
return mergeNoOverlapWorkLimit_; }
else {
return MergeNoOverlapWorkLimitDefaultValue; } }
3190 mergeNoOverlapWorkLimit_ = value;
3194 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3195 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3196 public bool HasMergeNoOverlapWorkLimit {
3197 get {
return (_hasBits3 & 8192) != 0; }
3200 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3201 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3202 public void ClearMergeNoOverlapWorkLimit() {
3207 public const int MergeAtMostOneWorkLimitFieldNumber = 146;
3208 private readonly
static double MergeAtMostOneWorkLimitDefaultValue = 1e+08D;
3210 private double mergeAtMostOneWorkLimit_;
3211 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3212 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3213 public double MergeAtMostOneWorkLimit {
3214 get {
if ((_hasBits3 & 16384) != 0) {
return mergeAtMostOneWorkLimit_; }
else {
return MergeAtMostOneWorkLimitDefaultValue; } }
3217 mergeAtMostOneWorkLimit_ = value;
3221 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3222 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3224 get {
return (_hasBits3 & 16384) != 0; }
3227 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3228 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3229 public void ClearMergeAtMostOneWorkLimit() {
3230 _hasBits3 &= ~16384;
3234 public const int PresolveSubstitutionLevelFieldNumber = 147;
3235 private readonly
static int PresolveSubstitutionLevelDefaultValue = 1;
3237 private int presolveSubstitutionLevel_;
3244 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3245 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3247 get {
if ((_hasBits3 & 32768) != 0) {
return presolveSubstitutionLevel_; }
else {
return PresolveSubstitutionLevelDefaultValue; } }
3250 presolveSubstitutionLevel_ = value;
3254 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3255 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3256 public bool HasPresolveSubstitutionLevel {
3257 get {
return (_hasBits3 & 32768) != 0; }
3260 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3261 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3262 public void ClearPresolveSubstitutionLevel() {
3263 _hasBits3 &= ~32768;
3267 public const int PresolveExtractIntegerEnforcementFieldNumber = 174;
3268 private readonly
static bool PresolveExtractIntegerEnforcementDefaultValue =
false;
3270 private bool presolveExtractIntegerEnforcement_;
3279 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3280 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3282 get {
if ((_hasBits4 & 128) != 0) {
return presolveExtractIntegerEnforcement_; }
else {
return PresolveExtractIntegerEnforcementDefaultValue; } }
3285 presolveExtractIntegerEnforcement_ = value;
3289 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3290 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3291 public bool HasPresolveExtractIntegerEnforcement {
3292 get {
return (_hasBits4 & 128) != 0; }
3295 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3296 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3297 public void ClearPresolveExtractIntegerEnforcement() {
3302 public const int PresolveInclusionWorkLimitFieldNumber = 201;
3303 private readonly
static long PresolveInclusionWorkLimitDefaultValue = 100000000L;
3305 private long presolveInclusionWorkLimit_;
3315 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3316 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3318 get {
if ((_hasBits5 & 1) != 0) {
return presolveInclusionWorkLimit_; }
else {
return PresolveInclusionWorkLimitDefaultValue; } }
3321 presolveInclusionWorkLimit_ = value;
3325 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3326 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3327 public bool HasPresolveInclusionWorkLimit {
3328 get {
return (_hasBits5 & 1) != 0; }
3331 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3332 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3333 public void ClearPresolveInclusionWorkLimit() {
3339 private readonly
static bool IgnoreNamesDefaultValue =
true;
3341 private bool ignoreNames_;
3345 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3346 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3348 get {
if ((_hasBits5 & 2) != 0) {
return ignoreNames_; }
else {
return IgnoreNamesDefaultValue; } }
3351 ignoreNames_ = value;
3355 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3356 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3358 get {
return (_hasBits5 & 2) != 0; }
3361 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3362 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3363 public void ClearIgnoreNames() {
3369 private readonly
static bool InferAllDiffsDefaultValue =
true;
3371 private bool inferAllDiffs_;
3382 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3383 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3385 get {
if ((_hasBits5 & 8388608) != 0) {
return inferAllDiffs_; }
else {
return InferAllDiffsDefaultValue; } }
3387 _hasBits5 |= 8388608;
3388 inferAllDiffs_ = value;
3392 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3393 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3394 public bool HasInferAllDiffs {
3395 get {
return (_hasBits5 & 8388608) != 0; }
3398 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3399 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3400 public void ClearInferAllDiffs() {
3401 _hasBits5 &= ~8388608;
3406 private readonly
static bool FindBigLinearOverlapDefaultValue =
true;
3408 private bool findBigLinearOverlap_;
3415 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3416 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3418 get {
if ((_hasBits5 & 16777216) != 0) {
return findBigLinearOverlap_; }
else {
return FindBigLinearOverlapDefaultValue; } }
3420 _hasBits5 |= 16777216;
3421 findBigLinearOverlap_ = value;
3425 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3426 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3428 get {
return (_hasBits5 & 16777216) != 0; }
3431 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3432 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3433 public void ClearFindBigLinearOverlap() {
3434 _hasBits5 &= ~16777216;
3439 private readonly
static bool UseSatInprocessingDefaultValue =
true;
3441 private bool useSatInprocessing_;
3446 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3447 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3449 get {
if ((_hasBits3 & 536870912) != 0) {
return useSatInprocessing_; }
else {
return UseSatInprocessingDefaultValue; } }
3451 _hasBits3 |= 536870912;
3452 useSatInprocessing_ = value;
3456 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3457 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3459 get {
return (_hasBits3 & 536870912) != 0; }
3462 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3463 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3464 public void ClearUseSatInprocessing() {
3465 _hasBits3 &= ~536870912;
3470 private readonly
static double InprocessingDtimeRatioDefaultValue = 0.2D;
3472 private double inprocessingDtimeRatio_;
3478 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3479 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3481 get {
if ((_hasBits6 & 16777216) != 0) {
return inprocessingDtimeRatio_; }
else {
return InprocessingDtimeRatioDefaultValue; } }
3483 _hasBits6 |= 16777216;
3484 inprocessingDtimeRatio_ = value;
3488 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3489 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3491 get {
return (_hasBits6 & 16777216) != 0; }
3494 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3495 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3496 public void ClearInprocessingDtimeRatio() {
3497 _hasBits6 &= ~16777216;
3502 private readonly
static double InprocessingProbingDtimeDefaultValue = 1D;
3504 private double inprocessingProbingDtime_;
3508 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3509 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3511 get {
if ((_hasBits6 & 33554432) != 0) {
return inprocessingProbingDtime_; }
else {
return InprocessingProbingDtimeDefaultValue; } }
3513 _hasBits6 |= 33554432;
3514 inprocessingProbingDtime_ = value;
3518 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3519 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3520 public bool HasInprocessingProbingDtime {
3521 get {
return (_hasBits6 & 33554432) != 0; }
3524 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3525 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3526 public void ClearInprocessingProbingDtime() {
3527 _hasBits6 &= ~33554432;
3532 private readonly
static double InprocessingMinimizationDtimeDefaultValue = 1D;
3534 private double inprocessingMinimizationDtime_;
3547 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3548 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3550 get {
if ((_hasBits6 & 67108864) != 0) {
return inprocessingMinimizationDtime_; }
else {
return InprocessingMinimizationDtimeDefaultValue; } }
3552 _hasBits6 |= 67108864;
3553 inprocessingMinimizationDtime_ = value;
3557 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3558 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3559 public bool HasInprocessingMinimizationDtime {
3560 get {
return (_hasBits6 & 67108864) != 0; }
3563 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3564 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3565 public void ClearInprocessingMinimizationDtime() {
3566 _hasBits6 &= ~67108864;
3570 public const int InprocessingMinimizationUseConflictAnalysisFieldNumber = 297;
3571 private readonly
static bool InprocessingMinimizationUseConflictAnalysisDefaultValue =
true;
3573 private bool inprocessingMinimizationUseConflictAnalysis_;
3574 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3575 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3577 get {
if ((_hasBits7 & 32768) != 0) {
return inprocessingMinimizationUseConflictAnalysis_; }
else {
return InprocessingMinimizationUseConflictAnalysisDefaultValue; } }
3580 inprocessingMinimizationUseConflictAnalysis_ = value;
3584 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3585 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3586 public bool HasInprocessingMinimizationUseConflictAnalysis {
3587 get {
return (_hasBits7 & 32768) != 0; }
3590 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3591 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3593 _hasBits7 &= ~32768;
3597 public const int InprocessingMinimizationUseAllOrderingsFieldNumber = 298;
3598 private readonly
static bool InprocessingMinimizationUseAllOrderingsDefaultValue =
false;
3600 private bool inprocessingMinimizationUseAllOrderings_;
3601 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3602 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3604 get {
if ((_hasBits7 & 65536) != 0) {
return inprocessingMinimizationUseAllOrderings_; }
else {
return InprocessingMinimizationUseAllOrderingsDefaultValue; } }
3607 inprocessingMinimizationUseAllOrderings_ = value;
3611 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3612 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3613 public bool HasInprocessingMinimizationUseAllOrderings {
3614 get {
return (_hasBits7 & 65536) != 0; }
3617 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3618 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3620 _hasBits7 &= ~65536;
3624 public const int NumWorkersFieldNumber = 206;
3625 private readonly
static int NumWorkersDefaultValue = 0;
3627 private int numWorkers_;
3644 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3645 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3647 get {
if ((_hasBits5 & 32) != 0) {
return numWorkers_; }
else {
return NumWorkersDefaultValue; } }
3650 numWorkers_ = value;
3654 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3655 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3656 public bool HasNumWorkers {
3657 get {
return (_hasBits5 & 32) != 0; }
3660 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3661 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3662 public void ClearNumWorkers() {
3667 public const int NumSearchWorkersFieldNumber = 100;
3668 private readonly
static int NumSearchWorkersDefaultValue = 0;
3670 private int numSearchWorkers_;
3671 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3672 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3674 get {
if ((_hasBits2 & 512) != 0) {
return numSearchWorkers_; }
else {
return NumSearchWorkersDefaultValue; } }
3677 numSearchWorkers_ = value;
3681 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3682 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3684 get {
return (_hasBits2 & 512) != 0; }
3687 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3688 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3695 private readonly
static int NumFullSubsolversDefaultValue = 0;
3697 private int numFullSubsolvers_;
3705 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3706 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3708 get {
if ((_hasBits7 & 4096) != 0) {
return numFullSubsolvers_; }
else {
return NumFullSubsolversDefaultValue; } }
3711 numFullSubsolvers_ = value;
3715 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3716 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3718 get {
return (_hasBits7 & 4096) != 0; }
3721 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3722 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3723 public void ClearNumFullSubsolvers() {
3728 public const int SubsolversFieldNumber = 207;
3729 private static readonly pb::FieldCodec<string> _repeated_subsolvers_codec
3730 = pb::FieldCodec.ForString(1658);
3731 private readonly pbc::RepeatedField<string> subsolvers_ =
new pbc::RepeatedField<string>();
3759 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3760 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3761 public pbc::RepeatedField<string>
Subsolvers {
3762 get {
return subsolvers_; }
3766 public const int ExtraSubsolversFieldNumber = 219;
3767 private static readonly pb::FieldCodec<string> _repeated_extraSubsolvers_codec
3768 = pb::FieldCodec.ForString(1754);
3769 private readonly pbc::RepeatedField<string> extraSubsolvers_ =
new pbc::RepeatedField<string>();
3774 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3775 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3776 public pbc::RepeatedField<string> ExtraSubsolvers {
3777 get {
return extraSubsolvers_; }
3781 public const int IgnoreSubsolversFieldNumber = 209;
3782 private static readonly pb::FieldCodec<string> _repeated_ignoreSubsolvers_codec
3783 = pb::FieldCodec.ForString(1674);
3784 private readonly pbc::RepeatedField<string> ignoreSubsolvers_ =
new pbc::RepeatedField<string>();
3796 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3797 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3799 get {
return ignoreSubsolvers_; }
3803 public const int FilterSubsolversFieldNumber = 293;
3804 private static readonly pb::FieldCodec<string> _repeated_filterSubsolvers_codec
3805 = pb::FieldCodec.ForString(2346);
3806 private readonly pbc::RepeatedField<string> filterSubsolvers_ =
new pbc::RepeatedField<string>();
3807 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3808 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3810 get {
return filterSubsolvers_; }
3814 public const int SubsolverParamsFieldNumber = 210;
3815 private static readonly pb::FieldCodec<global::Google.OrTools.Sat.SatParameters> _repeated_subsolverParams_codec
3817 private readonly pbc::RepeatedField<global::Google.OrTools.Sat.SatParameters> subsolverParams_ =
new pbc::RepeatedField<global::Google.OrTools.Sat.SatParameters>();
3825 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3826 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3828 get {
return subsolverParams_; }
3833 private readonly
static bool InterleaveSearchDefaultValue =
false;
3835 private bool interleaveSearch_;
3844 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3845 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3847 get {
if ((_hasBits3 & 512) != 0) {
return interleaveSearch_; }
else {
return InterleaveSearchDefaultValue; } }
3850 interleaveSearch_ = value;
3854 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3855 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3857 get {
return (_hasBits3 & 512) != 0; }
3860 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3861 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3867 public const int InterleaveBatchSizeFieldNumber = 134;
3868 private readonly
static int InterleaveBatchSizeDefaultValue = 0;
3870 private int interleaveBatchSize_;
3871 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3872 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3873 public int InterleaveBatchSize {
3874 get {
if ((_hasBits3 & 128) != 0) {
return interleaveBatchSize_; }
else {
return InterleaveBatchSizeDefaultValue; } }
3877 interleaveBatchSize_ = value;
3881 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3882 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3883 public bool HasInterleaveBatchSize {
3884 get {
return (_hasBits3 & 128) != 0; }
3887 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3888 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3895 private readonly
static bool ShareObjectiveBoundsDefaultValue =
true;
3897 private bool shareObjectiveBounds_;
3901 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3902 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3904 get {
if ((_hasBits2 & 524288) != 0) {
return shareObjectiveBounds_; }
else {
return ShareObjectiveBoundsDefaultValue; } }
3906 _hasBits2 |= 524288;
3907 shareObjectiveBounds_ = value;
3911 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3912 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3914 get {
return (_hasBits2 & 524288) != 0; }
3917 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3918 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3920 _hasBits2 &= ~524288;
3925 private readonly
static bool ShareLevelZeroBoundsDefaultValue =
true;
3927 private bool shareLevelZeroBounds_;
3931 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3932 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3934 get {
if ((_hasBits2 & 1048576) != 0) {
return shareLevelZeroBounds_; }
else {
return ShareLevelZeroBoundsDefaultValue; } }
3936 _hasBits2 |= 1048576;
3937 shareLevelZeroBounds_ = value;
3941 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3942 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3944 get {
return (_hasBits2 & 1048576) != 0; }
3947 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3948 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3950 _hasBits2 &= ~1048576;
3955 private readonly
static bool ShareBinaryClausesDefaultValue =
true;
3957 private bool shareBinaryClauses_;
3961 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3962 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3964 get {
if ((_hasBits5 & 4) != 0) {
return shareBinaryClauses_; }
else {
return ShareBinaryClausesDefaultValue; } }
3967 shareBinaryClauses_ = value;
3971 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3972 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3974 get {
return (_hasBits5 & 4) != 0; }
3977 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3978 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3985 private readonly
static bool ShareGlueClausesDefaultValue =
false;
3987 private bool shareGlueClauses_;
3992 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3993 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3995 get {
if ((_hasBits7 & 16) != 0) {
return shareGlueClauses_; }
else {
return ShareGlueClausesDefaultValue; } }
3998 shareGlueClauses_ = value;
4002 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4003 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4005 get {
return (_hasBits7 & 16) != 0; }
4008 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4009 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4016 private readonly
static bool MinimizeSharedClausesDefaultValue =
true;
4018 private bool minimizeSharedClauses_;
4023 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4024 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4026 get {
if ((_hasBits7 & 262144) != 0) {
return minimizeSharedClauses_; }
else {
return MinimizeSharedClausesDefaultValue; } }
4028 _hasBits7 |= 262144;
4029 minimizeSharedClauses_ = value;
4033 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4034 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4036 get {
return (_hasBits7 & 262144) != 0; }
4039 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4040 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4042 _hasBits7 &= ~262144;
4047 private readonly
static bool DebugPostsolveWithFullSolverDefaultValue =
false;
4049 private bool debugPostsolveWithFullSolver_;
4055 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4056 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4058 get {
if ((_hasBits3 & 268435456) != 0) {
return debugPostsolveWithFullSolver_; }
else {
return DebugPostsolveWithFullSolverDefaultValue; } }
4060 _hasBits3 |= 268435456;
4061 debugPostsolveWithFullSolver_ = value;
4065 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4066 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4068 get {
return (_hasBits3 & 268435456) != 0; }
4071 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4072 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4074 _hasBits3 &= ~268435456;
4079 private readonly
static int DebugMaxNumPresolveOperationsDefaultValue = 0;
4081 private int debugMaxNumPresolveOperations_;
4086 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4087 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4089 get {
if ((_hasBits3 & 262144) != 0) {
return debugMaxNumPresolveOperations_; }
else {
return DebugMaxNumPresolveOperationsDefaultValue; } }
4091 _hasBits3 |= 262144;
4092 debugMaxNumPresolveOperations_ = value;
4096 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4097 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4099 get {
return (_hasBits3 & 262144) != 0; }
4102 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4103 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4105 _hasBits3 &= ~262144;
4110 private readonly
static bool DebugCrashOnBadHintDefaultValue =
false;
4112 private bool debugCrashOnBadHint_;
4116 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4117 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4119 get {
if ((_hasBits4 & 67108864) != 0) {
return debugCrashOnBadHint_; }
else {
return DebugCrashOnBadHintDefaultValue; } }
4121 _hasBits4 |= 67108864;
4122 debugCrashOnBadHint_ = value;
4126 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4127 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4129 get {
return (_hasBits4 & 67108864) != 0; }
4132 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4133 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4135 _hasBits4 &= ~67108864;
4140 private readonly
static bool DebugCrashIfPresolveBreaksHintDefaultValue =
false;
4142 private bool debugCrashIfPresolveBreaksHint_;
4146 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4147 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4149 get {
if ((_hasBits7 & 16777216) != 0) {
return debugCrashIfPresolveBreaksHint_; }
else {
return DebugCrashIfPresolveBreaksHintDefaultValue; } }
4151 _hasBits7 |= 16777216;
4152 debugCrashIfPresolveBreaksHint_ = value;
4156 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4157 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4159 get {
return (_hasBits7 & 16777216) != 0; }
4162 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4163 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4165 _hasBits7 &= ~16777216;
4170 private readonly
static bool UseOptimizationHintsDefaultValue =
true;
4172 private bool useOptimizationHints_;
4179 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4180 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4182 get {
if ((_hasBits0 & 65536) != 0) {
return useOptimizationHints_; }
else {
return UseOptimizationHintsDefaultValue; } }
4185 useOptimizationHints_ = value;
4189 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4190 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4192 get {
return (_hasBits0 & 65536) != 0; }
4195 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4196 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4198 _hasBits0 &= ~65536;
4202 public const int CoreMinimizationLevelFieldNumber = 50;
4203 private readonly
static int CoreMinimizationLevelDefaultValue = 2;
4205 private int coreMinimizationLevel_;
4212 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4213 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4215 get {
if ((_hasBits0 & 268435456) != 0) {
return coreMinimizationLevel_; }
else {
return CoreMinimizationLevelDefaultValue; } }
4217 _hasBits0 |= 268435456;
4218 coreMinimizationLevel_ = value;
4222 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4223 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4225 get {
return (_hasBits0 & 268435456) != 0; }
4228 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4229 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4231 _hasBits0 &= ~268435456;
4235 public const int FindMultipleCoresFieldNumber = 84;
4236 private readonly
static bool FindMultipleCoresDefaultValue =
true;
4238 private bool findMultipleCores_;
4243 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4244 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4246 get {
if ((_hasBits1 & 134217728) != 0) {
return findMultipleCores_; }
else {
return FindMultipleCoresDefaultValue; } }
4248 _hasBits1 |= 134217728;
4249 findMultipleCores_ = value;
4253 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4254 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4256 get {
return (_hasBits1 & 134217728) != 0; }
4259 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4260 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4262 _hasBits1 &= ~134217728;
4267 private readonly
static bool CoverOptimizationDefaultValue =
true;
4269 private bool coverOptimization_;
4275 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4276 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4278 get {
if ((_hasBits2 & 1) != 0) {
return coverOptimization_; }
else {
return CoverOptimizationDefaultValue; } }
4281 coverOptimization_ = value;
4285 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4286 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4288 get {
return (_hasBits2 & 1) != 0; }
4291 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4292 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4299 private readonly
static global::Google.OrTools.Sat.SatParameters.Types.MaxSatAssumptionOrder MaxSatAssumptionOrderDefaultValue = global::Google.OrTools.Sat.SatParameters.Types.MaxSatAssumptionOrder.DefaultAssumptionOrder;
4301 private global::Google.OrTools.Sat.SatParameters.Types.MaxSatAssumptionOrder maxSatAssumptionOrder_;
4302 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4303 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4305 get {
if ((_hasBits0 & 536870912) != 0) {
return maxSatAssumptionOrder_; }
else {
return MaxSatAssumptionOrderDefaultValue; } }
4307 _hasBits0 |= 536870912;
4308 maxSatAssumptionOrder_ = value;
4312 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4313 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4314 public bool HasMaxSatAssumptionOrder {
4315 get {
return (_hasBits0 & 536870912) != 0; }
4318 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4319 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4321 _hasBits0 &= ~536870912;
4326 private readonly
static bool MaxSatReverseAssumptionOrderDefaultValue =
false;
4328 private bool maxSatReverseAssumptionOrder_;
4333 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4334 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4336 get {
if ((_hasBits0 & 1073741824) != 0) {
return maxSatReverseAssumptionOrder_; }
else {
return MaxSatReverseAssumptionOrderDefaultValue; } }
4338 _hasBits0 |= 1073741824;
4339 maxSatReverseAssumptionOrder_ = value;
4343 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4344 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4346 get {
return (_hasBits0 & 1073741824) != 0; }
4349 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4350 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4352 _hasBits0 &= ~1073741824;
4357 private readonly
static global::Google.OrTools.Sat.SatParameters.Types.MaxSatStratificationAlgorithm MaxSatStratificationDefaultValue = global::Google.OrTools.Sat.SatParameters.Types.MaxSatStratificationAlgorithm.StratificationDescent;
4359 private global::Google.OrTools.Sat.SatParameters.Types.MaxSatStratificationAlgorithm maxSatStratification_;
4360 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4361 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4362 public global::Google.OrTools.Sat.SatParameters.Types.MaxSatStratificationAlgorithm
MaxSatStratification {
4363 get {
if ((_hasBits0 & -2147483648) != 0) {
return maxSatStratification_; }
else {
return MaxSatStratificationDefaultValue; } }
4365 _hasBits0 |= -2147483648;
4366 maxSatStratification_ = value;
4370 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4371 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4372 public bool HasMaxSatStratification {
4373 get {
return (_hasBits0 & -2147483648) != 0; }
4376 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4377 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4379 _hasBits0 &= ~-2147483648;
4384 private readonly
static double PropagationLoopDetectionFactorDefaultValue = 10D;
4386 private double propagationLoopDetectionFactor_;
4398 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4399 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4401 get {
if ((_hasBits5 & 4096) != 0) {
return propagationLoopDetectionFactor_; }
else {
return PropagationLoopDetectionFactorDefaultValue; } }
4404 propagationLoopDetectionFactor_ = value;
4408 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4409 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4411 get {
return (_hasBits5 & 4096) != 0; }
4414 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4415 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4421 public const int UsePrecedencesInDisjunctiveConstraintFieldNumber = 74;
4422 private readonly
static bool UsePrecedencesInDisjunctiveConstraintDefaultValue =
true;
4424 private bool usePrecedencesInDisjunctiveConstraint_;
4436 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4437 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4439 get {
if ((_hasBits1 & 262144) != 0) {
return usePrecedencesInDisjunctiveConstraint_; }
else {
return UsePrecedencesInDisjunctiveConstraintDefaultValue; } }
4441 _hasBits1 |= 262144;
4442 usePrecedencesInDisjunctiveConstraint_ = value;
4446 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4447 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4449 get {
return (_hasBits1 & 262144) != 0; }
4452 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4453 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4455 _hasBits1 &= ~262144;
4459 public const int MaxSizeToCreatePrecedenceLiteralsInDisjunctiveFieldNumber = 229;
4460 private readonly
static int MaxSizeToCreatePrecedenceLiteralsInDisjunctiveDefaultValue = 60;
4462 private int maxSizeToCreatePrecedenceLiteralsInDisjunctive_;
4470 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4471 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4473 get {
if ((_hasBits5 & 1048576) != 0) {
return maxSizeToCreatePrecedenceLiteralsInDisjunctive_; }
else {
return MaxSizeToCreatePrecedenceLiteralsInDisjunctiveDefaultValue; } }
4475 _hasBits5 |= 1048576;
4476 maxSizeToCreatePrecedenceLiteralsInDisjunctive_ = value;
4480 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4481 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4483 get {
return (_hasBits5 & 1048576) != 0; }
4486 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4487 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4489 _hasBits5 &= ~1048576;
4494 private readonly
static bool UseStrongPropagationInDisjunctiveDefaultValue =
false;
4496 private bool useStrongPropagationInDisjunctive_;
4500 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4501 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4503 get {
if ((_hasBits5 & 2097152) != 0) {
return useStrongPropagationInDisjunctive_; }
else {
return UseStrongPropagationInDisjunctiveDefaultValue; } }
4505 _hasBits5 |= 2097152;
4506 useStrongPropagationInDisjunctive_ = value;
4510 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4511 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4512 public bool HasUseStrongPropagationInDisjunctive {
4513 get {
return (_hasBits5 & 2097152) != 0; }
4516 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4517 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4518 public void ClearUseStrongPropagationInDisjunctive() {
4519 _hasBits5 &= ~2097152;
4523 public const int UseDynamicPrecedenceInDisjunctiveFieldNumber = 263;
4524 private readonly
static bool UseDynamicPrecedenceInDisjunctiveDefaultValue =
false;
4526 private bool useDynamicPrecedenceInDisjunctive_;
4535 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4536 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4538 get {
if ((_hasBits6 & 16384) != 0) {
return useDynamicPrecedenceInDisjunctive_; }
else {
return UseDynamicPrecedenceInDisjunctiveDefaultValue; } }
4541 useDynamicPrecedenceInDisjunctive_ = value;
4545 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4546 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4548 get {
return (_hasBits6 & 16384) != 0; }
4551 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4552 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4554 _hasBits6 &= ~16384;
4558 public const int UseDynamicPrecedenceInCumulativeFieldNumber = 268;
4559 private readonly
static bool UseDynamicPrecedenceInCumulativeDefaultValue =
false;
4561 private bool useDynamicPrecedenceInCumulative_;
4562 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4563 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4564 public bool UseDynamicPrecedenceInCumulative {
4565 get {
if ((_hasBits6 & 524288) != 0) {
return useDynamicPrecedenceInCumulative_; }
else {
return UseDynamicPrecedenceInCumulativeDefaultValue; } }
4567 _hasBits6 |= 524288;
4568 useDynamicPrecedenceInCumulative_ = value;
4572 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4573 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4574 public bool HasUseDynamicPrecedenceInCumulative {
4575 get {
return (_hasBits6 & 524288) != 0; }
4578 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4579 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4581 _hasBits6 &= ~524288;
4585 public const int UseOverloadCheckerInCumulativeFieldNumber = 78;
4586 private readonly
static bool UseOverloadCheckerInCumulativeDefaultValue =
false;
4588 private bool useOverloadCheckerInCumulative_;
4598 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4599 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4601 get {
if ((_hasBits1 & 4194304) != 0) {
return useOverloadCheckerInCumulative_; }
else {
return UseOverloadCheckerInCumulativeDefaultValue; } }
4603 _hasBits1 |= 4194304;
4604 useOverloadCheckerInCumulative_ = value;
4608 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4609 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4611 get {
return (_hasBits1 & 4194304) != 0; }
4614 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4615 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4617 _hasBits1 &= ~4194304;
4621 public const int UseConservativeScaleOverloadCheckerFieldNumber = 286;
4622 private readonly
static bool UseConservativeScaleOverloadCheckerDefaultValue =
false;
4624 private bool useConservativeScaleOverloadChecker_;
4634 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4635 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4637 get {
if ((_hasBits7 & 32) != 0) {
return useConservativeScaleOverloadChecker_; }
else {
return UseConservativeScaleOverloadCheckerDefaultValue; } }
4640 useConservativeScaleOverloadChecker_ = value;
4644 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4645 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4647 get {
return (_hasBits7 & 32) != 0; }
4650 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4651 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4658 private readonly
static bool UseTimetableEdgeFindingInCumulativeDefaultValue =
false;
4660 private bool useTimetableEdgeFindingInCumulative_;
4670 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4671 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4673 get {
if ((_hasBits1 & 8388608) != 0) {
return useTimetableEdgeFindingInCumulative_; }
else {
return UseTimetableEdgeFindingInCumulativeDefaultValue; } }
4675 _hasBits1 |= 8388608;
4676 useTimetableEdgeFindingInCumulative_ = value;
4680 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4681 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4683 get {
return (_hasBits1 & 8388608) != 0; }
4686 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4687 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4689 _hasBits1 &= ~8388608;
4694 private readonly
static int MaxNumIntervalsForTimetableEdgeFindingDefaultValue = 100;
4696 private int maxNumIntervalsForTimetableEdgeFinding_;
4701 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4702 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4704 get {
if ((_hasBits6 & 2048) != 0) {
return maxNumIntervalsForTimetableEdgeFinding_; }
else {
return MaxNumIntervalsForTimetableEdgeFindingDefaultValue; } }
4707 maxNumIntervalsForTimetableEdgeFinding_ = value;
4711 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4712 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4713 public bool HasMaxNumIntervalsForTimetableEdgeFinding {
4714 get {
return (_hasBits6 & 2048) != 0; }
4717 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4718 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4725 private readonly
static bool UseHardPrecedencesInCumulativeDefaultValue =
false;
4727 private bool useHardPrecedencesInCumulative_;
4736 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4737 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4739 get {
if ((_hasBits5 & 256) != 0) {
return useHardPrecedencesInCumulative_; }
else {
return UseHardPrecedencesInCumulativeDefaultValue; } }
4742 useHardPrecedencesInCumulative_ = value;
4746 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4747 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4748 public bool HasUseHardPrecedencesInCumulative {
4749 get {
return (_hasBits5 & 256) != 0; }
4752 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4753 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4754 public void ClearUseHardPrecedencesInCumulative() {
4759 public const int ExploitAllPrecedencesFieldNumber = 220;
4760 private readonly
static bool ExploitAllPrecedencesDefaultValue =
false;
4762 private bool exploitAllPrecedences_;
4763 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4764 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4766 get {
if ((_hasBits5 & 2048) != 0) {
return exploitAllPrecedences_; }
else {
return ExploitAllPrecedencesDefaultValue; } }
4769 exploitAllPrecedences_ = value;
4773 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4774 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4776 get {
return (_hasBits5 & 2048) != 0; }
4779 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4780 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4781 public void ClearExploitAllPrecedences() {
4787 private readonly
static bool UseDisjunctiveConstraintInCumulativeDefaultValue =
true;
4789 private bool useDisjunctiveConstraintInCumulative_;
4802 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4803 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4805 get {
if ((_hasBits1 & 16777216) != 0) {
return useDisjunctiveConstraintInCumulative_; }
else {
return UseDisjunctiveConstraintInCumulativeDefaultValue; } }
4807 _hasBits1 |= 16777216;
4808 useDisjunctiveConstraintInCumulative_ = value;
4812 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4813 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4815 get {
return (_hasBits1 & 16777216) != 0; }
4818 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4819 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4821 _hasBits1 &= ~16777216;
4826 private readonly
static bool UseTimetablingInNoOverlap2DDefaultValue =
false;
4828 private bool useTimetablingInNoOverlap2D_;
4836 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4837 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4839 get {
if ((_hasBits4 & -2147483648) != 0) {
return useTimetablingInNoOverlap2D_; }
else {
return UseTimetablingInNoOverlap2DDefaultValue; } }
4841 _hasBits4 |= -2147483648;
4842 useTimetablingInNoOverlap2D_ = value;
4846 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4847 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4848 public bool HasUseTimetablingInNoOverlap2D {
4849 get {
return (_hasBits4 & -2147483648) != 0; }
4852 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4853 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4855 _hasBits4 &= ~-2147483648;
4860 private readonly
static bool UseEnergeticReasoningInNoOverlap2DDefaultValue =
false;
4862 private bool useEnergeticReasoningInNoOverlap2D_;
4868 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4869 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4871 get {
if ((_hasBits5 & 64) != 0) {
return useEnergeticReasoningInNoOverlap2D_; }
else {
return UseEnergeticReasoningInNoOverlap2DDefaultValue; } }
4874 useEnergeticReasoningInNoOverlap2D_ = value;
4878 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4879 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4881 get {
return (_hasBits5 & 64) != 0; }
4884 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4885 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4886 public void ClearUseEnergeticReasoningInNoOverlap2D() {
4891 public const int UseAreaEnergeticReasoningInNoOverlap2DFieldNumber = 271;
4892 private readonly
static bool UseAreaEnergeticReasoningInNoOverlap2DDefaultValue =
false;
4894 private bool useAreaEnergeticReasoningInNoOverlap2D_;
4900 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4901 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4903 get {
if ((_hasBits6 & 4194304) != 0) {
return useAreaEnergeticReasoningInNoOverlap2D_; }
else {
return UseAreaEnergeticReasoningInNoOverlap2DDefaultValue; } }
4905 _hasBits6 |= 4194304;
4906 useAreaEnergeticReasoningInNoOverlap2D_ = value;
4910 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4911 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4913 get {
return (_hasBits6 & 4194304) != 0; }
4916 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4917 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4918 public void ClearUseAreaEnergeticReasoningInNoOverlap2D() {
4919 _hasBits6 &= ~4194304;
4923 public const int UseTryEdgeReasoningInNoOverlap2DFieldNumber = 299;
4924 private readonly
static bool UseTryEdgeReasoningInNoOverlap2DDefaultValue =
false;
4926 private bool useTryEdgeReasoningInNoOverlap2D_;
4927 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4928 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4930 get {
if ((_hasBits7 & 131072) != 0) {
return useTryEdgeReasoningInNoOverlap2D_; }
else {
return UseTryEdgeReasoningInNoOverlap2DDefaultValue; } }
4932 _hasBits7 |= 131072;
4933 useTryEdgeReasoningInNoOverlap2D_ = value;
4937 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4938 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4939 public bool HasUseTryEdgeReasoningInNoOverlap2D {
4940 get {
return (_hasBits7 & 131072) != 0; }
4943 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4944 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4945 public void ClearUseTryEdgeReasoningInNoOverlap2D() {
4946 _hasBits7 &= ~131072;
4950 public const int MaxPairsPairwiseReasoningInNoOverlap2DFieldNumber = 276;
4951 private readonly
static int MaxPairsPairwiseReasoningInNoOverlap2DDefaultValue = 1250;
4953 private int maxPairsPairwiseReasoningInNoOverlap2D_;
4959 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4960 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4962 get {
if ((_hasBits6 & 134217728) != 0) {
return maxPairsPairwiseReasoningInNoOverlap2D_; }
else {
return MaxPairsPairwiseReasoningInNoOverlap2DDefaultValue; } }
4964 _hasBits6 |= 134217728;
4965 maxPairsPairwiseReasoningInNoOverlap2D_ = value;
4969 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4970 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4972 get {
return (_hasBits6 & 134217728) != 0; }
4975 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4976 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4977 public void ClearMaxPairsPairwiseReasoningInNoOverlap2D() {
4978 _hasBits6 &= ~134217728;
4982 public const int MaximumRegionsToSplitInDisconnectedNoOverlap2DFieldNumber = 315;
4983 private readonly
static int MaximumRegionsToSplitInDisconnectedNoOverlap2DDefaultValue = 0;
4985 private int maximumRegionsToSplitInDisconnectedNoOverlap2D_;
4998 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4999 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5001 get {
if ((_hasBits8 & 2) != 0) {
return maximumRegionsToSplitInDisconnectedNoOverlap2D_; }
else {
return MaximumRegionsToSplitInDisconnectedNoOverlap2DDefaultValue; } }
5004 maximumRegionsToSplitInDisconnectedNoOverlap2D_ = value;
5008 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5009 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5011 get {
return (_hasBits8 & 2) != 0; }
5014 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5015 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5022 private readonly
static bool UseDualSchedulingHeuristicsDefaultValue =
true;
5024 private bool useDualSchedulingHeuristics_;
5030 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5031 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5033 get {
if ((_hasBits5 & 128) != 0) {
return useDualSchedulingHeuristics_; }
else {
return UseDualSchedulingHeuristicsDefaultValue; } }
5036 useDualSchedulingHeuristics_ = value;
5040 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5041 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5043 get {
return (_hasBits5 & 128) != 0; }
5046 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5047 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5048 public void ClearUseDualSchedulingHeuristics() {
5053 public const int UseAllDifferentForCircuitFieldNumber = 311;
5054 private readonly
static bool UseAllDifferentForCircuitDefaultValue =
false;
5056 private bool useAllDifferentForCircuit_;
5061 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5062 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5064 get {
if ((_hasBits7 & 536870912) != 0) {
return useAllDifferentForCircuit_; }
else {
return UseAllDifferentForCircuitDefaultValue; } }
5066 _hasBits7 |= 536870912;
5067 useAllDifferentForCircuit_ = value;
5071 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5072 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5074 get {
return (_hasBits7 & 536870912) != 0; }
5077 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5078 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5079 public void ClearUseAllDifferentForCircuit() {
5080 _hasBits7 &= ~536870912;
5084 public const int RoutingCutSubsetSizeForBinaryRelationBoundFieldNumber = 312;
5085 private readonly
static int RoutingCutSubsetSizeForBinaryRelationBoundDefaultValue = 0;
5087 private int routingCutSubsetSizeForBinaryRelationBound_;
5098 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5099 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5101 get {
if ((_hasBits7 & 1073741824) != 0) {
return routingCutSubsetSizeForBinaryRelationBound_; }
else {
return RoutingCutSubsetSizeForBinaryRelationBoundDefaultValue; } }
5103 _hasBits7 |= 1073741824;
5104 routingCutSubsetSizeForBinaryRelationBound_ = value;
5108 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5109 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5110 public bool HasRoutingCutSubsetSizeForBinaryRelationBound {
5111 get {
return (_hasBits7 & 1073741824) != 0; }
5114 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5115 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5116 public void ClearRoutingCutSubsetSizeForBinaryRelationBound() {
5117 _hasBits7 &= ~1073741824;
5121 public const int RoutingCutSubsetSizeForTightBinaryRelationBoundFieldNumber = 313;
5122 private readonly
static int RoutingCutSubsetSizeForTightBinaryRelationBoundDefaultValue = 0;
5124 private int routingCutSubsetSizeForTightBinaryRelationBound_;
5130 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5131 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5133 get {
if ((_hasBits7 & -2147483648) != 0) {
return routingCutSubsetSizeForTightBinaryRelationBound_; }
else {
return RoutingCutSubsetSizeForTightBinaryRelationBoundDefaultValue; } }
5135 _hasBits7 |= -2147483648;
5136 routingCutSubsetSizeForTightBinaryRelationBound_ = value;
5140 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5141 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5143 get {
return (_hasBits7 & -2147483648) != 0; }
5146 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5147 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5148 public void ClearRoutingCutSubsetSizeForTightBinaryRelationBound() {
5149 _hasBits7 &= ~-2147483648;
5153 public const int RoutingCutDpEffortFieldNumber = 314;
5154 private readonly
static double RoutingCutDpEffortDefaultValue = 1e+07D;
5156 private double routingCutDpEffort_;
5163 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5164 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5166 get {
if ((_hasBits8 & 1) != 0) {
return routingCutDpEffort_; }
else {
return RoutingCutDpEffortDefaultValue; } }
5169 routingCutDpEffort_ = value;
5173 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5174 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5175 public bool HasRoutingCutDpEffort {
5176 get {
return (_hasBits8 & 1) != 0; }
5179 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5180 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5186 public const int SearchBranchingFieldNumber = 82;
5187 private readonly
static global::Google.OrTools.Sat.SatParameters.Types.SearchBranching SearchBranchingDefaultValue = global::Google.OrTools.Sat.SatParameters.Types.SearchBranching.AutomaticSearch;
5189 private global::Google.OrTools.Sat.SatParameters.Types.SearchBranching searchBranching_;
5190 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5191 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5193 get {
if ((_hasBits1 & 33554432) != 0) {
return searchBranching_; }
else {
return SearchBranchingDefaultValue; } }
5195 _hasBits1 |= 33554432;
5196 searchBranching_ = value;
5200 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5201 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5202 public bool HasSearchBranching {
5203 get {
return (_hasBits1 & 33554432) != 0; }
5206 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5207 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5208 public void ClearSearchBranching() {
5209 _hasBits1 &= ~33554432;
5213 public const int HintConflictLimitFieldNumber = 153;
5214 private readonly
static int HintConflictLimitDefaultValue = 10;
5216 private int hintConflictLimit_;
5220 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5221 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5223 get {
if ((_hasBits3 & 1048576) != 0) {
return hintConflictLimit_; }
else {
return HintConflictLimitDefaultValue; } }
5225 _hasBits3 |= 1048576;
5226 hintConflictLimit_ = value;
5230 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5231 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5233 get {
return (_hasBits3 & 1048576) != 0; }
5236 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5237 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5238 public void ClearHintConflictLimit() {
5239 _hasBits3 &= ~1048576;
5244 private readonly
static bool RepairHintDefaultValue =
false;
5246 private bool repairHint_;
5253 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5254 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5256 get {
if ((_hasBits4 & 2) != 0) {
return repairHint_; }
else {
return RepairHintDefaultValue; } }
5259 repairHint_ = value;
5263 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5264 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5265 public bool HasRepairHint {
5266 get {
return (_hasBits4 & 2) != 0; }
5269 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5270 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5276 public const int FixVariablesToTheirHintedValueFieldNumber = 192;
5277 private readonly
static bool FixVariablesToTheirHintedValueDefaultValue =
false;
5279 private bool fixVariablesToTheirHintedValue_;
5284 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5285 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5287 get {
if ((_hasBits4 & 8388608) != 0) {
return fixVariablesToTheirHintedValue_; }
else {
return FixVariablesToTheirHintedValueDefaultValue; } }
5289 _hasBits4 |= 8388608;
5290 fixVariablesToTheirHintedValue_ = value;
5294 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5295 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5297 get {
return (_hasBits4 & 8388608) != 0; }
5300 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5301 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5302 public void ClearFixVariablesToTheirHintedValue() {
5303 _hasBits4 &= ~8388608;
5307 public const int UseProbingSearchFieldNumber = 176;
5308 private readonly
static bool UseProbingSearchDefaultValue =
false;
5310 private bool useProbingSearch_;
5316 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5317 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5319 get {
if ((_hasBits4 & 512) != 0) {
return useProbingSearch_; }
else {
return UseProbingSearchDefaultValue; } }
5322 useProbingSearch_ = value;
5326 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5327 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5329 get {
return (_hasBits4 & 512) != 0; }
5332 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5333 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5334 public void ClearUseProbingSearch() {
5339 public const int UseExtendedProbingFieldNumber = 269;
5340 private readonly
static bool UseExtendedProbingDefaultValue =
true;
5342 private bool useExtendedProbing_;
5346 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5347 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5349 get {
if ((_hasBits6 & 1048576) != 0) {
return useExtendedProbing_; }
else {
return UseExtendedProbingDefaultValue; } }
5351 _hasBits6 |= 1048576;
5352 useExtendedProbing_ = value;
5356 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5357 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5359 get {
return (_hasBits6 & 1048576) != 0; }
5362 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5363 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5364 public void ClearUseExtendedProbing() {
5365 _hasBits6 &= ~1048576;
5370 private readonly
static int ProbingNumCombinationsLimitDefaultValue = 20000;
5372 private int probingNumCombinationsLimit_;
5376 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5377 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5379 get {
if ((_hasBits6 & 8388608) != 0) {
return probingNumCombinationsLimit_; }
else {
return ProbingNumCombinationsLimitDefaultValue; } }
5381 _hasBits6 |= 8388608;
5382 probingNumCombinationsLimit_ = value;
5386 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5387 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5389 get {
return (_hasBits6 & 8388608) != 0; }
5392 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5393 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5394 public void ClearProbingNumCombinationsLimit() {
5395 _hasBits6 &= ~8388608;
5400 private readonly
static bool UseShavingInProbingSearchDefaultValue =
true;
5402 private bool useShavingInProbingSearch_;
5407 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5408 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5410 get {
if ((_hasBits5 & 8) != 0) {
return useShavingInProbingSearch_; }
else {
return UseShavingInProbingSearchDefaultValue; } }
5413 useShavingInProbingSearch_ = value;
5417 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5418 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5420 get {
return (_hasBits5 & 8) != 0; }
5423 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5424 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5425 public void ClearUseShavingInProbingSearch() {
5430 public const int ShavingSearchDeterministicTimeFieldNumber = 205;
5431 private readonly
static double ShavingSearchDeterministicTimeDefaultValue = 0.001D;
5433 private double shavingSearchDeterministicTime_;
5438 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5439 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5441 get {
if ((_hasBits5 & 16) != 0) {
return shavingSearchDeterministicTime_; }
else {
return ShavingSearchDeterministicTimeDefaultValue; } }
5444 shavingSearchDeterministicTime_ = value;
5448 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5449 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5451 get {
return (_hasBits5 & 16) != 0; }
5454 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5455 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5456 public void ClearShavingSearchDeterministicTime() {
5461 public const int ShavingSearchThresholdFieldNumber = 290;
5462 private readonly
static long ShavingSearchThresholdDefaultValue = 64L;
5464 private long shavingSearchThreshold_;
5471 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5472 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5474 get {
if ((_hasBits7 & 512) != 0) {
return shavingSearchThreshold_; }
else {
return ShavingSearchThresholdDefaultValue; } }
5477 shavingSearchThreshold_ = value;
5481 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5482 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5483 public bool HasShavingSearchThreshold {
5484 get {
return (_hasBits7 & 512) != 0; }
5487 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5488 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5494 public const int UseObjectiveLbSearchFieldNumber = 228;
5495 private readonly
static bool UseObjectiveLbSearchDefaultValue =
false;
5497 private bool useObjectiveLbSearch_;
5502 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5503 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5505 get {
if ((_hasBits5 & 524288) != 0) {
return useObjectiveLbSearch_; }
else {
return UseObjectiveLbSearchDefaultValue; } }
5507 _hasBits5 |= 524288;
5508 useObjectiveLbSearch_ = value;
5512 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5513 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5515 get {
return (_hasBits5 & 524288) != 0; }
5518 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5519 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5520 public void ClearUseObjectiveLbSearch() {
5521 _hasBits5 &= ~524288;
5525 public const int UseObjectiveShavingSearchFieldNumber = 253;
5526 private readonly
static bool UseObjectiveShavingSearchDefaultValue =
false;
5528 private bool useObjectiveShavingSearch_;
5534 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5535 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5537 get {
if ((_hasBits6 & 32) != 0) {
return useObjectiveShavingSearch_; }
else {
return UseObjectiveShavingSearchDefaultValue; } }
5540 useObjectiveShavingSearch_ = value;
5544 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5545 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5547 get {
return (_hasBits6 & 32) != 0; }
5550 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5551 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5552 public void ClearUseObjectiveShavingSearch() {
5557 public const int UseVariablesShavingSearchFieldNumber = 289;
5558 private readonly
static bool UseVariablesShavingSearchDefaultValue =
false;
5560 private bool useVariablesShavingSearch_;
5565 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5566 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5568 get {
if ((_hasBits7 & 256) != 0) {
return useVariablesShavingSearch_; }
else {
return UseVariablesShavingSearchDefaultValue; } }
5571 useVariablesShavingSearch_ = value;
5575 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5576 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5578 get {
return (_hasBits7 & 256) != 0; }
5581 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5582 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5583 public void ClearUseVariablesShavingSearch() {
5588 public const int PseudoCostReliabilityThresholdFieldNumber = 123;
5589 private readonly
static long PseudoCostReliabilityThresholdDefaultValue = 100L;
5591 private long pseudoCostReliabilityThreshold_;
5596 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5597 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5599 get {
if ((_hasBits2 & 268435456) != 0) {
return pseudoCostReliabilityThreshold_; }
else {
return PseudoCostReliabilityThresholdDefaultValue; } }
5601 _hasBits2 |= 268435456;
5602 pseudoCostReliabilityThreshold_ = value;
5606 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5607 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5609 get {
return (_hasBits2 & 268435456) != 0; }
5612 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5613 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5614 public void ClearPseudoCostReliabilityThreshold() {
5615 _hasBits2 &= ~268435456;
5619 public const int OptimizeWithCoreFieldNumber = 83;
5620 private readonly
static bool OptimizeWithCoreDefaultValue =
false;
5622 private bool optimizeWithCore_;
5629 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5630 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5632 get {
if ((_hasBits1 & 67108864) != 0) {
return optimizeWithCore_; }
else {
return OptimizeWithCoreDefaultValue; } }
5634 _hasBits1 |= 67108864;
5635 optimizeWithCore_ = value;
5639 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5640 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5641 public bool HasOptimizeWithCore {
5642 get {
return (_hasBits1 & 67108864) != 0; }
5645 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5646 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5648 _hasBits1 &= ~67108864;
5652 public const int OptimizeWithLbTreeSearchFieldNumber = 188;
5653 private readonly
static bool OptimizeWithLbTreeSearchDefaultValue =
false;
5655 private bool optimizeWithLbTreeSearch_;
5663 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5664 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5666 get {
if ((_hasBits4 & 524288) != 0) {
return optimizeWithLbTreeSearch_; }
else {
return OptimizeWithLbTreeSearchDefaultValue; } }
5668 _hasBits4 |= 524288;
5669 optimizeWithLbTreeSearch_ = value;
5673 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5674 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5675 public bool HasOptimizeWithLbTreeSearch {
5676 get {
return (_hasBits4 & 524288) != 0; }
5679 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5680 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5682 _hasBits4 &= ~524288;
5687 private readonly
static bool SaveLpBasisInLbTreeSearchDefaultValue =
false;
5689 private bool saveLpBasisInLbTreeSearch_;
5698 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5699 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5701 get {
if ((_hasBits7 & 8) != 0) {
return saveLpBasisInLbTreeSearch_; }
else {
return SaveLpBasisInLbTreeSearchDefaultValue; } }
5704 saveLpBasisInLbTreeSearch_ = value;
5708 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5709 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5710 public bool HasSaveLpBasisInLbTreeSearch {
5711 get {
return (_hasBits7 & 8) != 0; }
5714 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5715 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5722 private readonly
static int BinarySearchNumConflictsDefaultValue = -1;
5724 private int binarySearchNumConflicts_;
5731 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5732 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5734 get {
if ((_hasBits2 & 256) != 0) {
return binarySearchNumConflicts_; }
else {
return BinarySearchNumConflictsDefaultValue; } }
5737 binarySearchNumConflicts_ = value;
5741 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5742 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5744 get {
return (_hasBits2 & 256) != 0; }
5747 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5748 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5749 public void ClearBinarySearchNumConflicts() {
5754 public const int OptimizeWithMaxHsFieldNumber = 85;
5755 private readonly
static bool OptimizeWithMaxHsDefaultValue =
false;
5757 private bool optimizeWithMaxHs_;
5766 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5767 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5769 get {
if ((_hasBits1 & 268435456) != 0) {
return optimizeWithMaxHs_; }
else {
return OptimizeWithMaxHsDefaultValue; } }
5771 _hasBits1 |= 268435456;
5772 optimizeWithMaxHs_ = value;
5776 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5777 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5778 public bool HasOptimizeWithMaxHs {
5779 get {
return (_hasBits1 & 268435456) != 0; }
5782 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5783 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5785 _hasBits1 &= ~268435456;
5790 private readonly
static bool UseFeasibilityJumpDefaultValue =
true;
5792 private bool useFeasibilityJump_;
5798 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5799 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5801 get {
if ((_hasBits6 & 65536) != 0) {
return useFeasibilityJump_; }
else {
return UseFeasibilityJumpDefaultValue; } }
5804 useFeasibilityJump_ = value;
5808 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5809 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5811 get {
return (_hasBits6 & 65536) != 0; }
5814 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5815 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5816 public void ClearUseFeasibilityJump() {
5817 _hasBits6 &= ~65536;
5821 public const int UseLsOnlyFieldNumber = 240;
5822 private readonly
static bool UseLsOnlyDefaultValue =
false;
5824 private bool useLsOnly_;
5829 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5830 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5832 get {
if ((_hasBits5 & 536870912) != 0) {
return useLsOnly_; }
else {
return UseLsOnlyDefaultValue; } }
5834 _hasBits5 |= 536870912;
5839 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5840 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5842 get {
return (_hasBits5 & 536870912) != 0; }
5845 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5846 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5847 public void ClearUseLsOnly() {
5848 _hasBits5 &= ~536870912;
5853 private readonly
static double FeasibilityJumpDecayDefaultValue = 0.95D;
5855 private double feasibilityJumpDecay_;
5860 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5861 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5863 get {
if ((_hasBits5 & 1073741824) != 0) {
return feasibilityJumpDecay_; }
else {
return FeasibilityJumpDecayDefaultValue; } }
5865 _hasBits5 |= 1073741824;
5866 feasibilityJumpDecay_ = value;
5870 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5871 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5873 get {
return (_hasBits5 & 1073741824) != 0; }
5876 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5877 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5878 public void ClearFeasibilityJumpDecay() {
5879 _hasBits5 &= ~1073741824;
5884 private readonly
static int FeasibilityJumpLinearizationLevelDefaultValue = 2;
5886 private int feasibilityJumpLinearizationLevel_;
5890 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5891 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5893 get {
if ((_hasBits6 & 256) != 0) {
return feasibilityJumpLinearizationLevel_; }
else {
return FeasibilityJumpLinearizationLevelDefaultValue; } }
5896 feasibilityJumpLinearizationLevel_ = value;
5900 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5901 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5903 get {
return (_hasBits6 & 256) != 0; }
5906 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5907 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5908 public void ClearFeasibilityJumpLinearizationLevel() {
5914 private readonly
static int FeasibilityJumpRestartFactorDefaultValue = 1;
5916 private int feasibilityJumpRestartFactor_;
5921 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5922 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5924 get {
if ((_hasBits6 & 512) != 0) {
return feasibilityJumpRestartFactor_; }
else {
return FeasibilityJumpRestartFactorDefaultValue; } }
5927 feasibilityJumpRestartFactor_ = value;
5931 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5932 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5934 get {
return (_hasBits6 & 512) != 0; }
5937 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5938 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5939 public void ClearFeasibilityJumpRestartFactor() {
5945 private readonly
static double FeasibilityJumpBatchDtimeDefaultValue = 0.1D;
5947 private double feasibilityJumpBatchDtime_;
5951 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5952 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5954 get {
if ((_hasBits7 & 2048) != 0) {
return feasibilityJumpBatchDtime_; }
else {
return FeasibilityJumpBatchDtimeDefaultValue; } }
5957 feasibilityJumpBatchDtime_ = value;
5961 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5962 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5964 get {
return (_hasBits7 & 2048) != 0; }
5967 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5968 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5969 public void ClearFeasibilityJumpBatchDtime() {
5975 private readonly
static double FeasibilityJumpVarRandomizationProbabilityDefaultValue = 0.05D;
5977 private double feasibilityJumpVarRandomizationProbability_;
5982 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5983 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5985 get {
if ((_hasBits6 & 1) != 0) {
return feasibilityJumpVarRandomizationProbability_; }
else {
return FeasibilityJumpVarRandomizationProbabilityDefaultValue; } }
5988 feasibilityJumpVarRandomizationProbability_ = value;
5992 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5993 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5995 get {
return (_hasBits6 & 1) != 0; }
5998 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5999 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6000 public void ClearFeasibilityJumpVarRandomizationProbability() {
6006 private readonly
static double FeasibilityJumpVarPerburbationRangeRatioDefaultValue = 0.2D;
6008 private double feasibilityJumpVarPerburbationRangeRatio_;
6013 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6014 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6016 get {
if ((_hasBits6 & 2) != 0) {
return feasibilityJumpVarPerburbationRangeRatio_; }
else {
return FeasibilityJumpVarPerburbationRangeRatioDefaultValue; } }
6019 feasibilityJumpVarPerburbationRangeRatio_ = value;
6023 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6024 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6026 get {
return (_hasBits6 & 2) != 0; }
6029 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6030 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6031 public void ClearFeasibilityJumpVarPerburbationRangeRatio() {
6037 private readonly
static bool FeasibilityJumpEnableRestartsDefaultValue =
true;
6039 private bool feasibilityJumpEnableRestarts_;
6045 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6046 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6048 get {
if ((_hasBits6 & 8) != 0) {
return feasibilityJumpEnableRestarts_; }
else {
return FeasibilityJumpEnableRestartsDefaultValue; } }
6051 feasibilityJumpEnableRestarts_ = value;
6055 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6056 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6058 get {
return (_hasBits6 & 8) != 0; }
6061 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6062 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6063 public void ClearFeasibilityJumpEnableRestarts() {
6068 public const int FeasibilityJumpMaxExpandedConstraintSizeFieldNumber = 264;
6069 private readonly
static int FeasibilityJumpMaxExpandedConstraintSizeDefaultValue = 500;
6071 private int feasibilityJumpMaxExpandedConstraintSize_;
6078 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6079 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6081 get {
if ((_hasBits6 & 32768) != 0) {
return feasibilityJumpMaxExpandedConstraintSize_; }
else {
return FeasibilityJumpMaxExpandedConstraintSizeDefaultValue; } }
6084 feasibilityJumpMaxExpandedConstraintSize_ = value;
6088 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6089 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6091 get {
return (_hasBits6 & 32768) != 0; }
6094 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6095 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6096 public void ClearFeasibilityJumpMaxExpandedConstraintSize() {
6097 _hasBits6 &= ~32768;
6101 public const int NumViolationLsFieldNumber = 244;
6102 private readonly
static int NumViolationLsDefaultValue = 0;
6104 private int numViolationLs_;
6110 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6111 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6113 get {
if ((_hasBits5 & -2147483648) != 0) {
return numViolationLs_; }
else {
return NumViolationLsDefaultValue; } }
6115 _hasBits5 |= -2147483648;
6116 numViolationLs_ = value;
6120 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6121 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6123 get {
return (_hasBits5 & -2147483648) != 0; }
6126 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6127 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6128 public void ClearNumViolationLs() {
6129 _hasBits5 &= ~-2147483648;
6133 public const int ViolationLsPerturbationPeriodFieldNumber = 249;
6134 private readonly
static int ViolationLsPerturbationPeriodDefaultValue = 100;
6136 private int violationLsPerturbationPeriod_;
6140 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6141 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6143 get {
if ((_hasBits6 & 4) != 0) {
return violationLsPerturbationPeriod_; }
else {
return ViolationLsPerturbationPeriodDefaultValue; } }
6146 violationLsPerturbationPeriod_ = value;
6150 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6151 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6153 get {
return (_hasBits6 & 4) != 0; }
6156 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6157 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6158 public void ClearViolationLsPerturbationPeriod() {
6164 private readonly
static double ViolationLsCompoundMoveProbabilityDefaultValue = 0.5D;
6166 private double violationLsCompoundMoveProbability_;
6171 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6172 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6174 get {
if ((_hasBits6 & 1024) != 0) {
return violationLsCompoundMoveProbability_; }
else {
return ViolationLsCompoundMoveProbabilityDefaultValue; } }
6177 violationLsCompoundMoveProbability_ = value;
6181 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6182 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6184 get {
return (_hasBits6 & 1024) != 0; }
6187 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6188 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6189 public void ClearViolationLsCompoundMoveProbability() {
6195 private readonly
static int SharedTreeNumWorkersDefaultValue = 0;
6197 private int sharedTreeNumWorkers_;
6207 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6208 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6210 get {
if ((_hasBits5 & 33554432) != 0) {
return sharedTreeNumWorkers_; }
else {
return SharedTreeNumWorkersDefaultValue; } }
6212 _hasBits5 |= 33554432;
6213 sharedTreeNumWorkers_ = value;
6217 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6218 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6219 public bool HasSharedTreeNumWorkers {
6220 get {
return (_hasBits5 & 33554432) != 0; }
6223 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6224 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6226 _hasBits5 &= ~33554432;
6231 private readonly
static bool UseSharedTreeSearchDefaultValue =
false;
6233 private bool useSharedTreeSearch_;
6237 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6238 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6240 get {
if ((_hasBits5 & 67108864) != 0) {
return useSharedTreeSearch_; }
else {
return UseSharedTreeSearchDefaultValue; } }
6242 _hasBits5 |= 67108864;
6243 useSharedTreeSearch_ = value;
6247 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6248 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6250 get {
return (_hasBits5 & 67108864) != 0; }
6253 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6254 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6255 public void ClearUseSharedTreeSearch() {
6256 _hasBits5 &= ~67108864;
6261 private readonly
static int SharedTreeWorkerMinRestartsPerSubtreeDefaultValue = 1;
6263 private int sharedTreeWorkerMinRestartsPerSubtree_;
6268 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6269 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6271 get {
if ((_hasBits7 & 2) != 0) {
return sharedTreeWorkerMinRestartsPerSubtree_; }
else {
return SharedTreeWorkerMinRestartsPerSubtreeDefaultValue; } }
6274 sharedTreeWorkerMinRestartsPerSubtree_ = value;
6278 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6279 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6281 get {
return (_hasBits7 & 2) != 0; }
6284 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6285 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6286 public void ClearSharedTreeWorkerMinRestartsPerSubtree() {
6292 private readonly
static bool SharedTreeWorkerEnableTrailSharingDefaultValue =
true;
6294 private bool sharedTreeWorkerEnableTrailSharing_;
6299 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6300 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6302 get {
if ((_hasBits7 & 8192) != 0) {
return sharedTreeWorkerEnableTrailSharing_; }
else {
return SharedTreeWorkerEnableTrailSharingDefaultValue; } }
6305 sharedTreeWorkerEnableTrailSharing_ = value;
6309 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6310 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6312 get {
return (_hasBits7 & 8192) != 0; }
6315 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6316 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6317 public void ClearSharedTreeWorkerEnableTrailSharing() {
6323 private readonly
static bool SharedTreeWorkerEnablePhaseSharingDefaultValue =
true;
6325 private bool sharedTreeWorkerEnablePhaseSharing_;
6330 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6331 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6333 get {
if ((_hasBits7 & 4194304) != 0) {
return sharedTreeWorkerEnablePhaseSharing_; }
else {
return SharedTreeWorkerEnablePhaseSharingDefaultValue; } }
6335 _hasBits7 |= 4194304;
6336 sharedTreeWorkerEnablePhaseSharing_ = value;
6340 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6341 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6343 get {
return (_hasBits7 & 4194304) != 0; }
6346 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6347 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6348 public void ClearSharedTreeWorkerEnablePhaseSharing() {
6349 _hasBits7 &= ~4194304;
6354 private readonly
static double SharedTreeOpenLeavesPerWorkerDefaultValue = 2D;
6356 private double sharedTreeOpenLeavesPerWorker_;
6360 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6361 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6363 get {
if ((_hasBits7 & 1) != 0) {
return sharedTreeOpenLeavesPerWorker_; }
else {
return SharedTreeOpenLeavesPerWorkerDefaultValue; } }
6366 sharedTreeOpenLeavesPerWorker_ = value;
6370 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6371 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6373 get {
return (_hasBits7 & 1) != 0; }
6376 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6377 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6378 public void ClearSharedTreeOpenLeavesPerWorker() {
6384 private readonly
static int SharedTreeMaxNodesPerWorkerDefaultValue = 10000;
6386 private int sharedTreeMaxNodesPerWorker_;
6393 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6394 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6396 get {
if ((_hasBits5 & 134217728) != 0) {
return sharedTreeMaxNodesPerWorker_; }
else {
return SharedTreeMaxNodesPerWorkerDefaultValue; } }
6398 _hasBits5 |= 134217728;
6399 sharedTreeMaxNodesPerWorker_ = value;
6403 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6404 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6406 get {
return (_hasBits5 & 134217728) != 0; }
6409 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6410 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6411 public void ClearSharedTreeMaxNodesPerWorker() {
6412 _hasBits5 &= ~134217728;
6416 public const int SharedTreeSplitStrategyFieldNumber = 239;
6417 private readonly
static global::Google.OrTools.Sat.SatParameters.Types.SharedTreeSplitStrategy SharedTreeSplitStrategyDefaultValue = global::Google.OrTools.Sat.SatParameters.Types.SharedTreeSplitStrategy.SplitStrategyAuto;
6419 private global::Google.OrTools.Sat.SatParameters.Types.SharedTreeSplitStrategy sharedTreeSplitStrategy_;
6420 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6421 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6423 get {
if ((_hasBits5 & 268435456) != 0) {
return sharedTreeSplitStrategy_; }
else {
return SharedTreeSplitStrategyDefaultValue; } }
6425 _hasBits5 |= 268435456;
6426 sharedTreeSplitStrategy_ = value;
6430 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6431 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6432 public bool HasSharedTreeSplitStrategy {
6433 get {
return (_hasBits5 & 268435456) != 0; }
6436 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6437 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6439 _hasBits5 &= ~268435456;
6443 public const int SharedTreeBalanceToleranceFieldNumber = 305;
6444 private readonly
static int SharedTreeBalanceToleranceDefaultValue = 1;
6446 private int sharedTreeBalanceTolerance_;
6456 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6457 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6459 get {
if ((_hasBits7 & 8388608) != 0) {
return sharedTreeBalanceTolerance_; }
else {
return SharedTreeBalanceToleranceDefaultValue; } }
6461 _hasBits7 |= 8388608;
6462 sharedTreeBalanceTolerance_ = value;
6466 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6467 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6468 public bool HasSharedTreeBalanceTolerance {
6469 get {
return (_hasBits7 & 8388608) != 0; }
6472 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6473 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6475 _hasBits7 &= ~8388608;
6480 private readonly
static bool EnumerateAllSolutionsDefaultValue =
false;
6482 private bool enumerateAllSolutions_;
6492 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6493 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6495 get {
if ((_hasBits1 & 1073741824) != 0) {
return enumerateAllSolutions_; }
else {
return EnumerateAllSolutionsDefaultValue; } }
6497 _hasBits1 |= 1073741824;
6498 enumerateAllSolutions_ = value;
6502 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6503 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6504 public bool HasEnumerateAllSolutions {
6505 get {
return (_hasBits1 & 1073741824) != 0; }
6508 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6509 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6511 _hasBits1 &= ~1073741824;
6516 private readonly
static bool KeepAllFeasibleSolutionsInPresolveDefaultValue =
false;
6518 private bool keepAllFeasibleSolutionsInPresolve_;
6529 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6530 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6532 get {
if ((_hasBits4 & 64) != 0) {
return keepAllFeasibleSolutionsInPresolve_; }
else {
return KeepAllFeasibleSolutionsInPresolveDefaultValue; } }
6535 keepAllFeasibleSolutionsInPresolve_ = value;
6539 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6540 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6541 public bool HasKeepAllFeasibleSolutionsInPresolve {
6542 get {
return (_hasBits4 & 64) != 0; }
6545 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6546 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6553 private readonly
static bool FillTightenedDomainsInResponseDefaultValue =
false;
6555 private bool fillTightenedDomainsInResponse_;
6563 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6564 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6566 get {
if ((_hasBits3 & 32) != 0) {
return fillTightenedDomainsInResponse_; }
else {
return FillTightenedDomainsInResponseDefaultValue; } }
6569 fillTightenedDomainsInResponse_ = value;
6573 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6574 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6576 get {
return (_hasBits3 & 32) != 0; }
6579 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6580 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6581 public void ClearFillTightenedDomainsInResponse() {
6586 public const int FillAdditionalSolutionsInResponseFieldNumber = 194;
6587 private readonly
static bool FillAdditionalSolutionsInResponseDefaultValue =
false;
6589 private bool fillAdditionalSolutionsInResponse_;
6602 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6603 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6605 get {
if ((_hasBits4 & 33554432) != 0) {
return fillAdditionalSolutionsInResponse_; }
else {
return FillAdditionalSolutionsInResponseDefaultValue; } }
6607 _hasBits4 |= 33554432;
6608 fillAdditionalSolutionsInResponse_ = value;
6612 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6613 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6614 public bool HasFillAdditionalSolutionsInResponse {
6615 get {
return (_hasBits4 & 33554432) != 0; }
6618 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6619 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6621 _hasBits4 &= ~33554432;
6626 private readonly
static bool InstantiateAllVariablesDefaultValue =
true;
6628 private bool instantiateAllVariables_;
6635 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6636 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6638 get {
if ((_hasBits2 & 8192) != 0) {
return instantiateAllVariables_; }
else {
return InstantiateAllVariablesDefaultValue; } }
6641 instantiateAllVariables_ = value;
6645 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6646 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6647 public bool HasInstantiateAllVariables {
6648 get {
return (_hasBits2 & 8192) != 0; }
6651 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6652 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6653 public void ClearInstantiateAllVariables() {
6659 private readonly
static bool AutoDetectGreaterThanAtLeastOneOfDefaultValue =
true;
6661 private bool autoDetectGreaterThanAtLeastOneOf_;
6668 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6669 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6671 get {
if ((_hasBits2 & 64) != 0) {
return autoDetectGreaterThanAtLeastOneOf_; }
else {
return AutoDetectGreaterThanAtLeastOneOfDefaultValue; } }
6674 autoDetectGreaterThanAtLeastOneOf_ = value;
6678 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6679 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6680 public bool HasAutoDetectGreaterThanAtLeastOneOf {
6681 get {
return (_hasBits2 & 64) != 0; }
6684 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6685 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6686 public void ClearAutoDetectGreaterThanAtLeastOneOf() {
6692 private readonly
static bool StopAfterFirstSolutionDefaultValue =
false;
6694 private bool stopAfterFirstSolution_;
6698 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6699 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6701 get {
if ((_hasBits2 & 128) != 0) {
return stopAfterFirstSolution_; }
else {
return StopAfterFirstSolutionDefaultValue; } }
6704 stopAfterFirstSolution_ = value;
6708 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6709 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6710 public bool HasStopAfterFirstSolution {
6711 get {
return (_hasBits2 & 128) != 0; }
6714 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6715 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6721 public const int StopAfterPresolveFieldNumber = 149;
6722 private readonly
static bool StopAfterPresolveDefaultValue =
false;
6724 private bool stopAfterPresolve_;
6729 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6730 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6732 get {
if ((_hasBits3 & 131072) != 0) {
return stopAfterPresolve_; }
else {
return StopAfterPresolveDefaultValue; } }
6734 _hasBits3 |= 131072;
6735 stopAfterPresolve_ = value;
6739 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6740 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6741 public bool HasStopAfterPresolve {
6742 get {
return (_hasBits3 & 131072) != 0; }
6745 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6746 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6748 _hasBits3 &= ~131072;
6752 public const int StopAfterRootPropagationFieldNumber = 252;
6753 private readonly
static bool StopAfterRootPropagationDefaultValue =
false;
6755 private bool stopAfterRootPropagation_;
6756 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6757 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6759 get {
if ((_hasBits6 & 16) != 0) {
return stopAfterRootPropagation_; }
else {
return StopAfterRootPropagationDefaultValue; } }
6762 stopAfterRootPropagation_ = value;
6766 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6767 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6769 get {
return (_hasBits6 & 16) != 0; }
6772 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6773 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6774 public void ClearStopAfterRootPropagation() {
6779 public const int LnsInitialDifficultyFieldNumber = 307;
6780 private readonly
static double LnsInitialDifficultyDefaultValue = 0.5D;
6782 private double lnsInitialDifficulty_;
6786 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6787 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6789 get {
if ((_hasBits7 & 33554432) != 0) {
return lnsInitialDifficulty_; }
else {
return LnsInitialDifficultyDefaultValue; } }
6791 _hasBits7 |= 33554432;
6792 lnsInitialDifficulty_ = value;
6796 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6797 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6799 get {
return (_hasBits7 & 33554432) != 0; }
6802 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6803 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6805 _hasBits7 &= ~33554432;
6809 public const int LnsInitialDeterministicLimitFieldNumber = 308;
6810 private readonly
static double LnsInitialDeterministicLimitDefaultValue = 0.1D;
6812 private double lnsInitialDeterministicLimit_;
6813 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6814 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6816 get {
if ((_hasBits7 & 67108864) != 0) {
return lnsInitialDeterministicLimit_; }
else {
return LnsInitialDeterministicLimitDefaultValue; } }
6818 _hasBits7 |= 67108864;
6819 lnsInitialDeterministicLimit_ = value;
6823 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6824 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6826 get {
return (_hasBits7 & 67108864) != 0; }
6829 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6830 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6831 public void ClearLnsInitialDeterministicLimit() {
6832 _hasBits7 &= ~67108864;
6836 public const int UseLnsFieldNumber = 283;
6837 private readonly
static bool UseLnsDefaultValue =
true;
6839 private bool useLns_;
6843 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6844 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6846 get {
if ((_hasBits7 & 4) != 0) {
return useLns_; }
else {
return UseLnsDefaultValue; } }
6853 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6854 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6856 get {
return (_hasBits7 & 4) != 0; }
6859 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6860 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6866 public const int UseLnsOnlyFieldNumber = 101;
6867 private readonly
static bool UseLnsOnlyDefaultValue =
false;
6869 private bool useLnsOnly_;
6873 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6874 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6876 get {
if ((_hasBits2 & 1024) != 0) {
return useLnsOnly_; }
else {
return UseLnsOnlyDefaultValue; } }
6879 useLnsOnly_ = value;
6883 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6884 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6885 public bool HasUseLnsOnly {
6886 get {
return (_hasBits2 & 1024) != 0; }
6889 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6890 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6896 public const int SolutionPoolSizeFieldNumber = 193;
6897 private readonly
static int SolutionPoolSizeDefaultValue = 3;
6899 private int solutionPoolSize_;
6905 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6906 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6908 get {
if ((_hasBits4 & 16777216) != 0) {
return solutionPoolSize_; }
else {
return SolutionPoolSizeDefaultValue; } }
6910 _hasBits4 |= 16777216;
6911 solutionPoolSize_ = value;
6915 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6916 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6917 public bool HasSolutionPoolSize {
6918 get {
return (_hasBits4 & 16777216) != 0; }
6921 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6922 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6923 public void ClearSolutionPoolSize() {
6924 _hasBits4 &= ~16777216;
6928 public const int UseRinsLnsFieldNumber = 129;
6929 private readonly
static bool UseRinsLnsDefaultValue =
true;
6931 private bool useRinsLns_;
6935 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6936 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6938 get {
if ((_hasBits3 & 4) != 0) {
return useRinsLns_; }
else {
return UseRinsLnsDefaultValue; } }
6941 useRinsLns_ = value;
6945 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6946 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6947 public bool HasUseRinsLns {
6948 get {
return (_hasBits3 & 4) != 0; }
6951 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6952 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6958 public const int UseFeasibilityPumpFieldNumber = 164;
6959 private readonly
static bool UseFeasibilityPumpDefaultValue =
true;
6961 private bool useFeasibilityPump_;
6965 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6966 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6968 get {
if ((_hasBits3 & 1073741824) != 0) {
return useFeasibilityPump_; }
else {
return UseFeasibilityPumpDefaultValue; } }
6970 _hasBits3 |= 1073741824;
6971 useFeasibilityPump_ = value;
6975 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6976 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6977 public bool HasUseFeasibilityPump {
6978 get {
return (_hasBits3 & 1073741824) != 0; }
6981 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6982 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6984 _hasBits3 &= ~1073741824;
6988 public const int UseLbRelaxLnsFieldNumber = 255;
6989 private readonly
static bool UseLbRelaxLnsDefaultValue =
true;
6991 private bool useLbRelaxLns_;
6997 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6998 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7000 get {
if ((_hasBits6 & 64) != 0) {
return useLbRelaxLns_; }
else {
return UseLbRelaxLnsDefaultValue; } }
7003 useLbRelaxLns_ = value;
7007 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7008 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7009 public bool HasUseLbRelaxLns {
7010 get {
return (_hasBits6 & 64) != 0; }
7013 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7014 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7015 public void ClearUseLbRelaxLns() {
7020 public const int LbRelaxNumWorkersThresholdFieldNumber = 296;
7021 private readonly
static int LbRelaxNumWorkersThresholdDefaultValue = 16;
7023 private int lbRelaxNumWorkersThreshold_;
7027 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7028 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7030 get {
if ((_hasBits7 & 16384) != 0) {
return lbRelaxNumWorkersThreshold_; }
else {
return LbRelaxNumWorkersThresholdDefaultValue; } }
7033 lbRelaxNumWorkersThreshold_ = value;
7037 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7038 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7039 public bool HasLbRelaxNumWorkersThreshold {
7040 get {
return (_hasBits7 & 16384) != 0; }
7043 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7044 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7046 _hasBits7 &= ~16384;
7050 public const int FpRoundingFieldNumber = 165;
7051 private readonly
static global::Google.OrTools.Sat.SatParameters.Types.FPRoundingMethod FpRoundingDefaultValue = global::Google.OrTools.Sat.SatParameters.Types.FPRoundingMethod.PropagationAssisted;
7053 private global::Google.OrTools.Sat.SatParameters.Types.FPRoundingMethod fpRounding_;
7054 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7055 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7056 public global::Google.OrTools.Sat.SatParameters.Types.FPRoundingMethod
FpRounding {
7057 get {
if ((_hasBits3 & -2147483648) != 0) {
return fpRounding_; }
else {
return FpRoundingDefaultValue; } }
7059 _hasBits3 |= -2147483648;
7060 fpRounding_ = value;
7064 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7065 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7067 get {
return (_hasBits3 & -2147483648) != 0; }
7070 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7071 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7072 public void ClearFpRounding() {
7073 _hasBits3 &= ~-2147483648;
7077 public const int DiversifyLnsParamsFieldNumber = 137;
7078 private readonly
static bool DiversifyLnsParamsDefaultValue =
false;
7080 private bool diversifyLnsParams_;
7084 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7085 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7087 get {
if ((_hasBits3 & 1024) != 0) {
return diversifyLnsParams_; }
else {
return DiversifyLnsParamsDefaultValue; } }
7090 diversifyLnsParams_ = value;
7094 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7095 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7097 get {
return (_hasBits3 & 1024) != 0; }
7100 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7101 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7107 public const int RandomizeSearchFieldNumber = 103;
7108 private readonly
static bool RandomizeSearchDefaultValue =
false;
7110 private bool randomizeSearch_;
7114 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7115 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7117 get {
if ((_hasBits2 & 2048) != 0) {
return randomizeSearch_; }
else {
return RandomizeSearchDefaultValue; } }
7120 randomizeSearch_ = value;
7124 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7125 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7126 public bool HasRandomizeSearch {
7127 get {
return (_hasBits2 & 2048) != 0; }
7130 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7131 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7137 public const int SearchRandomVariablePoolSizeFieldNumber = 104;
7138 private readonly
static long SearchRandomVariablePoolSizeDefaultValue = 0L;
7140 private long searchRandomVariablePoolSize_;
7146 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7147 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7149 get {
if ((_hasBits2 & 4096) != 0) {
return searchRandomVariablePoolSize_; }
else {
return SearchRandomVariablePoolSizeDefaultValue; } }
7152 searchRandomVariablePoolSize_ = value;
7156 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7157 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7158 public bool HasSearchRandomVariablePoolSize {
7159 get {
return (_hasBits2 & 4096) != 0; }
7162 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7163 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7164 public void ClearSearchRandomVariablePoolSize() {
7169 public const int PushAllTasksTowardStartFieldNumber = 262;
7170 private readonly
static bool PushAllTasksTowardStartDefaultValue =
false;
7172 private bool pushAllTasksTowardStart_;
7177 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7178 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7180 get {
if ((_hasBits6 & 8192) != 0) {
return pushAllTasksTowardStart_; }
else {
return PushAllTasksTowardStartDefaultValue; } }
7183 pushAllTasksTowardStart_ = value;
7187 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7188 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7189 public bool HasPushAllTasksTowardStart {
7190 get {
return (_hasBits6 & 8192) != 0; }
7193 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7194 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7200 public const int UseOptionalVariablesFieldNumber = 108;
7201 private readonly
static bool UseOptionalVariablesDefaultValue =
false;
7203 private bool useOptionalVariables_;
7212 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7213 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7215 get {
if ((_hasBits2 & 32768) != 0) {
return useOptionalVariables_; }
else {
return UseOptionalVariablesDefaultValue; } }
7218 useOptionalVariables_ = value;
7222 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7223 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7225 get {
return (_hasBits2 & 32768) != 0; }
7228 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7229 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7230 public void ClearUseOptionalVariables() {
7231 _hasBits2 &= ~32768;
7236 private readonly
static bool UseExactLpReasonDefaultValue =
true;
7238 private bool useExactLpReason_;
7245 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7246 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7248 get {
if ((_hasBits2 & 65536) != 0) {
return useExactLpReason_; }
else {
return UseExactLpReasonDefaultValue; } }
7251 useExactLpReason_ = value;
7255 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7256 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7257 public bool HasUseExactLpReason {
7258 get {
return (_hasBits2 & 65536) != 0; }
7261 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7262 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7263 public void ClearUseExactLpReason() {
7264 _hasBits2 &= ~65536;
7268 public const int UseCombinedNoOverlapFieldNumber = 133;
7269 private readonly
static bool UseCombinedNoOverlapDefaultValue =
false;
7271 private bool useCombinedNoOverlap_;
7277 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7278 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7280 get {
if ((_hasBits3 & 64) != 0) {
return useCombinedNoOverlap_; }
else {
return UseCombinedNoOverlapDefaultValue; } }
7283 useCombinedNoOverlap_ = value;
7287 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7288 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7289 public bool HasUseCombinedNoOverlap {
7290 get {
return (_hasBits3 & 64) != 0; }
7293 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7294 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7300 public const int AtMostOneMaxExpansionSizeFieldNumber = 270;
7301 private readonly
static int AtMostOneMaxExpansionSizeDefaultValue = 3;
7303 private int atMostOneMaxExpansionSize_;
7308 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7309 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7311 get {
if ((_hasBits6 & 2097152) != 0) {
return atMostOneMaxExpansionSize_; }
else {
return AtMostOneMaxExpansionSizeDefaultValue; } }
7313 _hasBits6 |= 2097152;
7314 atMostOneMaxExpansionSize_ = value;
7318 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7319 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7320 public bool HasAtMostOneMaxExpansionSize {
7321 get {
return (_hasBits6 & 2097152) != 0; }
7324 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7325 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7327 _hasBits6 &= ~2097152;
7331 public const int CatchSigintSignalFieldNumber = 135;
7332 private readonly
static bool CatchSigintSignalDefaultValue =
true;
7334 private bool catchSigintSignal_;
7340 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7341 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7343 get {
if ((_hasBits3 & 256) != 0) {
return catchSigintSignal_; }
else {
return CatchSigintSignalDefaultValue; } }
7346 catchSigintSignal_ = value;
7350 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7351 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7352 public bool HasCatchSigintSignal {
7353 get {
return (_hasBits3 & 256) != 0; }
7356 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7357 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7363 public const int UseImpliedBoundsFieldNumber = 144;
7364 private readonly
static bool UseImpliedBoundsDefaultValue =
true;
7366 private bool useImpliedBounds_;
7372 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7373 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7375 get {
if ((_hasBits3 & 4096) != 0) {
return useImpliedBounds_; }
else {
return UseImpliedBoundsDefaultValue; } }
7378 useImpliedBounds_ = value;
7382 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7383 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7384 public bool HasUseImpliedBounds {
7385 get {
return (_hasBits3 & 4096) != 0; }
7388 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7389 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7395 public const int PolishLpSolutionFieldNumber = 175;
7396 private readonly
static bool PolishLpSolutionDefaultValue =
false;
7398 private bool polishLpSolution_;
7405 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7406 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7408 get {
if ((_hasBits4 & 256) != 0) {
return polishLpSolution_; }
else {
return PolishLpSolutionDefaultValue; } }
7411 polishLpSolution_ = value;
7415 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7416 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7417 public bool HasPolishLpSolution {
7418 get {
return (_hasBits4 & 256) != 0; }
7421 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7422 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7423 public void ClearPolishLpSolution() {
7428 public const int LpPrimalToleranceFieldNumber = 266;
7429 private readonly
static double LpPrimalToleranceDefaultValue = 1e-07D;
7431 private double lpPrimalTolerance_;
7439 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7440 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7442 get {
if ((_hasBits6 & 131072) != 0) {
return lpPrimalTolerance_; }
else {
return LpPrimalToleranceDefaultValue; } }
7444 _hasBits6 |= 131072;
7445 lpPrimalTolerance_ = value;
7449 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7450 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7451 public bool HasLpPrimalTolerance {
7452 get {
return (_hasBits6 & 131072) != 0; }
7455 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7456 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7457 public void ClearLpPrimalTolerance() {
7458 _hasBits6 &= ~131072;
7463 private readonly
static double LpDualToleranceDefaultValue = 1e-07D;
7465 private double lpDualTolerance_;
7466 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7467 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7469 get {
if ((_hasBits6 & 262144) != 0) {
return lpDualTolerance_; }
else {
return LpDualToleranceDefaultValue; } }
7471 _hasBits6 |= 262144;
7472 lpDualTolerance_ = value;
7476 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7477 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7478 public bool HasLpDualTolerance {
7479 get {
return (_hasBits6 & 262144) != 0; }
7482 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7483 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7484 public void ClearLpDualTolerance() {
7485 _hasBits6 &= ~262144;
7489 public const int ConvertIntervalsFieldNumber = 177;
7490 private readonly
static bool ConvertIntervalsDefaultValue =
true;
7492 private bool convertIntervals_;
7498 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7499 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7501 get {
if ((_hasBits4 & 1024) != 0) {
return convertIntervals_; }
else {
return ConvertIntervalsDefaultValue; } }
7504 convertIntervals_ = value;
7508 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7509 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7511 get {
return (_hasBits4 & 1024) != 0; }
7514 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7515 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7521 public const int SymmetryLevelFieldNumber = 183;
7522 private readonly
static int SymmetryLevelDefaultValue = 2;
7524 private int symmetryLevel_;
7533 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7534 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7536 get {
if ((_hasBits4 & 65536) != 0) {
return symmetryLevel_; }
else {
return SymmetryLevelDefaultValue; } }
7539 symmetryLevel_ = value;
7543 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7544 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7546 get {
return (_hasBits4 & 65536) != 0; }
7549 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7550 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7551 public void ClearSymmetryLevel() {
7552 _hasBits4 &= ~65536;
7557 private readonly
static bool UseSymmetryInLpDefaultValue =
false;
7559 private bool useSymmetryInLp_;
7567 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7568 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7570 get {
if ((_hasBits7 & 524288) != 0) {
return useSymmetryInLp_; }
else {
return UseSymmetryInLpDefaultValue; } }
7572 _hasBits7 |= 524288;
7573 useSymmetryInLp_ = value;
7577 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7578 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7579 public bool HasUseSymmetryInLp {
7580 get {
return (_hasBits7 & 524288) != 0; }
7583 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7584 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7585 public void ClearUseSymmetryInLp() {
7586 _hasBits7 &= ~524288;
7591 private readonly
static bool KeepSymmetryInPresolveDefaultValue =
false;
7593 private bool keepSymmetryInPresolve_;
7600 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7601 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7603 get {
if ((_hasBits7 & 2097152) != 0) {
return keepSymmetryInPresolve_; }
else {
return KeepSymmetryInPresolveDefaultValue; } }
7605 _hasBits7 |= 2097152;
7606 keepSymmetryInPresolve_ = value;
7610 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7611 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7612 public bool HasKeepSymmetryInPresolve {
7613 get {
return (_hasBits7 & 2097152) != 0; }
7616 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7617 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7618 public void ClearKeepSymmetryInPresolve() {
7619 _hasBits7 &= ~2097152;
7623 public const int SymmetryDetectionDeterministicTimeLimitFieldNumber = 302;
7624 private readonly
static double SymmetryDetectionDeterministicTimeLimitDefaultValue = 1D;
7626 private double symmetryDetectionDeterministicTimeLimit_;
7630 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7631 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7633 get {
if ((_hasBits7 & 1048576) != 0) {
return symmetryDetectionDeterministicTimeLimit_; }
else {
return SymmetryDetectionDeterministicTimeLimitDefaultValue; } }
7635 _hasBits7 |= 1048576;
7636 symmetryDetectionDeterministicTimeLimit_ = value;
7640 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7641 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7642 public bool HasSymmetryDetectionDeterministicTimeLimit {
7643 get {
return (_hasBits7 & 1048576) != 0; }
7646 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7647 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7649 _hasBits7 &= ~1048576;
7653 public const int NewLinearPropagationFieldNumber = 224;
7654 private readonly
static bool NewLinearPropagationDefaultValue =
true;
7656 private bool newLinearPropagation_;
7662 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7663 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7665 get {
if ((_hasBits5 & 32768) != 0) {
return newLinearPropagation_; }
else {
return NewLinearPropagationDefaultValue; } }
7668 newLinearPropagation_ = value;
7672 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7673 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7674 public bool HasNewLinearPropagation {
7675 get {
return (_hasBits5 & 32768) != 0; }
7678 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7679 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7681 _hasBits5 &= ~32768;
7685 public const int LinearSplitSizeFieldNumber = 256;
7686 private readonly
static int LinearSplitSizeDefaultValue = 100;
7688 private int linearSplitSize_;
7694 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7695 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7697 get {
if ((_hasBits6 & 128) != 0) {
return linearSplitSize_; }
else {
return LinearSplitSizeDefaultValue; } }
7700 linearSplitSize_ = value;
7704 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7705 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7706 public bool HasLinearSplitSize {
7707 get {
return (_hasBits6 & 128) != 0; }
7710 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7711 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7717 public const int LinearizationLevelFieldNumber = 90;
7718 private readonly
static int LinearizationLevelDefaultValue = 1;
7720 private int linearizationLevel_;
7727 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7728 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7730 get {
if ((_hasBits2 & 2) != 0) {
return linearizationLevel_; }
else {
return LinearizationLevelDefaultValue; } }
7733 linearizationLevel_ = value;
7737 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7738 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7739 public bool HasLinearizationLevel {
7740 get {
return (_hasBits2 & 2) != 0; }
7743 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7744 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7745 public void ClearLinearizationLevel() {
7750 public const int BooleanEncodingLevelFieldNumber = 107;
7751 private readonly
static int BooleanEncodingLevelDefaultValue = 1;
7753 private int booleanEncodingLevel_;
7758 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7759 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7761 get {
if ((_hasBits2 & 16384) != 0) {
return booleanEncodingLevel_; }
else {
return BooleanEncodingLevelDefaultValue; } }
7764 booleanEncodingLevel_ = value;
7768 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7769 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7770 public bool HasBooleanEncodingLevel {
7771 get {
return (_hasBits2 & 16384) != 0; }
7774 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7775 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7777 _hasBits2 &= ~16384;
7781 public const int MaxDomainSizeWhenEncodingEqNeqConstraintsFieldNumber = 191;
7782 private readonly
static int MaxDomainSizeWhenEncodingEqNeqConstraintsDefaultValue = 16;
7784 private int maxDomainSizeWhenEncodingEqNeqConstraints_;
7791 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7792 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7794 get {
if ((_hasBits4 & 4194304) != 0) {
return maxDomainSizeWhenEncodingEqNeqConstraints_; }
else {
return MaxDomainSizeWhenEncodingEqNeqConstraintsDefaultValue; } }
7796 _hasBits4 |= 4194304;
7797 maxDomainSizeWhenEncodingEqNeqConstraints_ = value;
7801 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7802 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7803 public bool HasMaxDomainSizeWhenEncodingEqNeqConstraints {
7804 get {
return (_hasBits4 & 4194304) != 0; }
7807 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7808 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7809 public void ClearMaxDomainSizeWhenEncodingEqNeqConstraints() {
7810 _hasBits4 &= ~4194304;
7814 public const int MaxNumCutsFieldNumber = 91;
7815 private readonly
static int MaxNumCutsDefaultValue = 10000;
7817 private int maxNumCuts_;
7825 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7826 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7828 get {
if ((_hasBits2 & 4) != 0) {
return maxNumCuts_; }
else {
return MaxNumCutsDefaultValue; } }
7831 maxNumCuts_ = value;
7835 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7836 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7837 public bool HasMaxNumCuts {
7838 get {
return (_hasBits2 & 4) != 0; }
7841 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7842 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7843 public void ClearMaxNumCuts() {
7849 private readonly
static int CutLevelDefaultValue = 1;
7851 private int cutLevel_;
7857 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7858 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7860 get {
if ((_hasBits4 & 134217728) != 0) {
return cutLevel_; }
else {
return CutLevelDefaultValue; } }
7862 _hasBits4 |= 134217728;
7867 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7868 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7869 public bool HasCutLevel {
7870 get {
return (_hasBits4 & 134217728) != 0; }
7873 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7874 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7876 _hasBits4 &= ~134217728;
7880 public const int OnlyAddCutsAtLevelZeroFieldNumber = 92;
7881 private readonly
static bool OnlyAddCutsAtLevelZeroDefaultValue =
false;
7883 private bool onlyAddCutsAtLevelZero_;
7888 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7889 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7891 get {
if ((_hasBits2 & 8) != 0) {
return onlyAddCutsAtLevelZero_; }
else {
return OnlyAddCutsAtLevelZeroDefaultValue; } }
7894 onlyAddCutsAtLevelZero_ = value;
7898 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7899 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7900 public bool HasOnlyAddCutsAtLevelZero {
7901 get {
return (_hasBits2 & 8) != 0; }
7904 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7905 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7911 public const int AddObjectiveCutFieldNumber = 197;
7912 private readonly
static bool AddObjectiveCutDefaultValue =
false;
7914 private bool addObjectiveCut_;
7922 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7923 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7925 get {
if ((_hasBits4 & 268435456) != 0) {
return addObjectiveCut_; }
else {
return AddObjectiveCutDefaultValue; } }
7927 _hasBits4 |= 268435456;
7928 addObjectiveCut_ = value;
7932 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7933 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7934 public bool HasAddObjectiveCut {
7935 get {
return (_hasBits4 & 268435456) != 0; }
7938 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7939 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7940 public void ClearAddObjectiveCut() {
7941 _hasBits4 &= ~268435456;
7945 public const int AddCgCutsFieldNumber = 117;
7946 private readonly
static bool AddCgCutsDefaultValue =
true;
7948 private bool addCgCuts_;
7953 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7954 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7956 get {
if ((_hasBits2 & 8388608) != 0) {
return addCgCuts_; }
else {
return AddCgCutsDefaultValue; } }
7958 _hasBits2 |= 8388608;
7963 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7964 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7965 public bool HasAddCgCuts {
7966 get {
return (_hasBits2 & 8388608) != 0; }
7969 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7970 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7972 _hasBits2 &= ~8388608;
7976 public const int AddMirCutsFieldNumber = 120;
7977 private readonly
static bool AddMirCutsDefaultValue =
true;
7979 private bool addMirCuts_;
7984 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7985 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7987 get {
if ((_hasBits2 & 33554432) != 0) {
return addMirCuts_; }
else {
return AddMirCutsDefaultValue; } }
7989 _hasBits2 |= 33554432;
7990 addMirCuts_ = value;
7994 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7995 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7996 public bool HasAddMirCuts {
7997 get {
return (_hasBits2 & 33554432) != 0; }
8000 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8001 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8003 _hasBits2 &= ~33554432;
8007 public const int AddZeroHalfCutsFieldNumber = 169;
8008 private readonly
static bool AddZeroHalfCutsDefaultValue =
true;
8010 private bool addZeroHalfCuts_;
8015 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8016 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8018 get {
if ((_hasBits4 & 8) != 0) {
return addZeroHalfCuts_; }
else {
return AddZeroHalfCutsDefaultValue; } }
8021 addZeroHalfCuts_ = value;
8025 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8026 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8027 public bool HasAddZeroHalfCuts {
8028 get {
return (_hasBits4 & 8) != 0; }
8031 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8032 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8038 public const int AddCliqueCutsFieldNumber = 172;
8039 private readonly
static bool AddCliqueCutsDefaultValue =
true;
8041 private bool addCliqueCuts_;
8047 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8048 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8050 get {
if ((_hasBits4 & 32) != 0) {
return addCliqueCuts_; }
else {
return AddCliqueCutsDefaultValue; } }
8053 addCliqueCuts_ = value;
8057 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8058 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8059 public bool HasAddCliqueCuts {
8060 get {
return (_hasBits4 & 32) != 0; }
8063 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8064 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8070 public const int AddRltCutsFieldNumber = 279;
8071 private readonly
static bool AddRltCutsDefaultValue =
true;
8073 private bool addRltCuts_;
8078 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8079 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8081 get {
if ((_hasBits6 & 1073741824) != 0) {
return addRltCuts_; }
else {
return AddRltCutsDefaultValue; } }
8083 _hasBits6 |= 1073741824;
8084 addRltCuts_ = value;
8088 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8089 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8090 public bool HasAddRltCuts {
8091 get {
return (_hasBits6 & 1073741824) != 0; }
8094 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8095 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8097 _hasBits6 &= ~1073741824;
8101 public const int MaxAllDiffCutSizeFieldNumber = 148;
8102 private readonly
static int MaxAllDiffCutSizeDefaultValue = 64;
8104 private int maxAllDiffCutSize_;
8110 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8111 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8113 get {
if ((_hasBits3 & 65536) != 0) {
return maxAllDiffCutSize_; }
else {
return MaxAllDiffCutSizeDefaultValue; } }
8116 maxAllDiffCutSize_ = value;
8120 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8121 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8122 public bool HasMaxAllDiffCutSize {
8123 get {
return (_hasBits3 & 65536) != 0; }
8126 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8127 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8129 _hasBits3 &= ~65536;
8133 public const int AddLinMaxCutsFieldNumber = 152;
8134 private readonly
static bool AddLinMaxCutsDefaultValue =
true;
8136 private bool addLinMaxCuts_;
8142 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8143 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8145 get {
if ((_hasBits3 & 524288) != 0) {
return addLinMaxCuts_; }
else {
return AddLinMaxCutsDefaultValue; } }
8147 _hasBits3 |= 524288;
8148 addLinMaxCuts_ = value;
8152 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8153 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8154 public bool HasAddLinMaxCuts {
8155 get {
return (_hasBits3 & 524288) != 0; }
8158 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8159 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8161 _hasBits3 &= ~524288;
8165 public const int MaxIntegerRoundingScalingFieldNumber = 119;
8166 private readonly
static int MaxIntegerRoundingScalingDefaultValue = 600;
8168 private int maxIntegerRoundingScaling_;
8179 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8180 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8182 get {
if ((_hasBits2 & 16777216) != 0) {
return maxIntegerRoundingScaling_; }
else {
return MaxIntegerRoundingScalingDefaultValue; } }
8184 _hasBits2 |= 16777216;
8185 maxIntegerRoundingScaling_ = value;
8189 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8190 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8192 get {
return (_hasBits2 & 16777216) != 0; }
8195 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8196 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8197 public void ClearMaxIntegerRoundingScaling() {
8198 _hasBits2 &= ~16777216;
8203 private readonly
static bool AddLpConstraintsLazilyDefaultValue =
true;
8205 private bool addLpConstraintsLazily_;
8212 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8213 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8215 get {
if ((_hasBits2 & 262144) != 0) {
return addLpConstraintsLazily_; }
else {
return AddLpConstraintsLazilyDefaultValue; } }
8217 _hasBits2 |= 262144;
8218 addLpConstraintsLazily_ = value;
8222 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8223 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8224 public bool HasAddLpConstraintsLazily {
8225 get {
return (_hasBits2 & 262144) != 0; }
8228 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8229 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8231 _hasBits2 &= ~262144;
8235 public const int RootLpIterationsFieldNumber = 227;
8236 private readonly
static int RootLpIterationsDefaultValue = 2000;
8238 private int rootLpIterations_;
8245 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8246 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8248 get {
if ((_hasBits5 & 262144) != 0) {
return rootLpIterations_; }
else {
return RootLpIterationsDefaultValue; } }
8250 _hasBits5 |= 262144;
8251 rootLpIterations_ = value;
8255 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8256 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8257 public bool HasRootLpIterations {
8258 get {
return (_hasBits5 & 262144) != 0; }
8261 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8262 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8264 _hasBits5 &= ~262144;
8268 public const int MinOrthogonalityForLpConstraintsFieldNumber = 115;
8269 private readonly
static double MinOrthogonalityForLpConstraintsDefaultValue = 0.05D;
8271 private double minOrthogonalityForLpConstraints_;
8279 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8280 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8282 get {
if ((_hasBits2 & 2097152) != 0) {
return minOrthogonalityForLpConstraints_; }
else {
return MinOrthogonalityForLpConstraintsDefaultValue; } }
8284 _hasBits2 |= 2097152;
8285 minOrthogonalityForLpConstraints_ = value;
8289 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8290 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8291 public bool HasMinOrthogonalityForLpConstraints {
8292 get {
return (_hasBits2 & 2097152) != 0; }
8295 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8296 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8298 _hasBits2 &= ~2097152;
8302 public const int MaxCutRoundsAtLevelZeroFieldNumber = 154;
8303 private readonly
static int MaxCutRoundsAtLevelZeroDefaultValue = 1;
8305 private int maxCutRoundsAtLevelZero_;
8309 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8310 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8312 get {
if ((_hasBits3 & 2097152) != 0) {
return maxCutRoundsAtLevelZero_; }
else {
return MaxCutRoundsAtLevelZeroDefaultValue; } }
8314 _hasBits3 |= 2097152;
8315 maxCutRoundsAtLevelZero_ = value;
8319 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8320 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8321 public bool HasMaxCutRoundsAtLevelZero {
8322 get {
return (_hasBits3 & 2097152) != 0; }
8325 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8326 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8327 public void ClearMaxCutRoundsAtLevelZero() {
8328 _hasBits3 &= ~2097152;
8332 public const int MaxConsecutiveInactiveCountFieldNumber = 121;
8333 private readonly
static int MaxConsecutiveInactiveCountDefaultValue = 100;
8335 private int maxConsecutiveInactiveCount_;
8341 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8342 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8344 get {
if ((_hasBits2 & 67108864) != 0) {
return maxConsecutiveInactiveCount_; }
else {
return MaxConsecutiveInactiveCountDefaultValue; } }
8346 _hasBits2 |= 67108864;
8347 maxConsecutiveInactiveCount_ = value;
8351 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8352 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8353 public bool HasMaxConsecutiveInactiveCount {
8354 get {
return (_hasBits2 & 67108864) != 0; }
8357 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8358 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8360 _hasBits2 &= ~67108864;
8364 public const int CutMaxActiveCountValueFieldNumber = 155;
8365 private readonly
static double CutMaxActiveCountValueDefaultValue = 1e+10D;
8367 private double cutMaxActiveCountValue_;
8373 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8374 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8376 get {
if ((_hasBits3 & 4194304) != 0) {
return cutMaxActiveCountValue_; }
else {
return CutMaxActiveCountValueDefaultValue; } }
8378 _hasBits3 |= 4194304;
8379 cutMaxActiveCountValue_ = value;
8383 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8384 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8385 public bool HasCutMaxActiveCountValue {
8386 get {
return (_hasBits3 & 4194304) != 0; }
8389 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8390 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8392 _hasBits3 &= ~4194304;
8396 public const int CutActiveCountDecayFieldNumber = 156;
8397 private readonly
static double CutActiveCountDecayDefaultValue = 0.8D;
8399 private double cutActiveCountDecay_;
8400 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8401 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8403 get {
if ((_hasBits3 & 8388608) != 0) {
return cutActiveCountDecay_; }
else {
return CutActiveCountDecayDefaultValue; } }
8405 _hasBits3 |= 8388608;
8406 cutActiveCountDecay_ = value;
8410 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8411 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8413 get {
return (_hasBits3 & 8388608) != 0; }
8416 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8417 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8418 public void ClearCutActiveCountDecay() {
8419 _hasBits3 &= ~8388608;
8424 private readonly
static int CutCleanupTargetDefaultValue = 1000;
8426 private int cutCleanupTarget_;
8430 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8431 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8433 get {
if ((_hasBits3 & 16777216) != 0) {
return cutCleanupTarget_; }
else {
return CutCleanupTargetDefaultValue; } }
8435 _hasBits3 |= 16777216;
8436 cutCleanupTarget_ = value;
8440 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8441 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8442 public bool HasCutCleanupTarget {
8443 get {
return (_hasBits3 & 16777216) != 0; }
8446 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8447 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8448 public void ClearCutCleanupTarget() {
8449 _hasBits3 &= ~16777216;
8453 public const int NewConstraintsBatchSizeFieldNumber = 122;
8454 private readonly
static int NewConstraintsBatchSizeDefaultValue = 50;
8456 private int newConstraintsBatchSize_;
8461 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8462 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8464 get {
if ((_hasBits2 & 134217728) != 0) {
return newConstraintsBatchSize_; }
else {
return NewConstraintsBatchSizeDefaultValue; } }
8466 _hasBits2 |= 134217728;
8467 newConstraintsBatchSize_ = value;
8471 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8472 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8474 get {
return (_hasBits2 & 134217728) != 0; }
8477 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8478 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8480 _hasBits2 &= ~134217728;
8484 public const int ExploitIntegerLpSolutionFieldNumber = 94;
8485 private readonly
static bool ExploitIntegerLpSolutionDefaultValue =
true;
8487 private bool exploitIntegerLpSolution_;
8494 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8495 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8497 get {
if ((_hasBits2 & 32) != 0) {
return exploitIntegerLpSolution_; }
else {
return ExploitIntegerLpSolutionDefaultValue; } }
8500 exploitIntegerLpSolution_ = value;
8504 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8505 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8506 public bool HasExploitIntegerLpSolution {
8507 get {
return (_hasBits2 & 32) != 0; }
8510 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8511 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8517 public const int ExploitAllLpSolutionFieldNumber = 116;
8518 private readonly
static bool ExploitAllLpSolutionDefaultValue =
true;
8520 private bool exploitAllLpSolution_;
8526 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8527 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8529 get {
if ((_hasBits2 & 4194304) != 0) {
return exploitAllLpSolution_; }
else {
return ExploitAllLpSolutionDefaultValue; } }
8531 _hasBits2 |= 4194304;
8532 exploitAllLpSolution_ = value;
8536 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8537 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8538 public bool HasExploitAllLpSolution {
8539 get {
return (_hasBits2 & 4194304) != 0; }
8542 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8543 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8545 _hasBits2 &= ~4194304;
8549 public const int ExploitBestSolutionFieldNumber = 130;
8550 private readonly
static bool ExploitBestSolutionDefaultValue =
false;
8552 private bool exploitBestSolution_;
8556 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8557 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8559 get {
if ((_hasBits3 & 8) != 0) {
return exploitBestSolution_; }
else {
return ExploitBestSolutionDefaultValue; } }
8562 exploitBestSolution_ = value;
8566 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8567 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8568 public bool HasExploitBestSolution {
8569 get {
return (_hasBits3 & 8) != 0; }
8572 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8573 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8574 public void ClearExploitBestSolution() {
8579 public const int ExploitRelaxationSolutionFieldNumber = 161;
8580 private readonly
static bool ExploitRelaxationSolutionDefaultValue =
false;
8582 private bool exploitRelaxationSolution_;
8588 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8589 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8591 get {
if ((_hasBits3 & 134217728) != 0) {
return exploitRelaxationSolution_; }
else {
return ExploitRelaxationSolutionDefaultValue; } }
8593 _hasBits3 |= 134217728;
8594 exploitRelaxationSolution_ = value;
8598 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8599 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8600 public bool HasExploitRelaxationSolution {
8601 get {
return (_hasBits3 & 134217728) != 0; }
8604 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8605 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8607 _hasBits3 &= ~134217728;
8611 public const int ExploitObjectiveFieldNumber = 131;
8612 private readonly
static bool ExploitObjectiveDefaultValue =
true;
8614 private bool exploitObjective_;
8619 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8620 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8622 get {
if ((_hasBits3 & 16) != 0) {
return exploitObjective_; }
else {
return ExploitObjectiveDefaultValue; } }
8625 exploitObjective_ = value;
8629 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8630 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8631 public bool HasExploitObjective {
8632 get {
return (_hasBits3 & 16) != 0; }
8635 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8636 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8642 public const int DetectLinearizedProductFieldNumber = 277;
8643 private readonly
static bool DetectLinearizedProductDefaultValue =
false;
8645 private bool detectLinearizedProduct_;
8651 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8652 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8654 get {
if ((_hasBits6 & 268435456) != 0) {
return detectLinearizedProduct_; }
else {
return DetectLinearizedProductDefaultValue; } }
8656 _hasBits6 |= 268435456;
8657 detectLinearizedProduct_ = value;
8661 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8662 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8663 public bool HasDetectLinearizedProduct {
8664 get {
return (_hasBits6 & 268435456) != 0; }
8667 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8668 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8670 _hasBits6 &= ~268435456;
8674 public const int MipMaxBoundFieldNumber = 124;
8675 private readonly
static double MipMaxBoundDefaultValue = 1e+07D;
8677 private double mipMaxBound_;
8683 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8684 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8686 get {
if ((_hasBits2 & 536870912) != 0) {
return mipMaxBound_; }
else {
return MipMaxBoundDefaultValue; } }
8688 _hasBits2 |= 536870912;
8689 mipMaxBound_ = value;
8693 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8694 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8695 public bool HasMipMaxBound {
8696 get {
return (_hasBits2 & 536870912) != 0; }
8699 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8700 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8702 _hasBits2 &= ~536870912;
8706 public const int MipVarScalingFieldNumber = 125;
8707 private readonly
static double MipVarScalingDefaultValue = 1D;
8709 private double mipVarScaling_;
8715 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8716 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8718 get {
if ((_hasBits2 & 1073741824) != 0) {
return mipVarScaling_; }
else {
return MipVarScalingDefaultValue; } }
8720 _hasBits2 |= 1073741824;
8721 mipVarScaling_ = value;
8725 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8726 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8727 public bool HasMipVarScaling {
8728 get {
return (_hasBits2 & 1073741824) != 0; }
8731 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8732 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8734 _hasBits2 &= ~1073741824;
8738 public const int MipScaleLargeDomainFieldNumber = 225;
8739 private readonly
static bool MipScaleLargeDomainDefaultValue =
false;
8741 private bool mipScaleLargeDomain_;
8747 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8748 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8750 get {
if ((_hasBits5 & 65536) != 0) {
return mipScaleLargeDomain_; }
else {
return MipScaleLargeDomainDefaultValue; } }
8753 mipScaleLargeDomain_ = value;
8757 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8758 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8759 public bool HasMipScaleLargeDomain {
8760 get {
return (_hasBits5 & 65536) != 0; }
8763 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8764 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8766 _hasBits5 &= ~65536;
8770 public const int MipAutomaticallyScaleVariablesFieldNumber = 166;
8771 private readonly
static bool MipAutomaticallyScaleVariablesDefaultValue =
true;
8773 private bool mipAutomaticallyScaleVariables_;
8781 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8782 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8784 get {
if ((_hasBits4 & 1) != 0) {
return mipAutomaticallyScaleVariables_; }
else {
return MipAutomaticallyScaleVariablesDefaultValue; } }
8787 mipAutomaticallyScaleVariables_ = value;
8791 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8792 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8793 public bool HasMipAutomaticallyScaleVariables {
8794 get {
return (_hasBits4 & 1) != 0; }
8797 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8798 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8804 public const int OnlySolveIpFieldNumber = 222;
8805 private readonly
static bool OnlySolveIpDefaultValue =
false;
8807 private bool onlySolveIp_;
8822 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8823 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8825 get {
if ((_hasBits5 & 8192) != 0) {
return onlySolveIp_; }
else {
return OnlySolveIpDefaultValue; } }
8828 onlySolveIp_ = value;
8832 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8833 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8834 public bool HasOnlySolveIp {
8835 get {
return (_hasBits5 & 8192) != 0; }
8838 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8839 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8845 public const int MipWantedPrecisionFieldNumber = 126;
8846 private readonly
static double MipWantedPrecisionDefaultValue = 1e-06D;
8848 private double mipWantedPrecision_;
8868 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8869 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8871 get {
if ((_hasBits2 & -2147483648) != 0) {
return mipWantedPrecision_; }
else {
return MipWantedPrecisionDefaultValue; } }
8873 _hasBits2 |= -2147483648;
8874 mipWantedPrecision_ = value;
8878 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8879 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8880 public bool HasMipWantedPrecision {
8881 get {
return (_hasBits2 & -2147483648) != 0; }
8884 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8885 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8887 _hasBits2 &= ~-2147483648;
8892 private readonly
static int MipMaxActivityExponentDefaultValue = 53;
8894 private int mipMaxActivityExponent_;
8905 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8906 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8908 get {
if ((_hasBits3 & 1) != 0) {
return mipMaxActivityExponent_; }
else {
return MipMaxActivityExponentDefaultValue; } }
8911 mipMaxActivityExponent_ = value;
8915 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8916 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8917 public bool HasMipMaxActivityExponent {
8918 get {
return (_hasBits3 & 1) != 0; }
8921 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8922 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8928 public const int MipCheckPrecisionFieldNumber = 128;
8929 private readonly
static double MipCheckPrecisionDefaultValue = 0.0001D;
8931 private double mipCheckPrecision_;
8937 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8938 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8940 get {
if ((_hasBits3 & 2) != 0) {
return mipCheckPrecision_; }
else {
return MipCheckPrecisionDefaultValue; } }
8943 mipCheckPrecision_ = value;
8947 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8948 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8949 public bool HasMipCheckPrecision {
8950 get {
return (_hasBits3 & 2) != 0; }
8953 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8954 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8955 public void ClearMipCheckPrecision() {
8961 private readonly
static bool MipComputeTrueObjectiveBoundDefaultValue =
true;
8963 private bool mipComputeTrueObjectiveBound_;
8971 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8972 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8974 get {
if ((_hasBits4 & 536870912) != 0) {
return mipComputeTrueObjectiveBound_; }
else {
return MipComputeTrueObjectiveBoundDefaultValue; } }
8976 _hasBits4 |= 536870912;
8977 mipComputeTrueObjectiveBound_ = value;
8981 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8982 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8984 get {
return (_hasBits4 & 536870912) != 0; }
8987 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8988 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8989 public void ClearMipComputeTrueObjectiveBound() {
8990 _hasBits4 &= ~536870912;
8995 private readonly
static double MipMaxValidMagnitudeDefaultValue = 1e+20D;
8997 private double mipMaxValidMagnitude_;
9005 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
9006 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
9008 get {
if ((_hasBits4 & 1073741824) != 0) {
return mipMaxValidMagnitude_; }
else {
return MipMaxValidMagnitudeDefaultValue; } }
9010 _hasBits4 |= 1073741824;
9011 mipMaxValidMagnitude_ = value;
9015 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
9016 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
9017 public bool HasMipMaxValidMagnitude {
9018 get {
return (_hasBits4 & 1073741824) != 0; }
9021 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
9022 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
9023 public void ClearMipMaxValidMagnitude() {
9024 _hasBits4 &= ~1073741824;
9029 private readonly
static bool MipTreatHighMagnitudeBoundsAsInfinityDefaultValue =
false;
9031 private bool mipTreatHighMagnitudeBoundsAsInfinity_;
9040 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
9041 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
9043 get {
if ((_hasBits6 & 536870912) != 0) {
return mipTreatHighMagnitudeBoundsAsInfinity_; }
else {
return MipTreatHighMagnitudeBoundsAsInfinityDefaultValue; } }
9045 _hasBits6 |= 536870912;
9046 mipTreatHighMagnitudeBoundsAsInfinity_ = value;
9050 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
9051 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
9052 public bool HasMipTreatHighMagnitudeBoundsAsInfinity {
9053 get {
return (_hasBits6 & 536870912) != 0; }
9056 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
9057 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
9058 public void ClearMipTreatHighMagnitudeBoundsAsInfinity() {
9059 _hasBits6 &= ~536870912;
9063 public const int MipDropToleranceFieldNumber = 232;
9064 private readonly
static double MipDropToleranceDefaultValue = 1e-16D;
9066 private double mipDropTolerance_;
9071 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
9072 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
9074 get {
if ((_hasBits5 & 4194304) != 0) {
return mipDropTolerance_; }
else {
return MipDropToleranceDefaultValue; } }
9076 _hasBits5 |= 4194304;
9077 mipDropTolerance_ = value;
9081 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
9082 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
9084 get {
return (_hasBits5 & 4194304) != 0; }
9087 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
9088 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
9089 public void ClearMipDropTolerance() {
9090 _hasBits5 &= ~4194304;
9094 public const int MipPresolveLevelFieldNumber = 261;
9095 private readonly
static int MipPresolveLevelDefaultValue = 2;
9097 private int mipPresolveLevel_;
9104 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
9105 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
9107 get {
if ((_hasBits6 & 4096) != 0) {
return mipPresolveLevel_; }
else {
return MipPresolveLevelDefaultValue; } }
9110 mipPresolveLevel_ = value;
9114 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
9115 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
9116 public bool HasMipPresolveLevel {
9117 get {
return (_hasBits6 & 4096) != 0; }
9120 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
9121 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
9122 public void ClearMipPresolveLevel() {
9126 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
9127 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
9128 public override bool Equals(
object other) {
9132 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
9133 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
9135 if (ReferenceEquals(other,
null)) {
9138 if (ReferenceEquals(other,
this)) {
9141 if (Name != other.
Name)
return false;
9170 if(!restartAlgorithms_.Equals(other.restartAlgorithms_))
return false;
9238 if(!subsolvers_.Equals(other.subsolvers_))
return false;
9239 if(!extraSubsolvers_.Equals(other.extraSubsolvers_))
return false;
9240 if(!ignoreSubsolvers_.Equals(other.ignoreSubsolvers_))
return false;
9241 if(!filterSubsolvers_.Equals(other.filterSubsolvers_))
return false;
9242 if(!subsolverParams_.Equals(other.subsolverParams_))
return false;
9395 if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(
MipMaxBound, other.
MipMaxBound))
return false;
9408 return Equals(_unknownFields, other._unknownFields);
9411 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
9412 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
9413 public override int GetHashCode() {
9415 if (HasName) hash ^= Name.GetHashCode();
9416 if (HasPreferredVariableOrder) hash ^= PreferredVariableOrder.GetHashCode();
9417 if (HasInitialPolarity) hash ^= InitialPolarity.GetHashCode();
9418 if (HasUsePhaseSaving) hash ^= UsePhaseSaving.GetHashCode();
9419 if (HasPolarityRephaseIncrement) hash ^= PolarityRephaseIncrement.GetHashCode();
9420 if (HasPolarityExploitLsHints) hash ^= PolarityExploitLsHints.GetHashCode();
9421 if (HasRandomPolarityRatio) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(RandomPolarityRatio);
9422 if (HasRandomBranchesRatio) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(RandomBranchesRatio);
9423 if (HasUseErwaHeuristic) hash ^= UseErwaHeuristic.GetHashCode();
9424 if (HasInitialVariablesActivity) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(InitialVariablesActivity);
9425 if (HasAlsoBumpVariablesInConflictReasons) hash ^= AlsoBumpVariablesInConflictReasons.GetHashCode();
9426 if (HasMinimizationAlgorithm) hash ^= MinimizationAlgorithm.GetHashCode();
9427 if (HasBinaryMinimizationAlgorithm) hash ^= BinaryMinimizationAlgorithm.GetHashCode();
9428 if (HasSubsumptionDuringConflictAnalysis) hash ^= SubsumptionDuringConflictAnalysis.GetHashCode();
9429 if (HasClauseCleanupPeriod) hash ^= ClauseCleanupPeriod.GetHashCode();
9430 if (HasClauseCleanupTarget) hash ^= ClauseCleanupTarget.GetHashCode();
9431 if (HasClauseCleanupRatio) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(ClauseCleanupRatio);
9432 if (HasClauseCleanupProtection) hash ^= ClauseCleanupProtection.GetHashCode();
9433 if (HasClauseCleanupLbdBound) hash ^= ClauseCleanupLbdBound.GetHashCode();
9434 if (HasClauseCleanupOrdering) hash ^= ClauseCleanupOrdering.GetHashCode();
9435 if (HasPbCleanupIncrement) hash ^= PbCleanupIncrement.GetHashCode();
9436 if (HasPbCleanupRatio) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(PbCleanupRatio);
9437 if (HasVariableActivityDecay) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(VariableActivityDecay);
9438 if (HasMaxVariableActivityValue) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(MaxVariableActivityValue);
9439 if (HasGlucoseMaxDecay) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(GlucoseMaxDecay);
9440 if (HasGlucoseDecayIncrement) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(GlucoseDecayIncrement);
9441 if (HasGlucoseDecayIncrementPeriod) hash ^= GlucoseDecayIncrementPeriod.GetHashCode();
9442 if (HasClauseActivityDecay) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(ClauseActivityDecay);
9443 if (HasMaxClauseActivityValue) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(MaxClauseActivityValue);
9444 hash ^= restartAlgorithms_.GetHashCode();
9445 if (HasDefaultRestartAlgorithms) hash ^= DefaultRestartAlgorithms.GetHashCode();
9446 if (HasRestartPeriod) hash ^= RestartPeriod.GetHashCode();
9447 if (HasRestartRunningWindowSize) hash ^= RestartRunningWindowSize.GetHashCode();
9448 if (HasRestartDlAverageRatio) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(RestartDlAverageRatio);
9449 if (HasRestartLbdAverageRatio) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(RestartLbdAverageRatio);
9450 if (HasUseBlockingRestart) hash ^= UseBlockingRestart.GetHashCode();
9451 if (HasBlockingRestartWindowSize) hash ^= BlockingRestartWindowSize.GetHashCode();
9452 if (HasBlockingRestartMultiplier) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(BlockingRestartMultiplier);
9453 if (HasNumConflictsBeforeStrategyChanges) hash ^= NumConflictsBeforeStrategyChanges.GetHashCode();
9454 if (HasStrategyChangeIncreaseRatio) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(StrategyChangeIncreaseRatio);
9455 if (HasMaxTimeInSeconds) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(MaxTimeInSeconds);
9456 if (HasMaxDeterministicTime) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(MaxDeterministicTime);
9457 if (HasMaxNumDeterministicBatches) hash ^= MaxNumDeterministicBatches.GetHashCode();
9458 if (HasMaxNumberOfConflicts) hash ^= MaxNumberOfConflicts.GetHashCode();
9459 if (HasMaxMemoryInMb) hash ^= MaxMemoryInMb.GetHashCode();
9460 if (HasAbsoluteGapLimit) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(AbsoluteGapLimit);
9461 if (HasRelativeGapLimit) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(RelativeGapLimit);
9462 if (HasRandomSeed) hash ^= RandomSeed.GetHashCode();
9463 if (HasPermuteVariableRandomly) hash ^= PermuteVariableRandomly.GetHashCode();
9464 if (HasPermutePresolveConstraintOrder) hash ^= PermutePresolveConstraintOrder.GetHashCode();
9465 if (HasUseAbslRandom) hash ^= UseAbslRandom.GetHashCode();
9466 if (HasLogSearchProgress) hash ^= LogSearchProgress.GetHashCode();
9512 hash ^= subsolvers_.GetHashCode();
9513 hash ^= extraSubsolvers_.GetHashCode();
9514 hash ^= ignoreSubsolvers_.GetHashCode();
9515 hash ^= filterSubsolvers_.GetHashCode();
9516 hash ^= subsolverParams_.GetHashCode();
9682 if (_unknownFields !=
null) {
9683 hash ^= _unknownFields.GetHashCode();
9688 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
9689 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
9690 public override string ToString() {
9691 return pb::JsonFormatter.ToDiagnosticString(
this);
9694 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
9695 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
9696 public void WriteTo(pb::CodedOutputStream output) {
9697 #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
9698 output.WriteRawMessage(
this);
9700 if (HasPreferredVariableOrder) {
9701 output.WriteRawTag(8);
9702 output.WriteEnum((
int) PreferredVariableOrder);
9704 if (HasInitialPolarity) {
9705 output.WriteRawTag(16);
9706 output.WriteEnum((
int) InitialPolarity);
9708 if (HasMinimizationAlgorithm) {
9709 output.WriteRawTag(32);
9710 output.WriteEnum((
int) MinimizationAlgorithm);
9712 if (HasClauseCleanupPeriod) {
9713 output.WriteRawTag(88);
9714 output.WriteInt32(ClauseCleanupPeriod);
9716 if (HasClauseCleanupTarget) {
9717 output.WriteRawTag(104);
9718 output.WriteInt32(ClauseCleanupTarget);
9720 if (HasVariableActivityDecay) {
9721 output.WriteRawTag(121);
9722 output.WriteDouble(VariableActivityDecay);
9724 if (HasMaxVariableActivityValue) {
9725 output.WriteRawTag(129, 1);
9726 output.WriteDouble(MaxVariableActivityValue);
9728 if (HasClauseActivityDecay) {
9729 output.WriteRawTag(137, 1);
9730 output.WriteDouble(ClauseActivityDecay);
9732 if (HasMaxClauseActivityValue) {
9733 output.WriteRawTag(145, 1);
9734 output.WriteDouble(MaxClauseActivityValue);
9736 if (HasGlucoseMaxDecay) {
9737 output.WriteRawTag(177, 1);
9738 output.WriteDouble(GlucoseMaxDecay);
9740 if (HasGlucoseDecayIncrement) {
9741 output.WriteRawTag(185, 1);
9742 output.WriteDouble(GlucoseDecayIncrement);
9745 output.WriteRawTag(192, 1);
9748 if (HasRestartPeriod) {
9749 output.WriteRawTag(240, 1);
9752 if (HasRandomSeed) {
9753 output.WriteRawTag(248, 1);
9754 output.WriteInt32(RandomSeed);
9756 if (HasRandomBranchesRatio) {
9757 output.WriteRawTag(129, 2);
9758 output.WriteDouble(RandomBranchesRatio);
9760 if (HasBinaryMinimizationAlgorithm) {
9761 output.WriteRawTag(144, 2);
9762 output.WriteEnum((
int) BinaryMinimizationAlgorithm);
9764 if (HasUseOptimizationHints) {
9765 output.WriteRawTag(152, 2);
9766 output.WriteBool(UseOptimizationHints);
9768 if (HasMaxTimeInSeconds) {
9769 output.WriteRawTag(161, 2);
9770 output.WriteDouble(MaxTimeInSeconds);
9772 if (HasMaxNumberOfConflicts) {
9773 output.WriteRawTag(168, 2);
9774 output.WriteInt64(MaxNumberOfConflicts);
9776 if (HasMaxMemoryInMb) {
9777 output.WriteRawTag(192, 2);
9778 output.WriteInt64(MaxMemoryInMb);
9780 if (HasLogSearchProgress) {
9781 output.WriteRawTag(200, 2);
9782 output.WriteBool(LogSearchProgress);
9784 if (HasUsePbResolution) {
9785 output.WriteRawTag(216, 2);
9786 output.WriteBool(UsePbResolution);
9788 if (HasUsePhaseSaving) {
9789 output.WriteRawTag(224, 2);
9790 output.WriteBool(UsePhaseSaving);
9792 if (HasRandomPolarityRatio) {
9793 output.WriteRawTag(233, 2);
9794 output.WriteDouble(RandomPolarityRatio);
9796 if (HasPbCleanupIncrement) {
9797 output.WriteRawTag(240, 2);
9798 output.WriteInt32(PbCleanupIncrement);
9800 if (HasPbCleanupRatio) {
9801 output.WriteRawTag(249, 2);
9802 output.WriteDouble(PbCleanupRatio);
9804 if (HasMinimizeReductionDuringPbResolution) {
9805 output.WriteRawTag(128, 3);
9806 output.WriteBool(MinimizeReductionDuringPbResolution);
9808 if (HasCountAssumptionLevelsInLbd) {
9809 output.WriteRawTag(136, 3);
9810 output.WriteBool(CountAssumptionLevelsInLbd);
9812 if (HasCoreMinimizationLevel) {
9813 output.WriteRawTag(144, 3);
9814 output.WriteInt32(CoreMinimizationLevel);
9816 if (HasMaxSatAssumptionOrder) {
9817 output.WriteRawTag(152, 3);
9818 output.WriteEnum((
int) MaxSatAssumptionOrder);
9820 if (HasMaxSatReverseAssumptionOrder) {
9821 output.WriteRawTag(160, 3);
9822 output.WriteBool(MaxSatReverseAssumptionOrder);
9824 if (HasMaxSatStratification) {
9825 output.WriteRawTag(168, 3);
9826 output.WriteEnum((
int) MaxSatStratification);
9828 if (HasPresolveBveThreshold) {
9829 output.WriteRawTag(176, 3);
9830 output.WriteInt32(PresolveBveThreshold);
9832 if (HasPresolveBveClauseWeight) {
9833 output.WriteRawTag(184, 3);
9834 output.WriteInt32(PresolveBveClauseWeight);
9836 if (HasSubsumptionDuringConflictAnalysis) {
9837 output.WriteRawTag(192, 3);
9838 output.WriteBool(SubsumptionDuringConflictAnalysis);
9840 if (HasPresolveProbingDeterministicTimeLimit) {
9841 output.WriteRawTag(201, 3);
9842 output.WriteDouble(PresolveProbingDeterministicTimeLimit);
9844 if (HasClauseCleanupProtection) {
9845 output.WriteRawTag(208, 3);
9846 output.WriteEnum((
int) ClauseCleanupProtection);
9848 if (HasClauseCleanupLbdBound) {
9849 output.WriteRawTag(216, 3);
9850 output.WriteInt32(ClauseCleanupLbdBound);
9852 if (HasClauseCleanupOrdering) {
9853 output.WriteRawTag(224, 3);
9854 output.WriteEnum((
int) ClauseCleanupOrdering);
9856 restartAlgorithms_.WriteTo(output, _repeated_restartAlgorithms_codec);
9857 if (HasRestartRunningWindowSize) {
9858 output.WriteRawTag(240, 3);
9859 output.WriteInt32(RestartRunningWindowSize);
9861 if (HasRestartDlAverageRatio) {
9862 output.WriteRawTag(249, 3);
9863 output.WriteDouble(RestartDlAverageRatio);
9865 if (HasUseBlockingRestart) {
9866 output.WriteRawTag(128, 4);
9867 output.WriteBool(UseBlockingRestart);
9869 if (HasBlockingRestartWindowSize) {
9870 output.WriteRawTag(136, 4);
9871 output.WriteInt32(BlockingRestartWindowSize);
9873 if (HasBlockingRestartMultiplier) {
9874 output.WriteRawTag(145, 4);
9875 output.WriteDouble(BlockingRestartMultiplier);
9877 if (HasMaxDeterministicTime) {
9878 output.WriteRawTag(153, 4);
9879 output.WriteDouble(MaxDeterministicTime);
9881 if (HasNumConflictsBeforeStrategyChanges) {
9882 output.WriteRawTag(160, 4);
9883 output.WriteInt32(NumConflictsBeforeStrategyChanges);
9885 if (HasStrategyChangeIncreaseRatio) {
9886 output.WriteRawTag(169, 4);
9887 output.WriteDouble(StrategyChangeIncreaseRatio);
9889 if (HasDefaultRestartAlgorithms) {
9890 output.WriteRawTag(178, 4);
9891 output.WriteString(DefaultRestartAlgorithms);
9893 if (HasRestartLbdAverageRatio) {
9894 output.WriteRawTag(185, 4);
9895 output.WriteDouble(RestartLbdAverageRatio);
9897 if (HasPresolveUseBva) {
9898 output.WriteRawTag(192, 4);
9899 output.WriteBool(PresolveUseBva);
9901 if (HasPresolveBvaThreshold) {
9902 output.WriteRawTag(200, 4);
9903 output.WriteInt32(PresolveBvaThreshold);
9905 if (HasUsePrecedencesInDisjunctiveConstraint) {
9906 output.WriteRawTag(208, 4);
9907 output.WriteBool(UsePrecedencesInDisjunctiveConstraint);
9909 if (HasUseErwaHeuristic) {
9910 output.WriteRawTag(216, 4);
9911 output.WriteBool(UseErwaHeuristic);
9913 if (HasInitialVariablesActivity) {
9914 output.WriteRawTag(225, 4);
9915 output.WriteDouble(InitialVariablesActivity);
9917 if (HasAlsoBumpVariablesInConflictReasons) {
9918 output.WriteRawTag(232, 4);
9919 output.WriteBool(AlsoBumpVariablesInConflictReasons);
9921 if (HasUseOverloadCheckerInCumulative) {
9922 output.WriteRawTag(240, 4);
9923 output.WriteBool(UseOverloadCheckerInCumulative);
9925 if (HasUseTimetableEdgeFindingInCumulative) {
9926 output.WriteRawTag(248, 4);
9927 output.WriteBool(UseTimetableEdgeFindingInCumulative);
9929 if (HasUseDisjunctiveConstraintInCumulative) {
9930 output.WriteRawTag(128, 5);
9931 output.WriteBool(UseDisjunctiveConstraintInCumulative);
9933 if (HasSearchBranching) {
9934 output.WriteRawTag(144, 5);
9935 output.WriteEnum((
int) SearchBranching);
9937 if (HasOptimizeWithCore) {
9938 output.WriteRawTag(152, 5);
9939 output.WriteBool(OptimizeWithCore);
9941 if (HasFindMultipleCores) {
9942 output.WriteRawTag(160, 5);
9943 output.WriteBool(FindMultipleCores);
9945 if (HasOptimizeWithMaxHs) {
9946 output.WriteRawTag(168, 5);
9947 output.WriteBool(OptimizeWithMaxHs);
9949 if (HasCpModelPresolve) {
9950 output.WriteRawTag(176, 5);
9951 output.WriteBool(CpModelPresolve);
9953 if (HasEnumerateAllSolutions) {
9954 output.WriteRawTag(184, 5);
9955 output.WriteBool(EnumerateAllSolutions);
9957 if (HasPresolveBlockedClause) {
9958 output.WriteRawTag(192, 5);
9959 output.WriteBool(PresolveBlockedClause);
9961 if (HasCoverOptimization) {
9962 output.WriteRawTag(200, 5);
9963 output.WriteBool(CoverOptimization);
9965 if (HasLinearizationLevel) {
9966 output.WriteRawTag(208, 5);
9967 output.WriteInt32(LinearizationLevel);
9969 if (HasMaxNumCuts) {
9970 output.WriteRawTag(216, 5);
9971 output.WriteInt32(MaxNumCuts);
9973 if (HasOnlyAddCutsAtLevelZero) {
9974 output.WriteRawTag(224, 5);
9975 output.WriteBool(OnlyAddCutsAtLevelZero);
9977 if (HasCpModelUseSatPresolve) {
9978 output.WriteRawTag(232, 5);
9979 output.WriteBool(CpModelUseSatPresolve);
9981 if (HasExploitIntegerLpSolution) {
9982 output.WriteRawTag(240, 5);
9983 output.WriteBool(ExploitIntegerLpSolution);
9985 if (HasAutoDetectGreaterThanAtLeastOneOf) {
9986 output.WriteRawTag(248, 5);
9987 output.WriteBool(AutoDetectGreaterThanAtLeastOneOf);
9989 if (HasStopAfterFirstSolution) {
9990 output.WriteRawTag(144, 6);
9991 output.WriteBool(StopAfterFirstSolution);
9993 if (HasBinarySearchNumConflicts) {
9994 output.WriteRawTag(152, 6);
9995 output.WriteInt32(BinarySearchNumConflicts);
9997 if (HasNumSearchWorkers) {
9998 output.WriteRawTag(160, 6);
9999 output.WriteInt32(NumSearchWorkers);
10001 if (HasUseLnsOnly) {
10002 output.WriteRawTag(168, 6);
10003 output.WriteBool(UseLnsOnly);
10005 if (HasRandomizeSearch) {
10006 output.WriteRawTag(184, 6);
10007 output.WriteBool(RandomizeSearch);
10009 if (HasSearchRandomVariablePoolSize) {
10010 output.WriteRawTag(192, 6);
10011 output.WriteInt64(SearchRandomVariablePoolSize);
10013 if (HasInstantiateAllVariables) {
10014 output.WriteRawTag(208, 6);
10015 output.WriteBool(InstantiateAllVariables);
10017 if (HasBooleanEncodingLevel) {
10018 output.WriteRawTag(216, 6);
10019 output.WriteInt32(BooleanEncodingLevel);
10021 if (HasUseOptionalVariables) {
10022 output.WriteRawTag(224, 6);
10023 output.WriteBool(UseOptionalVariables);
10025 if (HasUseExactLpReason) {
10026 output.WriteRawTag(232, 6);
10027 output.WriteBool(UseExactLpReason);
10029 if (HasCpModelProbingLevel) {
10030 output.WriteRawTag(240, 6);
10031 output.WriteInt32(CpModelProbingLevel);
10033 if (HasAddLpConstraintsLazily) {
10034 output.WriteRawTag(128, 7);
10035 output.WriteBool(AddLpConstraintsLazily);
10037 if (HasShareObjectiveBounds) {
10038 output.WriteRawTag(136, 7);
10039 output.WriteBool(ShareObjectiveBounds);
10041 if (HasShareLevelZeroBounds) {
10042 output.WriteRawTag(144, 7);
10043 output.WriteBool(ShareLevelZeroBounds);
10045 if (HasMinOrthogonalityForLpConstraints) {
10046 output.WriteRawTag(153, 7);
10047 output.WriteDouble(MinOrthogonalityForLpConstraints);
10049 if (HasExploitAllLpSolution) {
10050 output.WriteRawTag(160, 7);
10051 output.WriteBool(ExploitAllLpSolution);
10053 if (HasAddCgCuts) {
10054 output.WriteRawTag(168, 7);
10055 output.WriteBool(AddCgCuts);
10057 if (HasMaxIntegerRoundingScaling) {
10058 output.WriteRawTag(184, 7);
10059 output.WriteInt32(MaxIntegerRoundingScaling);
10061 if (HasAddMirCuts) {
10062 output.WriteRawTag(192, 7);
10063 output.WriteBool(AddMirCuts);
10065 if (HasMaxConsecutiveInactiveCount) {
10066 output.WriteRawTag(200, 7);
10067 output.WriteInt32(MaxConsecutiveInactiveCount);
10069 if (HasNewConstraintsBatchSize) {
10070 output.WriteRawTag(208, 7);
10071 output.WriteInt32(NewConstraintsBatchSize);
10073 if (HasPseudoCostReliabilityThreshold) {
10074 output.WriteRawTag(216, 7);
10075 output.WriteInt64(PseudoCostReliabilityThreshold);
10077 if (HasMipMaxBound) {
10078 output.WriteRawTag(225, 7);
10079 output.WriteDouble(MipMaxBound);
10081 if (HasMipVarScaling) {
10082 output.WriteRawTag(233, 7);
10083 output.WriteDouble(MipVarScaling);
10085 if (HasMipWantedPrecision) {
10086 output.WriteRawTag(241, 7);
10087 output.WriteDouble(MipWantedPrecision);
10089 if (HasMipMaxActivityExponent) {
10090 output.WriteRawTag(248, 7);
10091 output.WriteInt32(MipMaxActivityExponent);
10093 if (HasMipCheckPrecision) {
10094 output.WriteRawTag(129, 8);
10095 output.WriteDouble(MipCheckPrecision);
10097 if (HasUseRinsLns) {
10098 output.WriteRawTag(136, 8);
10099 output.WriteBool(UseRinsLns);
10101 if (HasExploitBestSolution) {
10102 output.WriteRawTag(144, 8);
10103 output.WriteBool(ExploitBestSolution);
10105 if (HasExploitObjective) {
10106 output.WriteRawTag(152, 8);
10107 output.WriteBool(ExploitObjective);
10109 if (HasFillTightenedDomainsInResponse) {
10110 output.WriteRawTag(160, 8);
10111 output.WriteBool(FillTightenedDomainsInResponse);
10113 if (HasUseCombinedNoOverlap) {
10114 output.WriteRawTag(168, 8);
10115 output.WriteBool(UseCombinedNoOverlap);
10117 if (HasInterleaveBatchSize) {
10118 output.WriteRawTag(176, 8);
10119 output.WriteInt32(InterleaveBatchSize);
10121 if (HasCatchSigintSignal) {
10122 output.WriteRawTag(184, 8);
10123 output.WriteBool(CatchSigintSignal);
10125 if (HasInterleaveSearch) {
10126 output.WriteRawTag(192, 8);
10127 output.WriteBool(InterleaveSearch);
10129 if (HasDiversifyLnsParams) {
10130 output.WriteRawTag(200, 8);
10131 output.WriteBool(DiversifyLnsParams);
10133 if (HasMaxPresolveIterations) {
10134 output.WriteRawTag(208, 8);
10135 output.WriteInt32(MaxPresolveIterations);
10137 if (HasUseImpliedBounds) {
10138 output.WriteRawTag(128, 9);
10139 output.WriteBool(UseImpliedBounds);
10141 if (HasMergeNoOverlapWorkLimit) {
10142 output.WriteRawTag(137, 9);
10143 output.WriteDouble(MergeNoOverlapWorkLimit);
10145 if (HasMergeAtMostOneWorkLimit) {
10146 output.WriteRawTag(145, 9);
10147 output.WriteDouble(MergeAtMostOneWorkLimit);
10149 if (HasPresolveSubstitutionLevel) {
10150 output.WriteRawTag(152, 9);
10151 output.WriteInt32(PresolveSubstitutionLevel);
10153 if (HasMaxAllDiffCutSize) {
10154 output.WriteRawTag(160, 9);
10155 output.WriteInt32(MaxAllDiffCutSize);
10157 if (HasStopAfterPresolve) {
10158 output.WriteRawTag(168, 9);
10159 output.WriteBool(StopAfterPresolve);
10161 if (HasDebugMaxNumPresolveOperations) {
10162 output.WriteRawTag(184, 9);
10163 output.WriteInt32(DebugMaxNumPresolveOperations);
10165 if (HasAddLinMaxCuts) {
10166 output.WriteRawTag(192, 9);
10167 output.WriteBool(AddLinMaxCuts);
10169 if (HasHintConflictLimit) {
10170 output.WriteRawTag(200, 9);
10171 output.WriteInt32(HintConflictLimit);
10173 if (HasMaxCutRoundsAtLevelZero) {
10174 output.WriteRawTag(208, 9);
10175 output.WriteInt32(MaxCutRoundsAtLevelZero);
10177 if (HasCutMaxActiveCountValue) {
10178 output.WriteRawTag(217, 9);
10179 output.WriteDouble(CutMaxActiveCountValue);
10181 if (HasCutActiveCountDecay) {
10182 output.WriteRawTag(225, 9);
10183 output.WriteDouble(CutActiveCountDecay);
10185 if (HasCutCleanupTarget) {
10186 output.WriteRawTag(232, 9);
10187 output.WriteInt32(CutCleanupTarget);
10189 if (HasAbsoluteGapLimit) {
10190 output.WriteRawTag(249, 9);
10191 output.WriteDouble(AbsoluteGapLimit);
10193 if (HasRelativeGapLimit) {
10194 output.WriteRawTag(129, 10);
10195 output.WriteDouble(RelativeGapLimit);
10197 if (HasExploitRelaxationSolution) {
10198 output.WriteRawTag(136, 10);
10199 output.WriteBool(ExploitRelaxationSolution);
10201 if (HasDebugPostsolveWithFullSolver) {
10202 output.WriteRawTag(144, 10);
10203 output.WriteBool(DebugPostsolveWithFullSolver);
10205 if (HasUseSatInprocessing) {
10206 output.WriteRawTag(152, 10);
10207 output.WriteBool(UseSatInprocessing);
10209 if (HasUseFeasibilityPump) {
10210 output.WriteRawTag(160, 10);
10211 output.WriteBool(UseFeasibilityPump);
10213 if (HasFpRounding) {
10214 output.WriteRawTag(168, 10);
10215 output.WriteEnum((
int) FpRounding);
10217 if (HasMipAutomaticallyScaleVariables) {
10218 output.WriteRawTag(176, 10);
10219 output.WriteBool(MipAutomaticallyScaleVariables);
10221 if (HasRepairHint) {
10222 output.WriteRawTag(184, 10);
10223 output.WriteBool(RepairHint);
10225 if (HasPolarityRephaseIncrement) {
10226 output.WriteRawTag(192, 10);
10227 output.WriteInt32(PolarityRephaseIncrement);
10229 if (HasAddZeroHalfCuts) {
10230 output.WriteRawTag(200, 10);
10231 output.WriteBool(AddZeroHalfCuts);
10233 if (HasExpandAlldiffConstraints) {
10234 output.WriteRawTag(208, 10);
10235 output.WriteBool(ExpandAlldiffConstraints);
10238 output.WriteRawTag(218, 10);
10239 output.WriteString(Name);
10241 if (HasAddCliqueCuts) {
10242 output.WriteRawTag(224, 10);
10243 output.WriteBool(AddCliqueCuts);
10245 if (HasKeepAllFeasibleSolutionsInPresolve) {
10246 output.WriteRawTag(232, 10);
10247 output.WriteBool(KeepAllFeasibleSolutionsInPresolve);
10249 if (HasPresolveExtractIntegerEnforcement) {
10250 output.WriteRawTag(240, 10);
10251 output.WriteBool(PresolveExtractIntegerEnforcement);
10253 if (HasPolishLpSolution) {
10254 output.WriteRawTag(248, 10);
10255 output.WriteBool(PolishLpSolution);
10257 if (HasUseProbingSearch) {
10258 output.WriteRawTag(128, 11);
10259 output.WriteBool(UseProbingSearch);
10261 if (HasConvertIntervals) {
10262 output.WriteRawTag(136, 11);
10263 output.WriteBool(ConvertIntervals);
10265 if (HasPermuteVariableRandomly) {
10266 output.WriteRawTag(144, 11);
10267 output.WriteBool(PermuteVariableRandomly);
10269 if (HasPermutePresolveConstraintOrder) {
10270 output.WriteRawTag(152, 11);
10271 output.WriteBool(PermutePresolveConstraintOrder);
10273 if (HasUseAbslRandom) {
10274 output.WriteRawTag(160, 11);
10275 output.WriteBool(UseAbslRandom);
10277 if (HasDisableConstraintExpansion) {
10278 output.WriteRawTag(168, 11);
10279 output.WriteBool(DisableConstraintExpansion);
10281 if (HasExpandReservoirConstraints) {
10282 output.WriteRawTag(176, 11);
10283 output.WriteBool(ExpandReservoirConstraints);
10285 if (HasSymmetryLevel) {
10286 output.WriteRawTag(184, 11);
10287 output.WriteInt32(SymmetryLevel);
10289 if (HasLogPrefix) {
10290 output.WriteRawTag(202, 11);
10291 output.WriteString(LogPrefix);
10293 if (HasLogToStdout) {
10294 output.WriteRawTag(208, 11);
10295 output.WriteBool(LogToStdout);
10297 if (HasLogToResponse) {
10298 output.WriteRawTag(216, 11);
10299 output.WriteBool(LogToResponse);
10301 if (HasOptimizeWithLbTreeSearch) {
10302 output.WriteRawTag(224, 11);
10303 output.WriteBool(OptimizeWithLbTreeSearch);
10305 if (HasLogSubsolverStatistics) {
10306 output.WriteRawTag(232, 11);
10307 output.WriteBool(LogSubsolverStatistics);
10309 if (HasClauseCleanupRatio) {
10310 output.WriteRawTag(241, 11);
10311 output.WriteDouble(ClauseCleanupRatio);
10313 if (HasMaxDomainSizeWhenEncodingEqNeqConstraints) {
10314 output.WriteRawTag(248, 11);
10315 output.WriteInt32(MaxDomainSizeWhenEncodingEqNeqConstraints);
10317 if (HasFixVariablesToTheirHintedValue) {
10318 output.WriteRawTag(128, 12);
10319 output.WriteBool(FixVariablesToTheirHintedValue);
10321 if (HasSolutionPoolSize) {
10322 output.WriteRawTag(136, 12);
10323 output.WriteInt32(SolutionPoolSize);
10325 if (HasFillAdditionalSolutionsInResponse) {
10326 output.WriteRawTag(144, 12);
10327 output.WriteBool(FillAdditionalSolutionsInResponse);
10329 if (HasDebugCrashOnBadHint) {
10330 output.WriteRawTag(152, 12);
10331 output.WriteBool(DebugCrashOnBadHint);
10334 output.WriteRawTag(160, 12);
10335 output.WriteInt32(CutLevel);
10337 if (HasAddObjectiveCut) {
10338 output.WriteRawTag(168, 12);
10339 output.WriteBool(AddObjectiveCut);
10341 if (HasMipComputeTrueObjectiveBound) {
10342 output.WriteRawTag(176, 12);
10343 output.WriteBool(MipComputeTrueObjectiveBound);
10345 if (HasMipMaxValidMagnitude) {
10346 output.WriteRawTag(185, 12);
10347 output.WriteDouble(MipMaxValidMagnitude);
10349 if (HasUseTimetablingInNoOverlap2D) {
10350 output.WriteRawTag(192, 12);
10351 output.WriteBool(UseTimetablingInNoOverlap2D);
10353 if (HasPresolveInclusionWorkLimit) {
10354 output.WriteRawTag(200, 12);
10355 output.WriteInt64(PresolveInclusionWorkLimit);
10357 if (HasIgnoreNames) {
10358 output.WriteRawTag(208, 12);
10359 output.WriteBool(IgnoreNames);
10361 if (HasShareBinaryClauses) {
10362 output.WriteRawTag(216, 12);
10363 output.WriteBool(ShareBinaryClauses);
10365 if (HasUseShavingInProbingSearch) {
10366 output.WriteRawTag(224, 12);
10367 output.WriteBool(UseShavingInProbingSearch);
10369 if (HasShavingSearchDeterministicTime) {
10370 output.WriteRawTag(233, 12);
10371 output.WriteDouble(ShavingSearchDeterministicTime);
10373 if (HasNumWorkers) {
10374 output.WriteRawTag(240, 12);
10375 output.WriteInt32(NumWorkers);
10377 subsolvers_.WriteTo(output, _repeated_subsolvers_codec);
10378 ignoreSubsolvers_.WriteTo(output, _repeated_ignoreSubsolvers_codec);
10379 subsolverParams_.WriteTo(output, _repeated_subsolverParams_codec);
10380 if (HasUseEnergeticReasoningInNoOverlap2D) {
10381 output.WriteRawTag(168, 13);
10382 output.WriteBool(UseEnergeticReasoningInNoOverlap2D);
10384 if (HasUseDualSchedulingHeuristics) {
10385 output.WriteRawTag(176, 13);
10386 output.WriteBool(UseDualSchedulingHeuristics);
10388 if (HasUseHardPrecedencesInCumulative) {
10389 output.WriteRawTag(184, 13);
10390 output.WriteBool(UseHardPrecedencesInCumulative);
10392 if (HasDetectTableWithCost) {
10393 output.WriteRawTag(192, 13);
10394 output.WriteBool(DetectTableWithCost);
10396 if (HasTableCompressionLevel) {
10397 output.WriteRawTag(200, 13);
10398 output.WriteInt32(TableCompressionLevel);
10400 extraSubsolvers_.WriteTo(output, _repeated_extraSubsolvers_codec);
10401 if (HasExploitAllPrecedences) {
10402 output.WriteRawTag(224, 13);
10403 output.WriteBool(ExploitAllPrecedences);
10405 if (HasPropagationLoopDetectionFactor) {
10406 output.WriteRawTag(233, 13);
10407 output.WriteDouble(PropagationLoopDetectionFactor);
10409 if (HasOnlySolveIp) {
10410 output.WriteRawTag(240, 13);
10411 output.WriteBool(OnlySolveIp);
10413 if (HasEncodeComplexLinearConstraintWithInteger) {
10414 output.WriteRawTag(248, 13);
10415 output.WriteBool(EncodeComplexLinearConstraintWithInteger);
10417 if (HasNewLinearPropagation) {
10418 output.WriteRawTag(128, 14);
10419 output.WriteBool(NewLinearPropagation);
10421 if (HasMipScaleLargeDomain) {
10422 output.WriteRawTag(136, 14);
10423 output.WriteBool(MipScaleLargeDomain);
10425 if (HasProbingDeterministicTimeLimit) {
10426 output.WriteRawTag(145, 14);
10427 output.WriteDouble(ProbingDeterministicTimeLimit);
10429 if (HasRootLpIterations) {
10430 output.WriteRawTag(152, 14);
10431 output.WriteInt32(RootLpIterations);
10433 if (HasUseObjectiveLbSearch) {
10434 output.WriteRawTag(160, 14);
10435 output.WriteBool(UseObjectiveLbSearch);
10437 if (HasMaxSizeToCreatePrecedenceLiteralsInDisjunctive) {
10438 output.WriteRawTag(168, 14);
10439 output.WriteInt32(MaxSizeToCreatePrecedenceLiteralsInDisjunctive);
10441 if (HasUseStrongPropagationInDisjunctive) {
10442 output.WriteRawTag(176, 14);
10443 output.WriteBool(UseStrongPropagationInDisjunctive);
10445 if (HasMipDropTolerance) {
10446 output.WriteRawTag(193, 14);
10447 output.WriteDouble(MipDropTolerance);
10449 if (HasInferAllDiffs) {
10450 output.WriteRawTag(200, 14);
10451 output.WriteBool(InferAllDiffs);
10453 if (HasFindBigLinearOverlap) {
10454 output.WriteRawTag(208, 14);
10455 output.WriteBool(FindBigLinearOverlap);
10457 if (HasSharedTreeNumWorkers) {
10458 output.WriteRawTag(216, 14);
10459 output.WriteInt32(SharedTreeNumWorkers);
10461 if (HasUseSharedTreeSearch) {
10462 output.WriteRawTag(224, 14);
10463 output.WriteBool(UseSharedTreeSearch);
10465 if (HasSharedTreeMaxNodesPerWorker) {
10466 output.WriteRawTag(240, 14);
10467 output.WriteInt32(SharedTreeMaxNodesPerWorker);
10469 if (HasSharedTreeSplitStrategy) {
10470 output.WriteRawTag(248, 14);
10471 output.WriteEnum((
int) SharedTreeSplitStrategy);
10473 if (HasUseLsOnly) {
10474 output.WriteRawTag(128, 15);
10475 output.WriteBool(UseLsOnly);
10477 if (HasFeasibilityJumpDecay) {
10478 output.WriteRawTag(145, 15);
10479 output.WriteDouble(FeasibilityJumpDecay);
10481 if (HasNumViolationLs) {
10482 output.WriteRawTag(160, 15);
10483 output.WriteInt32(NumViolationLs);
10485 if (HasFeasibilityJumpVarRandomizationProbability) {
10486 output.WriteRawTag(185, 15);
10487 output.WriteDouble(FeasibilityJumpVarRandomizationProbability);
10489 if (HasFeasibilityJumpVarPerburbationRangeRatio) {
10490 output.WriteRawTag(193, 15);
10491 output.WriteDouble(FeasibilityJumpVarPerburbationRangeRatio);
10493 if (HasViolationLsPerturbationPeriod) {
10494 output.WriteRawTag(200, 15);
10495 output.WriteInt32(ViolationLsPerturbationPeriod);
10497 if (HasFeasibilityJumpEnableRestarts) {
10498 output.WriteRawTag(208, 15);
10499 output.WriteBool(FeasibilityJumpEnableRestarts);
10501 if (HasStopAfterRootPropagation) {
10502 output.WriteRawTag(224, 15);
10503 output.WriteBool(StopAfterRootPropagation);
10505 if (HasUseObjectiveShavingSearch) {
10506 output.WriteRawTag(232, 15);
10507 output.WriteBool(UseObjectiveShavingSearch);
10509 if (HasUseLbRelaxLns) {
10510 output.WriteRawTag(248, 15);
10511 output.WriteBool(UseLbRelaxLns);
10513 if (HasLinearSplitSize) {
10514 output.WriteRawTag(128, 16);
10515 output.WriteInt32(LinearSplitSize);
10517 if (HasFeasibilityJumpLinearizationLevel) {
10518 output.WriteRawTag(136, 16);
10519 output.WriteInt32(FeasibilityJumpLinearizationLevel);
10521 if (HasFeasibilityJumpRestartFactor) {
10522 output.WriteRawTag(144, 16);
10523 output.WriteInt32(FeasibilityJumpRestartFactor);
10525 if (HasViolationLsCompoundMoveProbability) {
10526 output.WriteRawTag(153, 16);
10527 output.WriteDouble(ViolationLsCompoundMoveProbability);
10529 if (HasMaxNumIntervalsForTimetableEdgeFinding) {
10530 output.WriteRawTag(160, 16);
10531 output.WriteInt32(MaxNumIntervalsForTimetableEdgeFinding);
10533 if (HasMipPresolveLevel) {
10534 output.WriteRawTag(168, 16);
10535 output.WriteInt32(MipPresolveLevel);
10537 if (HasPushAllTasksTowardStart) {
10538 output.WriteRawTag(176, 16);
10539 output.WriteBool(PushAllTasksTowardStart);
10541 if (HasUseDynamicPrecedenceInDisjunctive) {
10542 output.WriteRawTag(184, 16);
10543 output.WriteBool(UseDynamicPrecedenceInDisjunctive);
10545 if (HasFeasibilityJumpMaxExpandedConstraintSize) {
10546 output.WriteRawTag(192, 16);
10547 output.WriteInt32(FeasibilityJumpMaxExpandedConstraintSize);
10549 if (HasUseFeasibilityJump) {
10550 output.WriteRawTag(200, 16);
10551 output.WriteBool(UseFeasibilityJump);
10553 if (HasLpPrimalTolerance) {
10554 output.WriteRawTag(209, 16);
10555 output.WriteDouble(LpPrimalTolerance);
10557 if (HasLpDualTolerance) {
10558 output.WriteRawTag(217, 16);
10559 output.WriteDouble(LpDualTolerance);
10561 if (HasUseDynamicPrecedenceInCumulative) {
10562 output.WriteRawTag(224, 16);
10563 output.WriteBool(UseDynamicPrecedenceInCumulative);
10565 if (HasUseExtendedProbing) {
10566 output.WriteRawTag(232, 16);
10567 output.WriteBool(UseExtendedProbing);
10569 if (HasAtMostOneMaxExpansionSize) {
10570 output.WriteRawTag(240, 16);
10571 output.WriteInt32(AtMostOneMaxExpansionSize);
10573 if (HasUseAreaEnergeticReasoningInNoOverlap2D) {
10574 output.WriteRawTag(248, 16);
10575 output.WriteBool(UseAreaEnergeticReasoningInNoOverlap2D);
10577 if (HasProbingNumCombinationsLimit) {
10578 output.WriteRawTag(128, 17);
10579 output.WriteInt32(ProbingNumCombinationsLimit);
10581 if (HasInprocessingDtimeRatio) {
10582 output.WriteRawTag(137, 17);
10583 output.WriteDouble(InprocessingDtimeRatio);
10585 if (HasInprocessingProbingDtime) {
10586 output.WriteRawTag(145, 17);
10587 output.WriteDouble(InprocessingProbingDtime);
10589 if (HasInprocessingMinimizationDtime) {
10590 output.WriteRawTag(153, 17);
10591 output.WriteDouble(InprocessingMinimizationDtime);
10593 if (HasMaxPairsPairwiseReasoningInNoOverlap2D) {
10594 output.WriteRawTag(160, 17);
10595 output.WriteInt32(MaxPairsPairwiseReasoningInNoOverlap2D);
10597 if (HasDetectLinearizedProduct) {
10598 output.WriteRawTag(168, 17);
10599 output.WriteBool(DetectLinearizedProduct);
10601 if (HasMipTreatHighMagnitudeBoundsAsInfinity) {
10602 output.WriteRawTag(176, 17);
10603 output.WriteBool(MipTreatHighMagnitudeBoundsAsInfinity);
10605 if (HasAddRltCuts) {
10606 output.WriteRawTag(184, 17);
10607 output.WriteBool(AddRltCuts);
10609 if (HasMaxLinMaxSizeForExpansion) {
10610 output.WriteRawTag(192, 17);
10611 output.WriteInt32(MaxLinMaxSizeForExpansion);
10613 if (HasSharedTreeOpenLeavesPerWorker) {
10614 output.WriteRawTag(201, 17);
10615 output.WriteDouble(SharedTreeOpenLeavesPerWorker);
10617 if (HasSharedTreeWorkerMinRestartsPerSubtree) {
10618 output.WriteRawTag(208, 17);
10619 output.WriteInt32(SharedTreeWorkerMinRestartsPerSubtree);
10622 output.WriteRawTag(216, 17);
10623 output.WriteBool(UseLns);
10625 if (HasSaveLpBasisInLbTreeSearch) {
10626 output.WriteRawTag(224, 17);
10627 output.WriteBool(SaveLpBasisInLbTreeSearch);
10629 if (HasShareGlueClauses) {
10630 output.WriteRawTag(232, 17);
10631 output.WriteBool(ShareGlueClauses);
10633 if (HasUseConservativeScaleOverloadChecker) {
10634 output.WriteRawTag(240, 17);
10635 output.WriteBool(UseConservativeScaleOverloadChecker);
10637 if (HasEncodeCumulativeAsReservoir) {
10638 output.WriteRawTag(248, 17);
10639 output.WriteBool(EncodeCumulativeAsReservoir);
10641 if (HasExpandReservoirUsingCircuit) {
10642 output.WriteRawTag(128, 18);
10643 output.WriteBool(ExpandReservoirUsingCircuit);
10645 if (HasUseVariablesShavingSearch) {
10646 output.WriteRawTag(136, 18);
10647 output.WriteBool(UseVariablesShavingSearch);
10649 if (HasShavingSearchThreshold) {
10650 output.WriteRawTag(144, 18);
10651 output.WriteInt64(ShavingSearchThreshold);
10653 if (HasMaxNumDeterministicBatches) {
10654 output.WriteRawTag(152, 18);
10655 output.WriteInt32(MaxNumDeterministicBatches);
10657 if (HasFeasibilityJumpBatchDtime) {
10658 output.WriteRawTag(161, 18);
10659 output.WriteDouble(FeasibilityJumpBatchDtime);
10661 filterSubsolvers_.WriteTo(output, _repeated_filterSubsolvers_codec);
10662 if (HasNumFullSubsolvers) {
10663 output.WriteRawTag(176, 18);
10664 output.WriteInt32(NumFullSubsolvers);
10666 if (HasSharedTreeWorkerEnableTrailSharing) {
10667 output.WriteRawTag(184, 18);
10668 output.WriteBool(SharedTreeWorkerEnableTrailSharing);
10670 if (HasLbRelaxNumWorkersThreshold) {
10671 output.WriteRawTag(192, 18);
10672 output.WriteInt32(LbRelaxNumWorkersThreshold);
10674 if (HasInprocessingMinimizationUseConflictAnalysis) {
10675 output.WriteRawTag(200, 18);
10676 output.WriteBool(InprocessingMinimizationUseConflictAnalysis);
10678 if (HasInprocessingMinimizationUseAllOrderings) {
10679 output.WriteRawTag(208, 18);
10680 output.WriteBool(InprocessingMinimizationUseAllOrderings);
10682 if (HasUseTryEdgeReasoningInNoOverlap2D) {
10683 output.WriteRawTag(216, 18);
10684 output.WriteBool(UseTryEdgeReasoningInNoOverlap2D);
10686 if (HasMinimizeSharedClauses) {
10687 output.WriteRawTag(224, 18);
10688 output.WriteBool(MinimizeSharedClauses);
10690 if (HasUseSymmetryInLp) {
10691 output.WriteRawTag(232, 18);
10692 output.WriteBool(UseSymmetryInLp);
10694 if (HasSymmetryDetectionDeterministicTimeLimit) {
10695 output.WriteRawTag(241, 18);
10696 output.WriteDouble(SymmetryDetectionDeterministicTimeLimit);
10698 if (HasKeepSymmetryInPresolve) {
10699 output.WriteRawTag(248, 18);
10700 output.WriteBool(KeepSymmetryInPresolve);
10702 if (HasSharedTreeWorkerEnablePhaseSharing) {
10703 output.WriteRawTag(128, 19);
10704 output.WriteBool(SharedTreeWorkerEnablePhaseSharing);
10706 if (HasSharedTreeBalanceTolerance) {
10707 output.WriteRawTag(136, 19);
10708 output.WriteInt32(SharedTreeBalanceTolerance);
10710 if (HasDebugCrashIfPresolveBreaksHint) {
10711 output.WriteRawTag(144, 19);
10712 output.WriteBool(DebugCrashIfPresolveBreaksHint);
10714 if (HasLnsInitialDifficulty) {
10715 output.WriteRawTag(153, 19);
10716 output.WriteDouble(LnsInitialDifficulty);
10718 if (HasLnsInitialDeterministicLimit) {
10719 output.WriteRawTag(161, 19);
10720 output.WriteDouble(LnsInitialDeterministicLimit);
10722 if (HasPolarityExploitLsHints) {
10723 output.WriteRawTag(168, 19);
10724 output.WriteBool(PolarityExploitLsHints);
10726 if (HasRemoveFixedVariablesEarly) {
10727 output.WriteRawTag(176, 19);
10728 output.WriteBool(RemoveFixedVariablesEarly);
10730 if (HasUseAllDifferentForCircuit) {
10731 output.WriteRawTag(184, 19);
10732 output.WriteBool(UseAllDifferentForCircuit);
10734 if (HasRoutingCutSubsetSizeForBinaryRelationBound) {
10735 output.WriteRawTag(192, 19);
10736 output.WriteInt32(RoutingCutSubsetSizeForBinaryRelationBound);
10738 if (HasRoutingCutSubsetSizeForTightBinaryRelationBound) {
10739 output.WriteRawTag(200, 19);
10740 output.WriteInt32(RoutingCutSubsetSizeForTightBinaryRelationBound);
10742 if (HasRoutingCutDpEffort) {
10743 output.WriteRawTag(209, 19);
10744 output.WriteDouble(RoutingCutDpEffort);
10746 if (HasMaximumRegionsToSplitInDisconnectedNoOverlap2D) {
10747 output.WriteRawTag(216, 19);
10748 output.WriteInt32(MaximumRegionsToSplitInDisconnectedNoOverlap2D);
10750 if (_unknownFields !=
null) {
10751 _unknownFields.WriteTo(output);
10756 #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
10757 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
10758 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
10759 void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
10760 if (HasPreferredVariableOrder) {
10761 output.WriteRawTag(8);
10762 output.WriteEnum((
int) PreferredVariableOrder);
10764 if (HasInitialPolarity) {
10765 output.WriteRawTag(16);
10766 output.WriteEnum((
int) InitialPolarity);
10768 if (HasMinimizationAlgorithm) {
10769 output.WriteRawTag(32);
10770 output.WriteEnum((
int) MinimizationAlgorithm);
10772 if (HasClauseCleanupPeriod) {
10773 output.WriteRawTag(88);
10774 output.WriteInt32(ClauseCleanupPeriod);
10776 if (HasClauseCleanupTarget) {
10777 output.WriteRawTag(104);
10778 output.WriteInt32(ClauseCleanupTarget);
10780 if (HasVariableActivityDecay) {
10781 output.WriteRawTag(121);
10782 output.WriteDouble(VariableActivityDecay);
10784 if (HasMaxVariableActivityValue) {
10785 output.WriteRawTag(129, 1);
10786 output.WriteDouble(MaxVariableActivityValue);
10788 if (HasClauseActivityDecay) {
10789 output.WriteRawTag(137, 1);
10790 output.WriteDouble(ClauseActivityDecay);
10792 if (HasMaxClauseActivityValue) {
10793 output.WriteRawTag(145, 1);
10794 output.WriteDouble(MaxClauseActivityValue);
10796 if (HasGlucoseMaxDecay) {
10797 output.WriteRawTag(177, 1);
10798 output.WriteDouble(GlucoseMaxDecay);
10800 if (HasGlucoseDecayIncrement) {
10801 output.WriteRawTag(185, 1);
10802 output.WriteDouble(GlucoseDecayIncrement);
10804 if (HasGlucoseDecayIncrementPeriod) {
10805 output.WriteRawTag(192, 1);
10806 output.WriteInt32(GlucoseDecayIncrementPeriod);
10808 if (HasRestartPeriod) {
10809 output.WriteRawTag(240, 1);
10810 output.WriteInt32(RestartPeriod);
10812 if (HasRandomSeed) {
10813 output.WriteRawTag(248, 1);
10814 output.WriteInt32(RandomSeed);
10816 if (HasRandomBranchesRatio) {
10817 output.WriteRawTag(129, 2);
10818 output.WriteDouble(RandomBranchesRatio);
10820 if (HasBinaryMinimizationAlgorithm) {
10821 output.WriteRawTag(144, 2);
10822 output.WriteEnum((
int) BinaryMinimizationAlgorithm);
10824 if (HasUseOptimizationHints) {
10825 output.WriteRawTag(152, 2);
10826 output.WriteBool(UseOptimizationHints);
10828 if (HasMaxTimeInSeconds) {
10829 output.WriteRawTag(161, 2);
10830 output.WriteDouble(MaxTimeInSeconds);
10832 if (HasMaxNumberOfConflicts) {
10833 output.WriteRawTag(168, 2);
10834 output.WriteInt64(MaxNumberOfConflicts);
10836 if (HasMaxMemoryInMb) {
10837 output.WriteRawTag(192, 2);
10838 output.WriteInt64(MaxMemoryInMb);
10840 if (HasLogSearchProgress) {
10841 output.WriteRawTag(200, 2);
10842 output.WriteBool(LogSearchProgress);
10844 if (HasUsePbResolution) {
10845 output.WriteRawTag(216, 2);
10846 output.WriteBool(UsePbResolution);
10848 if (HasUsePhaseSaving) {
10849 output.WriteRawTag(224, 2);
10850 output.WriteBool(UsePhaseSaving);
10852 if (HasRandomPolarityRatio) {
10853 output.WriteRawTag(233, 2);
10854 output.WriteDouble(RandomPolarityRatio);
10856 if (HasPbCleanupIncrement) {
10857 output.WriteRawTag(240, 2);
10858 output.WriteInt32(PbCleanupIncrement);
10860 if (HasPbCleanupRatio) {
10861 output.WriteRawTag(249, 2);
10862 output.WriteDouble(PbCleanupRatio);
10864 if (HasMinimizeReductionDuringPbResolution) {
10865 output.WriteRawTag(128, 3);
10866 output.WriteBool(MinimizeReductionDuringPbResolution);
10868 if (HasCountAssumptionLevelsInLbd) {
10869 output.WriteRawTag(136, 3);
10870 output.WriteBool(CountAssumptionLevelsInLbd);
10872 if (HasCoreMinimizationLevel) {
10873 output.WriteRawTag(144, 3);
10874 output.WriteInt32(CoreMinimizationLevel);
10876 if (HasMaxSatAssumptionOrder) {
10877 output.WriteRawTag(152, 3);
10878 output.WriteEnum((
int) MaxSatAssumptionOrder);
10880 if (HasMaxSatReverseAssumptionOrder) {
10881 output.WriteRawTag(160, 3);
10882 output.WriteBool(MaxSatReverseAssumptionOrder);
10884 if (HasMaxSatStratification) {
10885 output.WriteRawTag(168, 3);
10886 output.WriteEnum((
int) MaxSatStratification);
10888 if (HasPresolveBveThreshold) {
10889 output.WriteRawTag(176, 3);
10890 output.WriteInt32(PresolveBveThreshold);
10892 if (HasPresolveBveClauseWeight) {
10893 output.WriteRawTag(184, 3);
10894 output.WriteInt32(PresolveBveClauseWeight);
10896 if (HasSubsumptionDuringConflictAnalysis) {
10897 output.WriteRawTag(192, 3);
10898 output.WriteBool(SubsumptionDuringConflictAnalysis);
10900 if (HasPresolveProbingDeterministicTimeLimit) {
10901 output.WriteRawTag(201, 3);
10902 output.WriteDouble(PresolveProbingDeterministicTimeLimit);
10904 if (HasClauseCleanupProtection) {
10905 output.WriteRawTag(208, 3);
10906 output.WriteEnum((
int) ClauseCleanupProtection);
10908 if (HasClauseCleanupLbdBound) {
10909 output.WriteRawTag(216, 3);
10910 output.WriteInt32(ClauseCleanupLbdBound);
10912 if (HasClauseCleanupOrdering) {
10913 output.WriteRawTag(224, 3);
10914 output.WriteEnum((
int) ClauseCleanupOrdering);
10916 restartAlgorithms_.WriteTo(ref output, _repeated_restartAlgorithms_codec);
10917 if (HasRestartRunningWindowSize) {
10918 output.WriteRawTag(240, 3);
10919 output.WriteInt32(RestartRunningWindowSize);
10921 if (HasRestartDlAverageRatio) {
10922 output.WriteRawTag(249, 3);
10923 output.WriteDouble(RestartDlAverageRatio);
10925 if (HasUseBlockingRestart) {
10926 output.WriteRawTag(128, 4);
10927 output.WriteBool(UseBlockingRestart);
10929 if (HasBlockingRestartWindowSize) {
10930 output.WriteRawTag(136, 4);
10931 output.WriteInt32(BlockingRestartWindowSize);
10933 if (HasBlockingRestartMultiplier) {
10934 output.WriteRawTag(145, 4);
10935 output.WriteDouble(BlockingRestartMultiplier);
10937 if (HasMaxDeterministicTime) {
10938 output.WriteRawTag(153, 4);
10939 output.WriteDouble(MaxDeterministicTime);
10941 if (HasNumConflictsBeforeStrategyChanges) {
10942 output.WriteRawTag(160, 4);
10943 output.WriteInt32(NumConflictsBeforeStrategyChanges);
10945 if (HasStrategyChangeIncreaseRatio) {
10946 output.WriteRawTag(169, 4);
10947 output.WriteDouble(StrategyChangeIncreaseRatio);
10949 if (HasDefaultRestartAlgorithms) {
10950 output.WriteRawTag(178, 4);
10951 output.WriteString(DefaultRestartAlgorithms);
10953 if (HasRestartLbdAverageRatio) {
10954 output.WriteRawTag(185, 4);
10955 output.WriteDouble(RestartLbdAverageRatio);
10957 if (HasPresolveUseBva) {
10958 output.WriteRawTag(192, 4);
10959 output.WriteBool(PresolveUseBva);
10961 if (HasPresolveBvaThreshold) {
10962 output.WriteRawTag(200, 4);
10963 output.WriteInt32(PresolveBvaThreshold);
10965 if (HasUsePrecedencesInDisjunctiveConstraint) {
10966 output.WriteRawTag(208, 4);
10967 output.WriteBool(UsePrecedencesInDisjunctiveConstraint);
10969 if (HasUseErwaHeuristic) {
10970 output.WriteRawTag(216, 4);
10971 output.WriteBool(UseErwaHeuristic);
10973 if (HasInitialVariablesActivity) {
10974 output.WriteRawTag(225, 4);
10975 output.WriteDouble(InitialVariablesActivity);
10977 if (HasAlsoBumpVariablesInConflictReasons) {
10978 output.WriteRawTag(232, 4);
10979 output.WriteBool(AlsoBumpVariablesInConflictReasons);
10981 if (HasUseOverloadCheckerInCumulative) {
10982 output.WriteRawTag(240, 4);
10983 output.WriteBool(UseOverloadCheckerInCumulative);
10985 if (HasUseTimetableEdgeFindingInCumulative) {
10986 output.WriteRawTag(248, 4);
10987 output.WriteBool(UseTimetableEdgeFindingInCumulative);
10989 if (HasUseDisjunctiveConstraintInCumulative) {
10990 output.WriteRawTag(128, 5);
10991 output.WriteBool(UseDisjunctiveConstraintInCumulative);
10993 if (HasSearchBranching) {
10994 output.WriteRawTag(144, 5);
10995 output.WriteEnum((
int) SearchBranching);
10997 if (HasOptimizeWithCore) {
10998 output.WriteRawTag(152, 5);
10999 output.WriteBool(OptimizeWithCore);
11001 if (HasFindMultipleCores) {
11002 output.WriteRawTag(160, 5);
11003 output.WriteBool(FindMultipleCores);
11005 if (HasOptimizeWithMaxHs) {
11006 output.WriteRawTag(168, 5);
11007 output.WriteBool(OptimizeWithMaxHs);
11009 if (HasCpModelPresolve) {
11010 output.WriteRawTag(176, 5);
11011 output.WriteBool(CpModelPresolve);
11013 if (HasEnumerateAllSolutions) {
11014 output.WriteRawTag(184, 5);
11015 output.WriteBool(EnumerateAllSolutions);
11017 if (HasPresolveBlockedClause) {
11018 output.WriteRawTag(192, 5);
11019 output.WriteBool(PresolveBlockedClause);
11021 if (HasCoverOptimization) {
11022 output.WriteRawTag(200, 5);
11023 output.WriteBool(CoverOptimization);
11025 if (HasLinearizationLevel) {
11026 output.WriteRawTag(208, 5);
11027 output.WriteInt32(LinearizationLevel);
11029 if (HasMaxNumCuts) {
11030 output.WriteRawTag(216, 5);
11031 output.WriteInt32(MaxNumCuts);
11033 if (HasOnlyAddCutsAtLevelZero) {
11034 output.WriteRawTag(224, 5);
11035 output.WriteBool(OnlyAddCutsAtLevelZero);
11037 if (HasCpModelUseSatPresolve) {
11038 output.WriteRawTag(232, 5);
11039 output.WriteBool(CpModelUseSatPresolve);
11041 if (HasExploitIntegerLpSolution) {
11042 output.WriteRawTag(240, 5);
11043 output.WriteBool(ExploitIntegerLpSolution);
11045 if (HasAutoDetectGreaterThanAtLeastOneOf) {
11046 output.WriteRawTag(248, 5);
11047 output.WriteBool(AutoDetectGreaterThanAtLeastOneOf);
11049 if (HasStopAfterFirstSolution) {
11050 output.WriteRawTag(144, 6);
11051 output.WriteBool(StopAfterFirstSolution);
11053 if (HasBinarySearchNumConflicts) {
11054 output.WriteRawTag(152, 6);
11055 output.WriteInt32(BinarySearchNumConflicts);
11057 if (HasNumSearchWorkers) {
11058 output.WriteRawTag(160, 6);
11059 output.WriteInt32(NumSearchWorkers);
11061 if (HasUseLnsOnly) {
11062 output.WriteRawTag(168, 6);
11063 output.WriteBool(UseLnsOnly);
11065 if (HasRandomizeSearch) {
11066 output.WriteRawTag(184, 6);
11067 output.WriteBool(RandomizeSearch);
11069 if (HasSearchRandomVariablePoolSize) {
11070 output.WriteRawTag(192, 6);
11071 output.WriteInt64(SearchRandomVariablePoolSize);
11073 if (HasInstantiateAllVariables) {
11074 output.WriteRawTag(208, 6);
11075 output.WriteBool(InstantiateAllVariables);
11077 if (HasBooleanEncodingLevel) {
11078 output.WriteRawTag(216, 6);
11079 output.WriteInt32(BooleanEncodingLevel);
11081 if (HasUseOptionalVariables) {
11082 output.WriteRawTag(224, 6);
11083 output.WriteBool(UseOptionalVariables);
11085 if (HasUseExactLpReason) {
11086 output.WriteRawTag(232, 6);
11087 output.WriteBool(UseExactLpReason);
11089 if (HasCpModelProbingLevel) {
11090 output.WriteRawTag(240, 6);
11091 output.WriteInt32(CpModelProbingLevel);
11093 if (HasAddLpConstraintsLazily) {
11094 output.WriteRawTag(128, 7);
11095 output.WriteBool(AddLpConstraintsLazily);
11097 if (HasShareObjectiveBounds) {
11098 output.WriteRawTag(136, 7);
11099 output.WriteBool(ShareObjectiveBounds);
11101 if (HasShareLevelZeroBounds) {
11102 output.WriteRawTag(144, 7);
11103 output.WriteBool(ShareLevelZeroBounds);
11105 if (HasMinOrthogonalityForLpConstraints) {
11106 output.WriteRawTag(153, 7);
11107 output.WriteDouble(MinOrthogonalityForLpConstraints);
11109 if (HasExploitAllLpSolution) {
11110 output.WriteRawTag(160, 7);
11111 output.WriteBool(ExploitAllLpSolution);
11113 if (HasAddCgCuts) {
11114 output.WriteRawTag(168, 7);
11115 output.WriteBool(AddCgCuts);
11117 if (HasMaxIntegerRoundingScaling) {
11118 output.WriteRawTag(184, 7);
11119 output.WriteInt32(MaxIntegerRoundingScaling);
11121 if (HasAddMirCuts) {
11122 output.WriteRawTag(192, 7);
11123 output.WriteBool(AddMirCuts);
11125 if (HasMaxConsecutiveInactiveCount) {
11126 output.WriteRawTag(200, 7);
11127 output.WriteInt32(MaxConsecutiveInactiveCount);
11129 if (HasNewConstraintsBatchSize) {
11130 output.WriteRawTag(208, 7);
11131 output.WriteInt32(NewConstraintsBatchSize);
11133 if (HasPseudoCostReliabilityThreshold) {
11134 output.WriteRawTag(216, 7);
11135 output.WriteInt64(PseudoCostReliabilityThreshold);
11137 if (HasMipMaxBound) {
11138 output.WriteRawTag(225, 7);
11139 output.WriteDouble(MipMaxBound);
11141 if (HasMipVarScaling) {
11142 output.WriteRawTag(233, 7);
11143 output.WriteDouble(MipVarScaling);
11145 if (HasMipWantedPrecision) {
11146 output.WriteRawTag(241, 7);
11147 output.WriteDouble(MipWantedPrecision);
11149 if (HasMipMaxActivityExponent) {
11150 output.WriteRawTag(248, 7);
11151 output.WriteInt32(MipMaxActivityExponent);
11153 if (HasMipCheckPrecision) {
11154 output.WriteRawTag(129, 8);
11155 output.WriteDouble(MipCheckPrecision);
11157 if (HasUseRinsLns) {
11158 output.WriteRawTag(136, 8);
11159 output.WriteBool(UseRinsLns);
11161 if (HasExploitBestSolution) {
11162 output.WriteRawTag(144, 8);
11163 output.WriteBool(ExploitBestSolution);
11165 if (HasExploitObjective) {
11166 output.WriteRawTag(152, 8);
11167 output.WriteBool(ExploitObjective);
11169 if (HasFillTightenedDomainsInResponse) {
11170 output.WriteRawTag(160, 8);
11171 output.WriteBool(FillTightenedDomainsInResponse);
11173 if (HasUseCombinedNoOverlap) {
11174 output.WriteRawTag(168, 8);
11175 output.WriteBool(UseCombinedNoOverlap);
11177 if (HasInterleaveBatchSize) {
11178 output.WriteRawTag(176, 8);
11179 output.WriteInt32(InterleaveBatchSize);
11181 if (HasCatchSigintSignal) {
11182 output.WriteRawTag(184, 8);
11183 output.WriteBool(CatchSigintSignal);
11185 if (HasInterleaveSearch) {
11186 output.WriteRawTag(192, 8);
11187 output.WriteBool(InterleaveSearch);
11189 if (HasDiversifyLnsParams) {
11190 output.WriteRawTag(200, 8);
11191 output.WriteBool(DiversifyLnsParams);
11193 if (HasMaxPresolveIterations) {
11194 output.WriteRawTag(208, 8);
11195 output.WriteInt32(MaxPresolveIterations);
11197 if (HasUseImpliedBounds) {
11198 output.WriteRawTag(128, 9);
11199 output.WriteBool(UseImpliedBounds);
11201 if (HasMergeNoOverlapWorkLimit) {
11202 output.WriteRawTag(137, 9);
11203 output.WriteDouble(MergeNoOverlapWorkLimit);
11205 if (HasMergeAtMostOneWorkLimit) {
11206 output.WriteRawTag(145, 9);
11207 output.WriteDouble(MergeAtMostOneWorkLimit);
11209 if (HasPresolveSubstitutionLevel) {
11210 output.WriteRawTag(152, 9);
11211 output.WriteInt32(PresolveSubstitutionLevel);
11213 if (HasMaxAllDiffCutSize) {
11214 output.WriteRawTag(160, 9);
11215 output.WriteInt32(MaxAllDiffCutSize);
11217 if (HasStopAfterPresolve) {
11218 output.WriteRawTag(168, 9);
11219 output.WriteBool(StopAfterPresolve);
11221 if (HasDebugMaxNumPresolveOperations) {
11222 output.WriteRawTag(184, 9);
11223 output.WriteInt32(DebugMaxNumPresolveOperations);
11225 if (HasAddLinMaxCuts) {
11226 output.WriteRawTag(192, 9);
11227 output.WriteBool(AddLinMaxCuts);
11229 if (HasHintConflictLimit) {
11230 output.WriteRawTag(200, 9);
11231 output.WriteInt32(HintConflictLimit);
11233 if (HasMaxCutRoundsAtLevelZero) {
11234 output.WriteRawTag(208, 9);
11235 output.WriteInt32(MaxCutRoundsAtLevelZero);
11237 if (HasCutMaxActiveCountValue) {
11238 output.WriteRawTag(217, 9);
11239 output.WriteDouble(CutMaxActiveCountValue);
11241 if (HasCutActiveCountDecay) {
11242 output.WriteRawTag(225, 9);
11243 output.WriteDouble(CutActiveCountDecay);
11245 if (HasCutCleanupTarget) {
11246 output.WriteRawTag(232, 9);
11247 output.WriteInt32(CutCleanupTarget);
11249 if (HasAbsoluteGapLimit) {
11250 output.WriteRawTag(249, 9);
11251 output.WriteDouble(AbsoluteGapLimit);
11253 if (HasRelativeGapLimit) {
11254 output.WriteRawTag(129, 10);
11255 output.WriteDouble(RelativeGapLimit);
11257 if (HasExploitRelaxationSolution) {
11258 output.WriteRawTag(136, 10);
11259 output.WriteBool(ExploitRelaxationSolution);
11261 if (HasDebugPostsolveWithFullSolver) {
11262 output.WriteRawTag(144, 10);
11263 output.WriteBool(DebugPostsolveWithFullSolver);
11265 if (HasUseSatInprocessing) {
11266 output.WriteRawTag(152, 10);
11267 output.WriteBool(UseSatInprocessing);
11269 if (HasUseFeasibilityPump) {
11270 output.WriteRawTag(160, 10);
11271 output.WriteBool(UseFeasibilityPump);
11273 if (HasFpRounding) {
11274 output.WriteRawTag(168, 10);
11275 output.WriteEnum((
int) FpRounding);
11277 if (HasMipAutomaticallyScaleVariables) {
11278 output.WriteRawTag(176, 10);
11279 output.WriteBool(MipAutomaticallyScaleVariables);
11281 if (HasRepairHint) {
11282 output.WriteRawTag(184, 10);
11283 output.WriteBool(RepairHint);
11285 if (HasPolarityRephaseIncrement) {
11286 output.WriteRawTag(192, 10);
11287 output.WriteInt32(PolarityRephaseIncrement);
11289 if (HasAddZeroHalfCuts) {
11290 output.WriteRawTag(200, 10);
11291 output.WriteBool(AddZeroHalfCuts);
11293 if (HasExpandAlldiffConstraints) {
11294 output.WriteRawTag(208, 10);
11295 output.WriteBool(ExpandAlldiffConstraints);
11298 output.WriteRawTag(218, 10);
11299 output.WriteString(Name);
11301 if (HasAddCliqueCuts) {
11302 output.WriteRawTag(224, 10);
11303 output.WriteBool(AddCliqueCuts);
11305 if (HasKeepAllFeasibleSolutionsInPresolve) {
11306 output.WriteRawTag(232, 10);
11307 output.WriteBool(KeepAllFeasibleSolutionsInPresolve);
11309 if (HasPresolveExtractIntegerEnforcement) {
11310 output.WriteRawTag(240, 10);
11311 output.WriteBool(PresolveExtractIntegerEnforcement);
11313 if (HasPolishLpSolution) {
11314 output.WriteRawTag(248, 10);
11315 output.WriteBool(PolishLpSolution);
11317 if (HasUseProbingSearch) {
11318 output.WriteRawTag(128, 11);
11319 output.WriteBool(UseProbingSearch);
11321 if (HasConvertIntervals) {
11322 output.WriteRawTag(136, 11);
11323 output.WriteBool(ConvertIntervals);
11325 if (HasPermuteVariableRandomly) {
11326 output.WriteRawTag(144, 11);
11327 output.WriteBool(PermuteVariableRandomly);
11329 if (HasPermutePresolveConstraintOrder) {
11330 output.WriteRawTag(152, 11);
11331 output.WriteBool(PermutePresolveConstraintOrder);
11333 if (HasUseAbslRandom) {
11334 output.WriteRawTag(160, 11);
11335 output.WriteBool(UseAbslRandom);
11337 if (HasDisableConstraintExpansion) {
11338 output.WriteRawTag(168, 11);
11339 output.WriteBool(DisableConstraintExpansion);
11341 if (HasExpandReservoirConstraints) {
11342 output.WriteRawTag(176, 11);
11343 output.WriteBool(ExpandReservoirConstraints);
11345 if (HasSymmetryLevel) {
11346 output.WriteRawTag(184, 11);
11347 output.WriteInt32(SymmetryLevel);
11349 if (HasLogPrefix) {
11350 output.WriteRawTag(202, 11);
11351 output.WriteString(LogPrefix);
11353 if (HasLogToStdout) {
11354 output.WriteRawTag(208, 11);
11355 output.WriteBool(LogToStdout);
11357 if (HasLogToResponse) {
11358 output.WriteRawTag(216, 11);
11359 output.WriteBool(LogToResponse);
11361 if (HasOptimizeWithLbTreeSearch) {
11362 output.WriteRawTag(224, 11);
11363 output.WriteBool(OptimizeWithLbTreeSearch);
11365 if (HasLogSubsolverStatistics) {
11366 output.WriteRawTag(232, 11);
11367 output.WriteBool(LogSubsolverStatistics);
11369 if (HasClauseCleanupRatio) {
11370 output.WriteRawTag(241, 11);
11371 output.WriteDouble(ClauseCleanupRatio);
11373 if (HasMaxDomainSizeWhenEncodingEqNeqConstraints) {
11374 output.WriteRawTag(248, 11);
11375 output.WriteInt32(MaxDomainSizeWhenEncodingEqNeqConstraints);
11377 if (HasFixVariablesToTheirHintedValue) {
11378 output.WriteRawTag(128, 12);
11379 output.WriteBool(FixVariablesToTheirHintedValue);
11381 if (HasSolutionPoolSize) {
11382 output.WriteRawTag(136, 12);
11383 output.WriteInt32(SolutionPoolSize);
11385 if (HasFillAdditionalSolutionsInResponse) {
11386 output.WriteRawTag(144, 12);
11387 output.WriteBool(FillAdditionalSolutionsInResponse);
11389 if (HasDebugCrashOnBadHint) {
11390 output.WriteRawTag(152, 12);
11391 output.WriteBool(DebugCrashOnBadHint);
11394 output.WriteRawTag(160, 12);
11395 output.WriteInt32(CutLevel);
11397 if (HasAddObjectiveCut) {
11398 output.WriteRawTag(168, 12);
11399 output.WriteBool(AddObjectiveCut);
11401 if (HasMipComputeTrueObjectiveBound) {
11402 output.WriteRawTag(176, 12);
11403 output.WriteBool(MipComputeTrueObjectiveBound);
11405 if (HasMipMaxValidMagnitude) {
11406 output.WriteRawTag(185, 12);
11407 output.WriteDouble(MipMaxValidMagnitude);
11409 if (HasUseTimetablingInNoOverlap2D) {
11410 output.WriteRawTag(192, 12);
11411 output.WriteBool(UseTimetablingInNoOverlap2D);
11413 if (HasPresolveInclusionWorkLimit) {
11414 output.WriteRawTag(200, 12);
11415 output.WriteInt64(PresolveInclusionWorkLimit);
11417 if (HasIgnoreNames) {
11418 output.WriteRawTag(208, 12);
11419 output.WriteBool(IgnoreNames);
11421 if (HasShareBinaryClauses) {
11422 output.WriteRawTag(216, 12);
11423 output.WriteBool(ShareBinaryClauses);
11425 if (HasUseShavingInProbingSearch) {
11426 output.WriteRawTag(224, 12);
11427 output.WriteBool(UseShavingInProbingSearch);
11429 if (HasShavingSearchDeterministicTime) {
11430 output.WriteRawTag(233, 12);
11431 output.WriteDouble(ShavingSearchDeterministicTime);
11433 if (HasNumWorkers) {
11434 output.WriteRawTag(240, 12);
11435 output.WriteInt32(NumWorkers);
11437 subsolvers_.WriteTo(ref output, _repeated_subsolvers_codec);
11438 ignoreSubsolvers_.WriteTo(ref output, _repeated_ignoreSubsolvers_codec);
11439 subsolverParams_.WriteTo(ref output, _repeated_subsolverParams_codec);
11440 if (HasUseEnergeticReasoningInNoOverlap2D) {
11441 output.WriteRawTag(168, 13);
11442 output.WriteBool(UseEnergeticReasoningInNoOverlap2D);
11444 if (HasUseDualSchedulingHeuristics) {
11445 output.WriteRawTag(176, 13);
11446 output.WriteBool(UseDualSchedulingHeuristics);
11448 if (HasUseHardPrecedencesInCumulative) {
11449 output.WriteRawTag(184, 13);
11450 output.WriteBool(UseHardPrecedencesInCumulative);
11452 if (HasDetectTableWithCost) {
11453 output.WriteRawTag(192, 13);
11454 output.WriteBool(DetectTableWithCost);
11456 if (HasTableCompressionLevel) {
11457 output.WriteRawTag(200, 13);
11458 output.WriteInt32(TableCompressionLevel);
11460 extraSubsolvers_.WriteTo(ref output, _repeated_extraSubsolvers_codec);
11461 if (HasExploitAllPrecedences) {
11462 output.WriteRawTag(224, 13);
11463 output.WriteBool(ExploitAllPrecedences);
11465 if (HasPropagationLoopDetectionFactor) {
11466 output.WriteRawTag(233, 13);
11467 output.WriteDouble(PropagationLoopDetectionFactor);
11469 if (HasOnlySolveIp) {
11470 output.WriteRawTag(240, 13);
11471 output.WriteBool(OnlySolveIp);
11473 if (HasEncodeComplexLinearConstraintWithInteger) {
11474 output.WriteRawTag(248, 13);
11475 output.WriteBool(EncodeComplexLinearConstraintWithInteger);
11477 if (HasNewLinearPropagation) {
11478 output.WriteRawTag(128, 14);
11479 output.WriteBool(NewLinearPropagation);
11481 if (HasMipScaleLargeDomain) {
11482 output.WriteRawTag(136, 14);
11483 output.WriteBool(MipScaleLargeDomain);
11485 if (HasProbingDeterministicTimeLimit) {
11486 output.WriteRawTag(145, 14);
11487 output.WriteDouble(ProbingDeterministicTimeLimit);
11489 if (HasRootLpIterations) {
11490 output.WriteRawTag(152, 14);
11491 output.WriteInt32(RootLpIterations);
11493 if (HasUseObjectiveLbSearch) {
11494 output.WriteRawTag(160, 14);
11495 output.WriteBool(UseObjectiveLbSearch);
11497 if (HasMaxSizeToCreatePrecedenceLiteralsInDisjunctive) {
11498 output.WriteRawTag(168, 14);
11499 output.WriteInt32(MaxSizeToCreatePrecedenceLiteralsInDisjunctive);
11501 if (HasUseStrongPropagationInDisjunctive) {
11502 output.WriteRawTag(176, 14);
11503 output.WriteBool(UseStrongPropagationInDisjunctive);
11505 if (HasMipDropTolerance) {
11506 output.WriteRawTag(193, 14);
11507 output.WriteDouble(MipDropTolerance);
11509 if (HasInferAllDiffs) {
11510 output.WriteRawTag(200, 14);
11511 output.WriteBool(InferAllDiffs);
11513 if (HasFindBigLinearOverlap) {
11514 output.WriteRawTag(208, 14);
11515 output.WriteBool(FindBigLinearOverlap);
11517 if (HasSharedTreeNumWorkers) {
11518 output.WriteRawTag(216, 14);
11519 output.WriteInt32(SharedTreeNumWorkers);
11521 if (HasUseSharedTreeSearch) {
11522 output.WriteRawTag(224, 14);
11523 output.WriteBool(UseSharedTreeSearch);
11525 if (HasSharedTreeMaxNodesPerWorker) {
11526 output.WriteRawTag(240, 14);
11527 output.WriteInt32(SharedTreeMaxNodesPerWorker);
11529 if (HasSharedTreeSplitStrategy) {
11530 output.WriteRawTag(248, 14);
11531 output.WriteEnum((
int) SharedTreeSplitStrategy);
11533 if (HasUseLsOnly) {
11534 output.WriteRawTag(128, 15);
11535 output.WriteBool(UseLsOnly);
11537 if (HasFeasibilityJumpDecay) {
11538 output.WriteRawTag(145, 15);
11539 output.WriteDouble(FeasibilityJumpDecay);
11541 if (HasNumViolationLs) {
11542 output.WriteRawTag(160, 15);
11543 output.WriteInt32(NumViolationLs);
11545 if (HasFeasibilityJumpVarRandomizationProbability) {
11546 output.WriteRawTag(185, 15);
11547 output.WriteDouble(FeasibilityJumpVarRandomizationProbability);
11549 if (HasFeasibilityJumpVarPerburbationRangeRatio) {
11550 output.WriteRawTag(193, 15);
11551 output.WriteDouble(FeasibilityJumpVarPerburbationRangeRatio);
11553 if (HasViolationLsPerturbationPeriod) {
11554 output.WriteRawTag(200, 15);
11555 output.WriteInt32(ViolationLsPerturbationPeriod);
11557 if (HasFeasibilityJumpEnableRestarts) {
11558 output.WriteRawTag(208, 15);
11559 output.WriteBool(FeasibilityJumpEnableRestarts);
11561 if (HasStopAfterRootPropagation) {
11562 output.WriteRawTag(224, 15);
11563 output.WriteBool(StopAfterRootPropagation);
11565 if (HasUseObjectiveShavingSearch) {
11566 output.WriteRawTag(232, 15);
11567 output.WriteBool(UseObjectiveShavingSearch);
11569 if (HasUseLbRelaxLns) {
11570 output.WriteRawTag(248, 15);
11571 output.WriteBool(UseLbRelaxLns);
11573 if (HasLinearSplitSize) {
11574 output.WriteRawTag(128, 16);
11575 output.WriteInt32(LinearSplitSize);
11577 if (HasFeasibilityJumpLinearizationLevel) {
11578 output.WriteRawTag(136, 16);
11579 output.WriteInt32(FeasibilityJumpLinearizationLevel);
11581 if (HasFeasibilityJumpRestartFactor) {
11582 output.WriteRawTag(144, 16);
11583 output.WriteInt32(FeasibilityJumpRestartFactor);
11585 if (HasViolationLsCompoundMoveProbability) {
11586 output.WriteRawTag(153, 16);
11587 output.WriteDouble(ViolationLsCompoundMoveProbability);
11589 if (HasMaxNumIntervalsForTimetableEdgeFinding) {
11590 output.WriteRawTag(160, 16);
11591 output.WriteInt32(MaxNumIntervalsForTimetableEdgeFinding);
11593 if (HasMipPresolveLevel) {
11594 output.WriteRawTag(168, 16);
11595 output.WriteInt32(MipPresolveLevel);
11597 if (HasPushAllTasksTowardStart) {
11598 output.WriteRawTag(176, 16);
11599 output.WriteBool(PushAllTasksTowardStart);
11601 if (HasUseDynamicPrecedenceInDisjunctive) {
11602 output.WriteRawTag(184, 16);
11603 output.WriteBool(UseDynamicPrecedenceInDisjunctive);
11605 if (HasFeasibilityJumpMaxExpandedConstraintSize) {
11606 output.WriteRawTag(192, 16);
11607 output.WriteInt32(FeasibilityJumpMaxExpandedConstraintSize);
11609 if (HasUseFeasibilityJump) {
11610 output.WriteRawTag(200, 16);
11611 output.WriteBool(UseFeasibilityJump);
11613 if (HasLpPrimalTolerance) {
11614 output.WriteRawTag(209, 16);
11615 output.WriteDouble(LpPrimalTolerance);
11617 if (HasLpDualTolerance) {
11618 output.WriteRawTag(217, 16);
11619 output.WriteDouble(LpDualTolerance);
11621 if (HasUseDynamicPrecedenceInCumulative) {
11622 output.WriteRawTag(224, 16);
11623 output.WriteBool(UseDynamicPrecedenceInCumulative);
11625 if (HasUseExtendedProbing) {
11626 output.WriteRawTag(232, 16);
11627 output.WriteBool(UseExtendedProbing);
11629 if (HasAtMostOneMaxExpansionSize) {
11630 output.WriteRawTag(240, 16);
11631 output.WriteInt32(AtMostOneMaxExpansionSize);
11633 if (HasUseAreaEnergeticReasoningInNoOverlap2D) {
11634 output.WriteRawTag(248, 16);
11635 output.WriteBool(UseAreaEnergeticReasoningInNoOverlap2D);
11637 if (HasProbingNumCombinationsLimit) {
11638 output.WriteRawTag(128, 17);
11639 output.WriteInt32(ProbingNumCombinationsLimit);
11641 if (HasInprocessingDtimeRatio) {
11642 output.WriteRawTag(137, 17);
11643 output.WriteDouble(InprocessingDtimeRatio);
11645 if (HasInprocessingProbingDtime) {
11646 output.WriteRawTag(145, 17);
11647 output.WriteDouble(InprocessingProbingDtime);
11649 if (HasInprocessingMinimizationDtime) {
11650 output.WriteRawTag(153, 17);
11651 output.WriteDouble(InprocessingMinimizationDtime);
11653 if (HasMaxPairsPairwiseReasoningInNoOverlap2D) {
11654 output.WriteRawTag(160, 17);
11655 output.WriteInt32(MaxPairsPairwiseReasoningInNoOverlap2D);
11657 if (HasDetectLinearizedProduct) {
11658 output.WriteRawTag(168, 17);
11659 output.WriteBool(DetectLinearizedProduct);
11661 if (HasMipTreatHighMagnitudeBoundsAsInfinity) {
11662 output.WriteRawTag(176, 17);
11663 output.WriteBool(MipTreatHighMagnitudeBoundsAsInfinity);
11665 if (HasAddRltCuts) {
11666 output.WriteRawTag(184, 17);
11667 output.WriteBool(AddRltCuts);
11669 if (HasMaxLinMaxSizeForExpansion) {
11670 output.WriteRawTag(192, 17);
11671 output.WriteInt32(MaxLinMaxSizeForExpansion);
11673 if (HasSharedTreeOpenLeavesPerWorker) {
11674 output.WriteRawTag(201, 17);
11675 output.WriteDouble(SharedTreeOpenLeavesPerWorker);
11677 if (HasSharedTreeWorkerMinRestartsPerSubtree) {
11678 output.WriteRawTag(208, 17);
11679 output.WriteInt32(SharedTreeWorkerMinRestartsPerSubtree);
11682 output.WriteRawTag(216, 17);
11683 output.WriteBool(UseLns);
11685 if (HasSaveLpBasisInLbTreeSearch) {
11686 output.WriteRawTag(224, 17);
11687 output.WriteBool(SaveLpBasisInLbTreeSearch);
11689 if (HasShareGlueClauses) {
11690 output.WriteRawTag(232, 17);
11691 output.WriteBool(ShareGlueClauses);
11693 if (HasUseConservativeScaleOverloadChecker) {
11694 output.WriteRawTag(240, 17);
11695 output.WriteBool(UseConservativeScaleOverloadChecker);
11697 if (HasEncodeCumulativeAsReservoir) {
11698 output.WriteRawTag(248, 17);
11699 output.WriteBool(EncodeCumulativeAsReservoir);
11701 if (HasExpandReservoirUsingCircuit) {
11702 output.WriteRawTag(128, 18);
11703 output.WriteBool(ExpandReservoirUsingCircuit);
11705 if (HasUseVariablesShavingSearch) {
11706 output.WriteRawTag(136, 18);
11707 output.WriteBool(UseVariablesShavingSearch);
11709 if (HasShavingSearchThreshold) {
11710 output.WriteRawTag(144, 18);
11711 output.WriteInt64(ShavingSearchThreshold);
11713 if (HasMaxNumDeterministicBatches) {
11714 output.WriteRawTag(152, 18);
11715 output.WriteInt32(MaxNumDeterministicBatches);
11717 if (HasFeasibilityJumpBatchDtime) {
11718 output.WriteRawTag(161, 18);
11719 output.WriteDouble(FeasibilityJumpBatchDtime);
11721 filterSubsolvers_.WriteTo(ref output, _repeated_filterSubsolvers_codec);
11722 if (HasNumFullSubsolvers) {
11723 output.WriteRawTag(176, 18);
11724 output.WriteInt32(NumFullSubsolvers);
11726 if (HasSharedTreeWorkerEnableTrailSharing) {
11727 output.WriteRawTag(184, 18);
11728 output.WriteBool(SharedTreeWorkerEnableTrailSharing);
11730 if (HasLbRelaxNumWorkersThreshold) {
11731 output.WriteRawTag(192, 18);
11732 output.WriteInt32(LbRelaxNumWorkersThreshold);
11734 if (HasInprocessingMinimizationUseConflictAnalysis) {
11735 output.WriteRawTag(200, 18);
11736 output.WriteBool(InprocessingMinimizationUseConflictAnalysis);
11738 if (HasInprocessingMinimizationUseAllOrderings) {
11739 output.WriteRawTag(208, 18);
11740 output.WriteBool(InprocessingMinimizationUseAllOrderings);
11742 if (HasUseTryEdgeReasoningInNoOverlap2D) {
11743 output.WriteRawTag(216, 18);
11744 output.WriteBool(UseTryEdgeReasoningInNoOverlap2D);
11746 if (HasMinimizeSharedClauses) {
11747 output.WriteRawTag(224, 18);
11748 output.WriteBool(MinimizeSharedClauses);
11750 if (HasUseSymmetryInLp) {
11751 output.WriteRawTag(232, 18);
11752 output.WriteBool(UseSymmetryInLp);
11754 if (HasSymmetryDetectionDeterministicTimeLimit) {
11755 output.WriteRawTag(241, 18);
11756 output.WriteDouble(SymmetryDetectionDeterministicTimeLimit);
11758 if (HasKeepSymmetryInPresolve) {
11759 output.WriteRawTag(248, 18);
11760 output.WriteBool(KeepSymmetryInPresolve);
11762 if (HasSharedTreeWorkerEnablePhaseSharing) {
11763 output.WriteRawTag(128, 19);
11764 output.WriteBool(SharedTreeWorkerEnablePhaseSharing);
11766 if (HasSharedTreeBalanceTolerance) {
11767 output.WriteRawTag(136, 19);
11768 output.WriteInt32(SharedTreeBalanceTolerance);
11770 if (HasDebugCrashIfPresolveBreaksHint) {
11771 output.WriteRawTag(144, 19);
11772 output.WriteBool(DebugCrashIfPresolveBreaksHint);
11774 if (HasLnsInitialDifficulty) {
11775 output.WriteRawTag(153, 19);
11776 output.WriteDouble(LnsInitialDifficulty);
11778 if (HasLnsInitialDeterministicLimit) {
11779 output.WriteRawTag(161, 19);
11780 output.WriteDouble(LnsInitialDeterministicLimit);
11782 if (HasPolarityExploitLsHints) {
11783 output.WriteRawTag(168, 19);
11784 output.WriteBool(PolarityExploitLsHints);
11786 if (HasRemoveFixedVariablesEarly) {
11787 output.WriteRawTag(176, 19);
11788 output.WriteBool(RemoveFixedVariablesEarly);
11790 if (HasUseAllDifferentForCircuit) {
11791 output.WriteRawTag(184, 19);
11792 output.WriteBool(UseAllDifferentForCircuit);
11794 if (HasRoutingCutSubsetSizeForBinaryRelationBound) {
11795 output.WriteRawTag(192, 19);
11796 output.WriteInt32(RoutingCutSubsetSizeForBinaryRelationBound);
11798 if (HasRoutingCutSubsetSizeForTightBinaryRelationBound) {
11799 output.WriteRawTag(200, 19);
11800 output.WriteInt32(RoutingCutSubsetSizeForTightBinaryRelationBound);
11802 if (HasRoutingCutDpEffort) {
11803 output.WriteRawTag(209, 19);
11804 output.WriteDouble(RoutingCutDpEffort);
11806 if (HasMaximumRegionsToSplitInDisconnectedNoOverlap2D) {
11807 output.WriteRawTag(216, 19);
11808 output.WriteInt32(MaximumRegionsToSplitInDisconnectedNoOverlap2D);
11810 if (_unknownFields !=
null) {
11811 _unknownFields.WriteTo(ref output);
11816 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
11817 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
11818 public int CalculateSize() {
11821 size += 2 + pb::CodedOutputStream.ComputeStringSize(Name);
11823 if (HasPreferredVariableOrder) {
11824 size += 1 + pb::CodedOutputStream.ComputeEnumSize((
int) PreferredVariableOrder);
11826 if (HasInitialPolarity) {
11827 size += 1 + pb::CodedOutputStream.ComputeEnumSize((
int) InitialPolarity);
11829 if (HasUsePhaseSaving) {
11832 if (HasPolarityRephaseIncrement) {
11833 size += 2 + pb::CodedOutputStream.ComputeInt32Size(PolarityRephaseIncrement);
11835 if (HasPolarityExploitLsHints) {
11838 if (HasRandomPolarityRatio) {
11841 if (HasRandomBranchesRatio) {
11844 if (HasUseErwaHeuristic) {
11847 if (HasInitialVariablesActivity) {
11850 if (HasAlsoBumpVariablesInConflictReasons) {
11853 if (HasMinimizationAlgorithm) {
11854 size += 1 + pb::CodedOutputStream.ComputeEnumSize((
int) MinimizationAlgorithm);
11856 if (HasBinaryMinimizationAlgorithm) {
11857 size += 2 + pb::CodedOutputStream.ComputeEnumSize((
int) BinaryMinimizationAlgorithm);
11859 if (HasSubsumptionDuringConflictAnalysis) {
11862 if (HasClauseCleanupPeriod) {
11863 size += 1 + pb::CodedOutputStream.ComputeInt32Size(ClauseCleanupPeriod);
11865 if (HasClauseCleanupTarget) {
11866 size += 1 + pb::CodedOutputStream.ComputeInt32Size(ClauseCleanupTarget);
11868 if (HasClauseCleanupRatio) {
11871 if (HasClauseCleanupProtection) {
11874 if (HasClauseCleanupLbdBound) {
11875 size += 2 + pb::CodedOutputStream.ComputeInt32Size(ClauseCleanupLbdBound);
11877 if (HasClauseCleanupOrdering) {
11878 size += 2 + pb::CodedOutputStream.ComputeEnumSize((
int) ClauseCleanupOrdering);
11880 if (HasPbCleanupIncrement) {
11881 size += 2 + pb::CodedOutputStream.ComputeInt32Size(PbCleanupIncrement);
11883 if (HasPbCleanupRatio) {
11886 if (HasVariableActivityDecay) {
11889 if (HasMaxVariableActivityValue) {
11892 if (HasGlucoseMaxDecay) {
11895 if (HasGlucoseDecayIncrement) {
11898 if (HasGlucoseDecayIncrementPeriod) {
11899 size += 2 + pb::CodedOutputStream.ComputeInt32Size(GlucoseDecayIncrementPeriod);
11901 if (HasClauseActivityDecay) {
11904 if (HasMaxClauseActivityValue) {
11907 size += restartAlgorithms_.CalculateSize(_repeated_restartAlgorithms_codec);
11908 if (HasDefaultRestartAlgorithms) {
11909 size += 2 + pb::CodedOutputStream.ComputeStringSize(DefaultRestartAlgorithms);
11911 if (HasRestartPeriod) {
11912 size += 2 + pb::CodedOutputStream.ComputeInt32Size(RestartPeriod);
11914 if (HasRestartRunningWindowSize) {
11915 size += 2 + pb::CodedOutputStream.ComputeInt32Size(RestartRunningWindowSize);
11917 if (HasRestartDlAverageRatio) {
11920 if (HasRestartLbdAverageRatio) {
11923 if (HasUseBlockingRestart) {
11926 if (HasBlockingRestartWindowSize) {
11927 size += 2 + pb::CodedOutputStream.ComputeInt32Size(BlockingRestartWindowSize);
11929 if (HasBlockingRestartMultiplier) {
11932 if (HasNumConflictsBeforeStrategyChanges) {
11933 size += 2 + pb::CodedOutputStream.ComputeInt32Size(NumConflictsBeforeStrategyChanges);
11935 if (HasStrategyChangeIncreaseRatio) {
11938 if (HasMaxTimeInSeconds) {
11941 if (HasMaxDeterministicTime) {
11944 if (HasMaxNumDeterministicBatches) {
11945 size += 2 + pb::CodedOutputStream.ComputeInt32Size(MaxNumDeterministicBatches);
11947 if (HasMaxNumberOfConflicts) {
11948 size += 2 + pb::CodedOutputStream.ComputeInt64Size(MaxNumberOfConflicts);
11950 if (HasMaxMemoryInMb) {
11951 size += 2 + pb::CodedOutputStream.ComputeInt64Size(MaxMemoryInMb);
11953 if (HasAbsoluteGapLimit) {
11956 if (HasRelativeGapLimit) {
11959 if (HasRandomSeed) {
11960 size += 2 + pb::CodedOutputStream.ComputeInt32Size(RandomSeed);
11962 if (HasPermuteVariableRandomly) {
11965 if (HasPermutePresolveConstraintOrder) {
11968 if (HasUseAbslRandom) {
11971 if (HasLogSearchProgress) {
11974 if (HasLogSubsolverStatistics) {
11977 if (HasLogPrefix) {
11978 size += 2 + pb::CodedOutputStream.ComputeStringSize(LogPrefix);
11980 if (HasLogToStdout) {
11983 if (HasLogToResponse) {
11986 if (HasUsePbResolution) {
11989 if (HasMinimizeReductionDuringPbResolution) {
11992 if (HasCountAssumptionLevelsInLbd) {
11995 if (HasPresolveBveThreshold) {
11996 size += 2 + pb::CodedOutputStream.ComputeInt32Size(PresolveBveThreshold);
11998 if (HasPresolveBveClauseWeight) {
11999 size += 2 + pb::CodedOutputStream.ComputeInt32Size(PresolveBveClauseWeight);
12001 if (HasProbingDeterministicTimeLimit) {
12004 if (HasPresolveProbingDeterministicTimeLimit) {
12007 if (HasPresolveBlockedClause) {
12010 if (HasPresolveUseBva) {
12013 if (HasPresolveBvaThreshold) {
12014 size += 2 + pb::CodedOutputStream.ComputeInt32Size(PresolveBvaThreshold);
12016 if (HasMaxPresolveIterations) {
12017 size += 2 + pb::CodedOutputStream.ComputeInt32Size(MaxPresolveIterations);
12019 if (HasCpModelPresolve) {
12022 if (HasCpModelProbingLevel) {
12023 size += 2 + pb::CodedOutputStream.ComputeInt32Size(CpModelProbingLevel);
12025 if (HasCpModelUseSatPresolve) {
12028 if (HasRemoveFixedVariablesEarly) {
12031 if (HasDetectTableWithCost) {
12034 if (HasTableCompressionLevel) {
12035 size += 2 + pb::CodedOutputStream.ComputeInt32Size(TableCompressionLevel);
12037 if (HasExpandAlldiffConstraints) {
12040 if (HasExpandReservoirConstraints) {
12043 if (HasExpandReservoirUsingCircuit) {
12046 if (HasEncodeCumulativeAsReservoir) {
12049 if (HasMaxLinMaxSizeForExpansion) {
12050 size += 2 + pb::CodedOutputStream.ComputeInt32Size(MaxLinMaxSizeForExpansion);
12052 if (HasDisableConstraintExpansion) {
12055 if (HasEncodeComplexLinearConstraintWithInteger) {
12058 if (HasMergeNoOverlapWorkLimit) {
12061 if (HasMergeAtMostOneWorkLimit) {
12064 if (HasPresolveSubstitutionLevel) {
12065 size += 2 + pb::CodedOutputStream.ComputeInt32Size(PresolveSubstitutionLevel);
12067 if (HasPresolveExtractIntegerEnforcement) {
12070 if (HasPresolveInclusionWorkLimit) {
12071 size += 2 + pb::CodedOutputStream.ComputeInt64Size(PresolveInclusionWorkLimit);
12073 if (HasIgnoreNames) {
12076 if (HasInferAllDiffs) {
12079 if (HasFindBigLinearOverlap) {
12082 if (HasUseSatInprocessing) {
12085 if (HasInprocessingDtimeRatio) {
12088 if (HasInprocessingProbingDtime) {
12091 if (HasInprocessingMinimizationDtime) {
12094 if (HasInprocessingMinimizationUseConflictAnalysis) {
12097 if (HasInprocessingMinimizationUseAllOrderings) {
12100 if (HasNumWorkers) {
12101 size += 2 + pb::CodedOutputStream.ComputeInt32Size(NumWorkers);
12103 if (HasNumSearchWorkers) {
12104 size += 2 + pb::CodedOutputStream.ComputeInt32Size(NumSearchWorkers);
12106 if (HasNumFullSubsolvers) {
12107 size += 2 + pb::CodedOutputStream.ComputeInt32Size(NumFullSubsolvers);
12109 size += subsolvers_.CalculateSize(_repeated_subsolvers_codec);
12110 size += extraSubsolvers_.CalculateSize(_repeated_extraSubsolvers_codec);
12111 size += ignoreSubsolvers_.CalculateSize(_repeated_ignoreSubsolvers_codec);
12112 size += filterSubsolvers_.CalculateSize(_repeated_filterSubsolvers_codec);
12113 size += subsolverParams_.CalculateSize(_repeated_subsolverParams_codec);
12114 if (HasInterleaveSearch) {
12117 if (HasInterleaveBatchSize) {
12118 size += 2 + pb::CodedOutputStream.ComputeInt32Size(InterleaveBatchSize);
12120 if (HasShareObjectiveBounds) {
12123 if (HasShareLevelZeroBounds) {
12126 if (HasShareBinaryClauses) {
12129 if (HasShareGlueClauses) {
12132 if (HasMinimizeSharedClauses) {
12135 if (HasDebugPostsolveWithFullSolver) {
12138 if (HasDebugMaxNumPresolveOperations) {
12139 size += 2 + pb::CodedOutputStream.ComputeInt32Size(DebugMaxNumPresolveOperations);
12141 if (HasDebugCrashOnBadHint) {
12144 if (HasDebugCrashIfPresolveBreaksHint) {
12147 if (HasUseOptimizationHints) {
12150 if (HasCoreMinimizationLevel) {
12151 size += 2 + pb::CodedOutputStream.ComputeInt32Size(CoreMinimizationLevel);
12153 if (HasFindMultipleCores) {
12156 if (HasCoverOptimization) {
12159 if (HasMaxSatAssumptionOrder) {
12160 size += 2 + pb::CodedOutputStream.ComputeEnumSize((
int) MaxSatAssumptionOrder);
12162 if (HasMaxSatReverseAssumptionOrder) {
12165 if (HasMaxSatStratification) {
12166 size += 2 + pb::CodedOutputStream.ComputeEnumSize((
int) MaxSatStratification);
12168 if (HasPropagationLoopDetectionFactor) {
12171 if (HasUsePrecedencesInDisjunctiveConstraint) {
12174 if (HasMaxSizeToCreatePrecedenceLiteralsInDisjunctive) {
12175 size += 2 + pb::CodedOutputStream.ComputeInt32Size(MaxSizeToCreatePrecedenceLiteralsInDisjunctive);
12177 if (HasUseStrongPropagationInDisjunctive) {
12180 if (HasUseDynamicPrecedenceInDisjunctive) {
12183 if (HasUseDynamicPrecedenceInCumulative) {
12186 if (HasUseOverloadCheckerInCumulative) {
12189 if (HasUseConservativeScaleOverloadChecker) {
12192 if (HasUseTimetableEdgeFindingInCumulative) {
12195 if (HasMaxNumIntervalsForTimetableEdgeFinding) {
12196 size += 2 + pb::CodedOutputStream.ComputeInt32Size(MaxNumIntervalsForTimetableEdgeFinding);
12198 if (HasUseHardPrecedencesInCumulative) {
12201 if (HasExploitAllPrecedences) {
12204 if (HasUseDisjunctiveConstraintInCumulative) {
12207 if (HasUseTimetablingInNoOverlap2D) {
12210 if (HasUseEnergeticReasoningInNoOverlap2D) {
12213 if (HasUseAreaEnergeticReasoningInNoOverlap2D) {
12216 if (HasUseTryEdgeReasoningInNoOverlap2D) {
12219 if (HasMaxPairsPairwiseReasoningInNoOverlap2D) {
12220 size += 2 + pb::CodedOutputStream.ComputeInt32Size(MaxPairsPairwiseReasoningInNoOverlap2D);
12222 if (HasMaximumRegionsToSplitInDisconnectedNoOverlap2D) {
12223 size += 2 + pb::CodedOutputStream.ComputeInt32Size(MaximumRegionsToSplitInDisconnectedNoOverlap2D);
12225 if (HasUseDualSchedulingHeuristics) {
12228 if (HasUseAllDifferentForCircuit) {
12231 if (HasRoutingCutSubsetSizeForBinaryRelationBound) {
12232 size += 2 + pb::CodedOutputStream.ComputeInt32Size(RoutingCutSubsetSizeForBinaryRelationBound);
12234 if (HasRoutingCutSubsetSizeForTightBinaryRelationBound) {
12235 size += 2 + pb::CodedOutputStream.ComputeInt32Size(RoutingCutSubsetSizeForTightBinaryRelationBound);
12237 if (HasRoutingCutDpEffort) {
12240 if (HasSearchBranching) {
12241 size += 2 + pb::CodedOutputStream.ComputeEnumSize((
int) SearchBranching);
12243 if (HasHintConflictLimit) {
12244 size += 2 + pb::CodedOutputStream.ComputeInt32Size(HintConflictLimit);
12246 if (HasRepairHint) {
12249 if (HasFixVariablesToTheirHintedValue) {
12252 if (HasUseProbingSearch) {
12255 if (HasUseExtendedProbing) {
12258 if (HasProbingNumCombinationsLimit) {
12259 size += 2 + pb::CodedOutputStream.ComputeInt32Size(ProbingNumCombinationsLimit);
12261 if (HasUseShavingInProbingSearch) {
12264 if (HasShavingSearchDeterministicTime) {
12267 if (HasShavingSearchThreshold) {
12268 size += 2 + pb::CodedOutputStream.ComputeInt64Size(ShavingSearchThreshold);
12270 if (HasUseObjectiveLbSearch) {
12273 if (HasUseObjectiveShavingSearch) {
12276 if (HasUseVariablesShavingSearch) {
12279 if (HasPseudoCostReliabilityThreshold) {
12280 size += 2 + pb::CodedOutputStream.ComputeInt64Size(PseudoCostReliabilityThreshold);
12282 if (HasOptimizeWithCore) {
12285 if (HasOptimizeWithLbTreeSearch) {
12288 if (HasSaveLpBasisInLbTreeSearch) {
12291 if (HasBinarySearchNumConflicts) {
12292 size += 2 + pb::CodedOutputStream.ComputeInt32Size(BinarySearchNumConflicts);
12294 if (HasOptimizeWithMaxHs) {
12297 if (HasUseFeasibilityJump) {
12300 if (HasUseLsOnly) {
12303 if (HasFeasibilityJumpDecay) {
12306 if (HasFeasibilityJumpLinearizationLevel) {
12307 size += 2 + pb::CodedOutputStream.ComputeInt32Size(FeasibilityJumpLinearizationLevel);
12309 if (HasFeasibilityJumpRestartFactor) {
12310 size += 2 + pb::CodedOutputStream.ComputeInt32Size(FeasibilityJumpRestartFactor);
12312 if (HasFeasibilityJumpBatchDtime) {
12315 if (HasFeasibilityJumpVarRandomizationProbability) {
12318 if (HasFeasibilityJumpVarPerburbationRangeRatio) {
12321 if (HasFeasibilityJumpEnableRestarts) {
12324 if (HasFeasibilityJumpMaxExpandedConstraintSize) {
12325 size += 2 + pb::CodedOutputStream.ComputeInt32Size(FeasibilityJumpMaxExpandedConstraintSize);
12327 if (HasNumViolationLs) {
12328 size += 2 + pb::CodedOutputStream.ComputeInt32Size(NumViolationLs);
12330 if (HasViolationLsPerturbationPeriod) {
12331 size += 2 + pb::CodedOutputStream.ComputeInt32Size(ViolationLsPerturbationPeriod);
12333 if (HasViolationLsCompoundMoveProbability) {
12336 if (HasSharedTreeNumWorkers) {
12337 size += 2 + pb::CodedOutputStream.ComputeInt32Size(SharedTreeNumWorkers);
12339 if (HasUseSharedTreeSearch) {
12342 if (HasSharedTreeWorkerMinRestartsPerSubtree) {
12343 size += 2 + pb::CodedOutputStream.ComputeInt32Size(SharedTreeWorkerMinRestartsPerSubtree);
12345 if (HasSharedTreeWorkerEnableTrailSharing) {
12348 if (HasSharedTreeWorkerEnablePhaseSharing) {
12351 if (HasSharedTreeOpenLeavesPerWorker) {
12354 if (HasSharedTreeMaxNodesPerWorker) {
12355 size += 2 + pb::CodedOutputStream.ComputeInt32Size(SharedTreeMaxNodesPerWorker);
12357 if (HasSharedTreeSplitStrategy) {
12358 size += 2 + pb::CodedOutputStream.ComputeEnumSize((
int) SharedTreeSplitStrategy);
12360 if (HasSharedTreeBalanceTolerance) {
12361 size += 2 + pb::CodedOutputStream.ComputeInt32Size(SharedTreeBalanceTolerance);
12363 if (HasEnumerateAllSolutions) {
12366 if (HasKeepAllFeasibleSolutionsInPresolve) {
12369 if (HasFillTightenedDomainsInResponse) {
12372 if (HasFillAdditionalSolutionsInResponse) {
12375 if (HasInstantiateAllVariables) {
12378 if (HasAutoDetectGreaterThanAtLeastOneOf) {
12381 if (HasStopAfterFirstSolution) {
12384 if (HasStopAfterPresolve) {
12387 if (HasStopAfterRootPropagation) {
12390 if (HasLnsInitialDifficulty) {
12393 if (HasLnsInitialDeterministicLimit) {
12399 if (HasUseLnsOnly) {
12402 if (HasSolutionPoolSize) {
12403 size += 2 + pb::CodedOutputStream.ComputeInt32Size(SolutionPoolSize);
12405 if (HasUseRinsLns) {
12408 if (HasUseFeasibilityPump) {
12411 if (HasUseLbRelaxLns) {
12414 if (HasLbRelaxNumWorkersThreshold) {
12415 size += 2 + pb::CodedOutputStream.ComputeInt32Size(LbRelaxNumWorkersThreshold);
12417 if (HasFpRounding) {
12418 size += 2 + pb::CodedOutputStream.ComputeEnumSize((
int) FpRounding);
12420 if (HasDiversifyLnsParams) {
12423 if (HasRandomizeSearch) {
12426 if (HasSearchRandomVariablePoolSize) {
12427 size += 2 + pb::CodedOutputStream.ComputeInt64Size(SearchRandomVariablePoolSize);
12429 if (HasPushAllTasksTowardStart) {
12432 if (HasUseOptionalVariables) {
12435 if (HasUseExactLpReason) {
12438 if (HasUseCombinedNoOverlap) {
12441 if (HasAtMostOneMaxExpansionSize) {
12442 size += 2 + pb::CodedOutputStream.ComputeInt32Size(AtMostOneMaxExpansionSize);
12444 if (HasCatchSigintSignal) {
12447 if (HasUseImpliedBounds) {
12450 if (HasPolishLpSolution) {
12453 if (HasLpPrimalTolerance) {
12456 if (HasLpDualTolerance) {
12459 if (HasConvertIntervals) {
12462 if (HasSymmetryLevel) {
12463 size += 2 + pb::CodedOutputStream.ComputeInt32Size(SymmetryLevel);
12465 if (HasUseSymmetryInLp) {
12468 if (HasKeepSymmetryInPresolve) {
12471 if (HasSymmetryDetectionDeterministicTimeLimit) {
12474 if (HasNewLinearPropagation) {
12477 if (HasLinearSplitSize) {
12478 size += 2 + pb::CodedOutputStream.ComputeInt32Size(LinearSplitSize);
12480 if (HasLinearizationLevel) {
12481 size += 2 + pb::CodedOutputStream.ComputeInt32Size(LinearizationLevel);
12483 if (HasBooleanEncodingLevel) {
12484 size += 2 + pb::CodedOutputStream.ComputeInt32Size(BooleanEncodingLevel);
12486 if (HasMaxDomainSizeWhenEncodingEqNeqConstraints) {
12487 size += 2 + pb::CodedOutputStream.ComputeInt32Size(MaxDomainSizeWhenEncodingEqNeqConstraints);
12489 if (HasMaxNumCuts) {
12490 size += 2 + pb::CodedOutputStream.ComputeInt32Size(MaxNumCuts);
12493 size += 2 + pb::CodedOutputStream.ComputeInt32Size(CutLevel);
12495 if (HasOnlyAddCutsAtLevelZero) {
12498 if (HasAddObjectiveCut) {
12501 if (HasAddCgCuts) {
12504 if (HasAddMirCuts) {
12507 if (HasAddZeroHalfCuts) {
12510 if (HasAddCliqueCuts) {
12513 if (HasAddRltCuts) {
12516 if (HasMaxAllDiffCutSize) {
12517 size += 2 + pb::CodedOutputStream.ComputeInt32Size(MaxAllDiffCutSize);
12519 if (HasAddLinMaxCuts) {
12522 if (HasMaxIntegerRoundingScaling) {
12523 size += 2 + pb::CodedOutputStream.ComputeInt32Size(MaxIntegerRoundingScaling);
12525 if (HasAddLpConstraintsLazily) {
12528 if (HasRootLpIterations) {
12529 size += 2 + pb::CodedOutputStream.ComputeInt32Size(RootLpIterations);
12531 if (HasMinOrthogonalityForLpConstraints) {
12534 if (HasMaxCutRoundsAtLevelZero) {
12535 size += 2 + pb::CodedOutputStream.ComputeInt32Size(MaxCutRoundsAtLevelZero);
12537 if (HasMaxConsecutiveInactiveCount) {
12538 size += 2 + pb::CodedOutputStream.ComputeInt32Size(MaxConsecutiveInactiveCount);
12540 if (HasCutMaxActiveCountValue) {
12543 if (HasCutActiveCountDecay) {
12546 if (HasCutCleanupTarget) {
12547 size += 2 + pb::CodedOutputStream.ComputeInt32Size(CutCleanupTarget);
12549 if (HasNewConstraintsBatchSize) {
12550 size += 2 + pb::CodedOutputStream.ComputeInt32Size(NewConstraintsBatchSize);
12552 if (HasExploitIntegerLpSolution) {
12555 if (HasExploitAllLpSolution) {
12558 if (HasExploitBestSolution) {
12561 if (HasExploitRelaxationSolution) {
12564 if (HasExploitObjective) {
12567 if (HasDetectLinearizedProduct) {
12570 if (HasMipMaxBound) {
12573 if (HasMipVarScaling) {
12576 if (HasMipScaleLargeDomain) {
12579 if (HasMipAutomaticallyScaleVariables) {
12582 if (HasOnlySolveIp) {
12585 if (HasMipWantedPrecision) {
12588 if (HasMipMaxActivityExponent) {
12589 size += 2 + pb::CodedOutputStream.ComputeInt32Size(MipMaxActivityExponent);
12591 if (HasMipCheckPrecision) {
12594 if (HasMipComputeTrueObjectiveBound) {
12597 if (HasMipMaxValidMagnitude) {
12600 if (HasMipTreatHighMagnitudeBoundsAsInfinity) {
12603 if (HasMipDropTolerance) {
12606 if (HasMipPresolveLevel) {
12607 size += 2 + pb::CodedOutputStream.ComputeInt32Size(MipPresolveLevel);
12609 if (_unknownFields !=
null) {
12610 size += _unknownFields.CalculateSize();
12615 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
12616 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
12617 public void MergeFrom(SatParameters other) {
12618 if (other ==
null) {
12621 if (other.HasName) {
12624 if (other.HasPreferredVariableOrder) {
12625 PreferredVariableOrder = other.PreferredVariableOrder;
12627 if (other.HasInitialPolarity) {
12628 InitialPolarity = other.InitialPolarity;
12630 if (other.HasUsePhaseSaving) {
12631 UsePhaseSaving = other.UsePhaseSaving;
12633 if (other.HasPolarityRephaseIncrement) {
12634 PolarityRephaseIncrement = other.PolarityRephaseIncrement;
12636 if (other.HasPolarityExploitLsHints) {
12637 PolarityExploitLsHints = other.PolarityExploitLsHints;
12639 if (other.HasRandomPolarityRatio) {
12640 RandomPolarityRatio = other.RandomPolarityRatio;
12642 if (other.HasRandomBranchesRatio) {
12643 RandomBranchesRatio = other.RandomBranchesRatio;
12645 if (other.HasUseErwaHeuristic) {
12646 UseErwaHeuristic = other.UseErwaHeuristic;
12648 if (other.HasInitialVariablesActivity) {
12649 InitialVariablesActivity = other.InitialVariablesActivity;
12651 if (other.HasAlsoBumpVariablesInConflictReasons) {
12652 AlsoBumpVariablesInConflictReasons = other.AlsoBumpVariablesInConflictReasons;
12654 if (other.HasMinimizationAlgorithm) {
12655 MinimizationAlgorithm = other.MinimizationAlgorithm;
12657 if (other.HasBinaryMinimizationAlgorithm) {
12658 BinaryMinimizationAlgorithm = other.BinaryMinimizationAlgorithm;
12660 if (other.HasSubsumptionDuringConflictAnalysis) {
12661 SubsumptionDuringConflictAnalysis = other.SubsumptionDuringConflictAnalysis;
12663 if (other.HasClauseCleanupPeriod) {
12664 ClauseCleanupPeriod = other.ClauseCleanupPeriod;
12666 if (other.HasClauseCleanupTarget) {
12667 ClauseCleanupTarget = other.ClauseCleanupTarget;
12669 if (other.HasClauseCleanupRatio) {
12670 ClauseCleanupRatio = other.ClauseCleanupRatio;
12672 if (other.HasClauseCleanupProtection) {
12673 ClauseCleanupProtection = other.ClauseCleanupProtection;
12675 if (other.HasClauseCleanupLbdBound) {
12676 ClauseCleanupLbdBound = other.ClauseCleanupLbdBound;
12678 if (other.HasClauseCleanupOrdering) {
12679 ClauseCleanupOrdering = other.ClauseCleanupOrdering;
12681 if (other.HasPbCleanupIncrement) {
12682 PbCleanupIncrement = other.PbCleanupIncrement;
12684 if (other.HasPbCleanupRatio) {
12685 PbCleanupRatio = other.PbCleanupRatio;
12687 if (other.HasVariableActivityDecay) {
12688 VariableActivityDecay = other.VariableActivityDecay;
12690 if (other.HasMaxVariableActivityValue) {
12691 MaxVariableActivityValue = other.MaxVariableActivityValue;
12693 if (other.HasGlucoseMaxDecay) {
12694 GlucoseMaxDecay = other.GlucoseMaxDecay;
12696 if (other.HasGlucoseDecayIncrement) {
12697 GlucoseDecayIncrement = other.GlucoseDecayIncrement;
12699 if (other.HasGlucoseDecayIncrementPeriod) {
12700 GlucoseDecayIncrementPeriod = other.GlucoseDecayIncrementPeriod;
12702 if (other.HasClauseActivityDecay) {
12703 ClauseActivityDecay = other.ClauseActivityDecay;
12705 if (other.HasMaxClauseActivityValue) {
12706 MaxClauseActivityValue = other.MaxClauseActivityValue;
12708 restartAlgorithms_.Add(other.restartAlgorithms_);
12709 if (other.HasDefaultRestartAlgorithms) {
12710 DefaultRestartAlgorithms = other.DefaultRestartAlgorithms;
12712 if (other.HasRestartPeriod) {
12713 RestartPeriod = other.RestartPeriod;
12715 if (other.HasRestartRunningWindowSize) {
12716 RestartRunningWindowSize = other.RestartRunningWindowSize;
12718 if (other.HasRestartDlAverageRatio) {
12719 RestartDlAverageRatio = other.RestartDlAverageRatio;
12721 if (other.HasRestartLbdAverageRatio) {
12722 RestartLbdAverageRatio = other.RestartLbdAverageRatio;
12724 if (other.HasUseBlockingRestart) {
12725 UseBlockingRestart = other.UseBlockingRestart;
12727 if (other.HasBlockingRestartWindowSize) {
12728 BlockingRestartWindowSize = other.BlockingRestartWindowSize;
12730 if (other.HasBlockingRestartMultiplier) {
12731 BlockingRestartMultiplier = other.BlockingRestartMultiplier;
12733 if (other.HasNumConflictsBeforeStrategyChanges) {
12734 NumConflictsBeforeStrategyChanges = other.NumConflictsBeforeStrategyChanges;
12736 if (other.HasStrategyChangeIncreaseRatio) {
12737 StrategyChangeIncreaseRatio = other.StrategyChangeIncreaseRatio;
12739 if (other.HasMaxTimeInSeconds) {
12740 MaxTimeInSeconds = other.MaxTimeInSeconds;
12742 if (other.HasMaxDeterministicTime) {
12743 MaxDeterministicTime = other.MaxDeterministicTime;
12745 if (other.HasMaxNumDeterministicBatches) {
12746 MaxNumDeterministicBatches = other.MaxNumDeterministicBatches;
12748 if (other.HasMaxNumberOfConflicts) {
12749 MaxNumberOfConflicts = other.MaxNumberOfConflicts;
12751 if (other.HasMaxMemoryInMb) {
12752 MaxMemoryInMb = other.MaxMemoryInMb;
12754 if (other.HasAbsoluteGapLimit) {
12755 AbsoluteGapLimit = other.AbsoluteGapLimit;
12757 if (other.HasRelativeGapLimit) {
12758 RelativeGapLimit = other.RelativeGapLimit;
12760 if (other.HasRandomSeed) {
12761 RandomSeed = other.RandomSeed;
12763 if (other.HasPermuteVariableRandomly) {
12764 PermuteVariableRandomly = other.PermuteVariableRandomly;
12766 if (other.HasPermutePresolveConstraintOrder) {
12767 PermutePresolveConstraintOrder = other.PermutePresolveConstraintOrder;
12769 if (other.HasUseAbslRandom) {
12770 UseAbslRandom = other.UseAbslRandom;
12772 if (other.HasLogSearchProgress) {
12773 LogSearchProgress = other.LogSearchProgress;
12775 if (other.HasLogSubsolverStatistics) {
12776 LogSubsolverStatistics = other.LogSubsolverStatistics;
12778 if (other.HasLogPrefix) {
12779 LogPrefix = other.LogPrefix;
12781 if (other.HasLogToStdout) {
12782 LogToStdout = other.LogToStdout;
12784 if (other.HasLogToResponse) {
12785 LogToResponse = other.LogToResponse;
12787 if (other.HasUsePbResolution) {
12788 UsePbResolution = other.UsePbResolution;
12790 if (other.HasMinimizeReductionDuringPbResolution) {
12791 MinimizeReductionDuringPbResolution = other.MinimizeReductionDuringPbResolution;
12793 if (other.HasCountAssumptionLevelsInLbd) {
12794 CountAssumptionLevelsInLbd = other.CountAssumptionLevelsInLbd;
12796 if (other.HasPresolveBveThreshold) {
12797 PresolveBveThreshold = other.PresolveBveThreshold;
12799 if (other.HasPresolveBveClauseWeight) {
12800 PresolveBveClauseWeight = other.PresolveBveClauseWeight;
12802 if (other.HasProbingDeterministicTimeLimit) {
12803 ProbingDeterministicTimeLimit = other.ProbingDeterministicTimeLimit;
12805 if (other.HasPresolveProbingDeterministicTimeLimit) {
12806 PresolveProbingDeterministicTimeLimit = other.PresolveProbingDeterministicTimeLimit;
12808 if (other.HasPresolveBlockedClause) {
12809 PresolveBlockedClause = other.PresolveBlockedClause;
12811 if (other.HasPresolveUseBva) {
12812 PresolveUseBva = other.PresolveUseBva;
12814 if (other.HasPresolveBvaThreshold) {
12815 PresolveBvaThreshold = other.PresolveBvaThreshold;
12817 if (other.HasMaxPresolveIterations) {
12818 MaxPresolveIterations = other.MaxPresolveIterations;
12820 if (other.HasCpModelPresolve) {
12821 CpModelPresolve = other.CpModelPresolve;
12823 if (other.HasCpModelProbingLevel) {
12824 CpModelProbingLevel = other.CpModelProbingLevel;
12826 if (other.HasCpModelUseSatPresolve) {
12827 CpModelUseSatPresolve = other.CpModelUseSatPresolve;
12829 if (other.HasRemoveFixedVariablesEarly) {
12830 RemoveFixedVariablesEarly = other.RemoveFixedVariablesEarly;
12832 if (other.HasDetectTableWithCost) {
12833 DetectTableWithCost = other.DetectTableWithCost;
12835 if (other.HasTableCompressionLevel) {
12836 TableCompressionLevel = other.TableCompressionLevel;
12838 if (other.HasExpandAlldiffConstraints) {
12839 ExpandAlldiffConstraints = other.ExpandAlldiffConstraints;
12841 if (other.HasExpandReservoirConstraints) {
12842 ExpandReservoirConstraints = other.ExpandReservoirConstraints;
12844 if (other.HasExpandReservoirUsingCircuit) {
12845 ExpandReservoirUsingCircuit = other.ExpandReservoirUsingCircuit;
12847 if (other.HasEncodeCumulativeAsReservoir) {
12848 EncodeCumulativeAsReservoir = other.EncodeCumulativeAsReservoir;
12850 if (other.HasMaxLinMaxSizeForExpansion) {
12851 MaxLinMaxSizeForExpansion = other.MaxLinMaxSizeForExpansion;
12853 if (other.HasDisableConstraintExpansion) {
12854 DisableConstraintExpansion = other.DisableConstraintExpansion;
12856 if (other.HasEncodeComplexLinearConstraintWithInteger) {
12857 EncodeComplexLinearConstraintWithInteger = other.EncodeComplexLinearConstraintWithInteger;
12859 if (other.HasMergeNoOverlapWorkLimit) {
12860 MergeNoOverlapWorkLimit = other.MergeNoOverlapWorkLimit;
12862 if (other.HasMergeAtMostOneWorkLimit) {
12863 MergeAtMostOneWorkLimit = other.MergeAtMostOneWorkLimit;
12865 if (other.HasPresolveSubstitutionLevel) {
12866 PresolveSubstitutionLevel = other.PresolveSubstitutionLevel;
12868 if (other.HasPresolveExtractIntegerEnforcement) {
12869 PresolveExtractIntegerEnforcement = other.PresolveExtractIntegerEnforcement;
12871 if (other.HasPresolveInclusionWorkLimit) {
12872 PresolveInclusionWorkLimit = other.PresolveInclusionWorkLimit;
12874 if (other.HasIgnoreNames) {
12875 IgnoreNames = other.IgnoreNames;
12877 if (other.HasInferAllDiffs) {
12878 InferAllDiffs = other.InferAllDiffs;
12880 if (other.HasFindBigLinearOverlap) {
12881 FindBigLinearOverlap = other.FindBigLinearOverlap;
12883 if (other.HasUseSatInprocessing) {
12884 UseSatInprocessing = other.UseSatInprocessing;
12886 if (other.HasInprocessingDtimeRatio) {
12887 InprocessingDtimeRatio = other.InprocessingDtimeRatio;
12889 if (other.HasInprocessingProbingDtime) {
12890 InprocessingProbingDtime = other.InprocessingProbingDtime;
12892 if (other.HasInprocessingMinimizationDtime) {
12893 InprocessingMinimizationDtime = other.InprocessingMinimizationDtime;
12895 if (other.HasInprocessingMinimizationUseConflictAnalysis) {
12896 InprocessingMinimizationUseConflictAnalysis = other.InprocessingMinimizationUseConflictAnalysis;
12898 if (other.HasInprocessingMinimizationUseAllOrderings) {
12899 InprocessingMinimizationUseAllOrderings = other.InprocessingMinimizationUseAllOrderings;
12901 if (other.HasNumWorkers) {
12902 NumWorkers = other.NumWorkers;
12904 if (other.HasNumSearchWorkers) {
12905 NumSearchWorkers = other.NumSearchWorkers;
12907 if (other.HasNumFullSubsolvers) {
12908 NumFullSubsolvers = other.NumFullSubsolvers;
12910 subsolvers_.Add(other.subsolvers_);
12911 extraSubsolvers_.Add(other.extraSubsolvers_);
12912 ignoreSubsolvers_.Add(other.ignoreSubsolvers_);
12913 filterSubsolvers_.Add(other.filterSubsolvers_);
12914 subsolverParams_.Add(other.subsolverParams_);
12915 if (other.HasInterleaveSearch) {
12916 InterleaveSearch = other.InterleaveSearch;
12918 if (other.HasInterleaveBatchSize) {
12919 InterleaveBatchSize = other.InterleaveBatchSize;
12921 if (other.HasShareObjectiveBounds) {
12922 ShareObjectiveBounds = other.ShareObjectiveBounds;
12924 if (other.HasShareLevelZeroBounds) {
12925 ShareLevelZeroBounds = other.ShareLevelZeroBounds;
12927 if (other.HasShareBinaryClauses) {
12928 ShareBinaryClauses = other.ShareBinaryClauses;
12930 if (other.HasShareGlueClauses) {
12931 ShareGlueClauses = other.ShareGlueClauses;
12933 if (other.HasMinimizeSharedClauses) {
12934 MinimizeSharedClauses = other.MinimizeSharedClauses;
12936 if (other.HasDebugPostsolveWithFullSolver) {
12937 DebugPostsolveWithFullSolver = other.DebugPostsolveWithFullSolver;
12939 if (other.HasDebugMaxNumPresolveOperations) {
12940 DebugMaxNumPresolveOperations = other.DebugMaxNumPresolveOperations;
12942 if (other.HasDebugCrashOnBadHint) {
12943 DebugCrashOnBadHint = other.DebugCrashOnBadHint;
12945 if (other.HasDebugCrashIfPresolveBreaksHint) {
12946 DebugCrashIfPresolveBreaksHint = other.DebugCrashIfPresolveBreaksHint;
12948 if (other.HasUseOptimizationHints) {
12949 UseOptimizationHints = other.UseOptimizationHints;
12951 if (other.HasCoreMinimizationLevel) {
12952 CoreMinimizationLevel = other.CoreMinimizationLevel;
12954 if (other.HasFindMultipleCores) {
12955 FindMultipleCores = other.FindMultipleCores;
12957 if (other.HasCoverOptimization) {
12958 CoverOptimization = other.CoverOptimization;
12960 if (other.HasMaxSatAssumptionOrder) {
12961 MaxSatAssumptionOrder = other.MaxSatAssumptionOrder;
12963 if (other.HasMaxSatReverseAssumptionOrder) {
12964 MaxSatReverseAssumptionOrder = other.MaxSatReverseAssumptionOrder;
12966 if (other.HasMaxSatStratification) {
12967 MaxSatStratification = other.MaxSatStratification;
12969 if (other.HasPropagationLoopDetectionFactor) {
12970 PropagationLoopDetectionFactor = other.PropagationLoopDetectionFactor;
12972 if (other.HasUsePrecedencesInDisjunctiveConstraint) {
12973 UsePrecedencesInDisjunctiveConstraint = other.UsePrecedencesInDisjunctiveConstraint;
12975 if (other.HasMaxSizeToCreatePrecedenceLiteralsInDisjunctive) {
12976 MaxSizeToCreatePrecedenceLiteralsInDisjunctive = other.MaxSizeToCreatePrecedenceLiteralsInDisjunctive;
12978 if (other.HasUseStrongPropagationInDisjunctive) {
12979 UseStrongPropagationInDisjunctive = other.UseStrongPropagationInDisjunctive;
12981 if (other.HasUseDynamicPrecedenceInDisjunctive) {
12982 UseDynamicPrecedenceInDisjunctive = other.UseDynamicPrecedenceInDisjunctive;
12984 if (other.HasUseDynamicPrecedenceInCumulative) {
12985 UseDynamicPrecedenceInCumulative = other.UseDynamicPrecedenceInCumulative;
12987 if (other.HasUseOverloadCheckerInCumulative) {
12988 UseOverloadCheckerInCumulative = other.UseOverloadCheckerInCumulative;
12990 if (other.HasUseConservativeScaleOverloadChecker) {
12991 UseConservativeScaleOverloadChecker = other.UseConservativeScaleOverloadChecker;
12993 if (other.HasUseTimetableEdgeFindingInCumulative) {
12994 UseTimetableEdgeFindingInCumulative = other.UseTimetableEdgeFindingInCumulative;
12996 if (other.HasMaxNumIntervalsForTimetableEdgeFinding) {
12997 MaxNumIntervalsForTimetableEdgeFinding = other.MaxNumIntervalsForTimetableEdgeFinding;
12999 if (other.HasUseHardPrecedencesInCumulative) {
13000 UseHardPrecedencesInCumulative = other.UseHardPrecedencesInCumulative;
13002 if (other.HasExploitAllPrecedences) {
13003 ExploitAllPrecedences = other.ExploitAllPrecedences;
13005 if (other.HasUseDisjunctiveConstraintInCumulative) {
13006 UseDisjunctiveConstraintInCumulative = other.UseDisjunctiveConstraintInCumulative;
13008 if (other.HasUseTimetablingInNoOverlap2D) {
13009 UseTimetablingInNoOverlap2D = other.UseTimetablingInNoOverlap2D;
13011 if (other.HasUseEnergeticReasoningInNoOverlap2D) {
13012 UseEnergeticReasoningInNoOverlap2D = other.UseEnergeticReasoningInNoOverlap2D;
13014 if (other.HasUseAreaEnergeticReasoningInNoOverlap2D) {
13015 UseAreaEnergeticReasoningInNoOverlap2D = other.UseAreaEnergeticReasoningInNoOverlap2D;
13017 if (other.HasUseTryEdgeReasoningInNoOverlap2D) {
13018 UseTryEdgeReasoningInNoOverlap2D = other.UseTryEdgeReasoningInNoOverlap2D;
13020 if (other.HasMaxPairsPairwiseReasoningInNoOverlap2D) {
13021 MaxPairsPairwiseReasoningInNoOverlap2D = other.MaxPairsPairwiseReasoningInNoOverlap2D;
13023 if (other.HasMaximumRegionsToSplitInDisconnectedNoOverlap2D) {
13024 MaximumRegionsToSplitInDisconnectedNoOverlap2D = other.MaximumRegionsToSplitInDisconnectedNoOverlap2D;
13026 if (other.HasUseDualSchedulingHeuristics) {
13027 UseDualSchedulingHeuristics = other.UseDualSchedulingHeuristics;
13029 if (other.HasUseAllDifferentForCircuit) {
13030 UseAllDifferentForCircuit = other.UseAllDifferentForCircuit;
13032 if (other.HasRoutingCutSubsetSizeForBinaryRelationBound) {
13033 RoutingCutSubsetSizeForBinaryRelationBound = other.RoutingCutSubsetSizeForBinaryRelationBound;
13035 if (other.HasRoutingCutSubsetSizeForTightBinaryRelationBound) {
13036 RoutingCutSubsetSizeForTightBinaryRelationBound = other.RoutingCutSubsetSizeForTightBinaryRelationBound;
13038 if (other.HasRoutingCutDpEffort) {
13039 RoutingCutDpEffort = other.RoutingCutDpEffort;
13041 if (other.HasSearchBranching) {
13042 SearchBranching = other.SearchBranching;
13044 if (other.HasHintConflictLimit) {
13045 HintConflictLimit = other.HintConflictLimit;
13047 if (other.HasRepairHint) {
13048 RepairHint = other.RepairHint;
13050 if (other.HasFixVariablesToTheirHintedValue) {
13051 FixVariablesToTheirHintedValue = other.FixVariablesToTheirHintedValue;
13053 if (other.HasUseProbingSearch) {
13054 UseProbingSearch = other.UseProbingSearch;
13056 if (other.HasUseExtendedProbing) {
13057 UseExtendedProbing = other.UseExtendedProbing;
13059 if (other.HasProbingNumCombinationsLimit) {
13060 ProbingNumCombinationsLimit = other.ProbingNumCombinationsLimit;
13062 if (other.HasUseShavingInProbingSearch) {
13063 UseShavingInProbingSearch = other.UseShavingInProbingSearch;
13065 if (other.HasShavingSearchDeterministicTime) {
13066 ShavingSearchDeterministicTime = other.ShavingSearchDeterministicTime;
13068 if (other.HasShavingSearchThreshold) {
13069 ShavingSearchThreshold = other.ShavingSearchThreshold;
13071 if (other.HasUseObjectiveLbSearch) {
13072 UseObjectiveLbSearch = other.UseObjectiveLbSearch;
13074 if (other.HasUseObjectiveShavingSearch) {
13075 UseObjectiveShavingSearch = other.UseObjectiveShavingSearch;
13077 if (other.HasUseVariablesShavingSearch) {
13078 UseVariablesShavingSearch = other.UseVariablesShavingSearch;
13080 if (other.HasPseudoCostReliabilityThreshold) {
13081 PseudoCostReliabilityThreshold = other.PseudoCostReliabilityThreshold;
13083 if (other.HasOptimizeWithCore) {
13084 OptimizeWithCore = other.OptimizeWithCore;
13086 if (other.HasOptimizeWithLbTreeSearch) {
13087 OptimizeWithLbTreeSearch = other.OptimizeWithLbTreeSearch;
13089 if (other.HasSaveLpBasisInLbTreeSearch) {
13090 SaveLpBasisInLbTreeSearch = other.SaveLpBasisInLbTreeSearch;
13092 if (other.HasBinarySearchNumConflicts) {
13093 BinarySearchNumConflicts = other.BinarySearchNumConflicts;
13095 if (other.HasOptimizeWithMaxHs) {
13096 OptimizeWithMaxHs = other.OptimizeWithMaxHs;
13098 if (other.HasUseFeasibilityJump) {
13099 UseFeasibilityJump = other.UseFeasibilityJump;
13101 if (other.HasUseLsOnly) {
13102 UseLsOnly = other.UseLsOnly;
13104 if (other.HasFeasibilityJumpDecay) {
13105 FeasibilityJumpDecay = other.FeasibilityJumpDecay;
13107 if (other.HasFeasibilityJumpLinearizationLevel) {
13108 FeasibilityJumpLinearizationLevel = other.FeasibilityJumpLinearizationLevel;
13110 if (other.HasFeasibilityJumpRestartFactor) {
13111 FeasibilityJumpRestartFactor = other.FeasibilityJumpRestartFactor;
13113 if (other.HasFeasibilityJumpBatchDtime) {
13114 FeasibilityJumpBatchDtime = other.FeasibilityJumpBatchDtime;
13116 if (other.HasFeasibilityJumpVarRandomizationProbability) {
13117 FeasibilityJumpVarRandomizationProbability = other.FeasibilityJumpVarRandomizationProbability;
13119 if (other.HasFeasibilityJumpVarPerburbationRangeRatio) {
13120 FeasibilityJumpVarPerburbationRangeRatio = other.FeasibilityJumpVarPerburbationRangeRatio;
13122 if (other.HasFeasibilityJumpEnableRestarts) {
13123 FeasibilityJumpEnableRestarts = other.FeasibilityJumpEnableRestarts;
13125 if (other.HasFeasibilityJumpMaxExpandedConstraintSize) {
13126 FeasibilityJumpMaxExpandedConstraintSize = other.FeasibilityJumpMaxExpandedConstraintSize;
13128 if (other.HasNumViolationLs) {
13129 NumViolationLs = other.NumViolationLs;
13131 if (other.HasViolationLsPerturbationPeriod) {
13132 ViolationLsPerturbationPeriod = other.ViolationLsPerturbationPeriod;
13134 if (other.HasViolationLsCompoundMoveProbability) {
13135 ViolationLsCompoundMoveProbability = other.ViolationLsCompoundMoveProbability;
13137 if (other.HasSharedTreeNumWorkers) {
13138 SharedTreeNumWorkers = other.SharedTreeNumWorkers;
13140 if (other.HasUseSharedTreeSearch) {
13141 UseSharedTreeSearch = other.UseSharedTreeSearch;
13143 if (other.HasSharedTreeWorkerMinRestartsPerSubtree) {
13144 SharedTreeWorkerMinRestartsPerSubtree = other.SharedTreeWorkerMinRestartsPerSubtree;
13146 if (other.HasSharedTreeWorkerEnableTrailSharing) {
13147 SharedTreeWorkerEnableTrailSharing = other.SharedTreeWorkerEnableTrailSharing;
13149 if (other.HasSharedTreeWorkerEnablePhaseSharing) {
13150 SharedTreeWorkerEnablePhaseSharing = other.SharedTreeWorkerEnablePhaseSharing;
13152 if (other.HasSharedTreeOpenLeavesPerWorker) {
13153 SharedTreeOpenLeavesPerWorker = other.SharedTreeOpenLeavesPerWorker;
13155 if (other.HasSharedTreeMaxNodesPerWorker) {
13156 SharedTreeMaxNodesPerWorker = other.SharedTreeMaxNodesPerWorker;
13158 if (other.HasSharedTreeSplitStrategy) {
13159 SharedTreeSplitStrategy = other.SharedTreeSplitStrategy;
13161 if (other.HasSharedTreeBalanceTolerance) {
13162 SharedTreeBalanceTolerance = other.SharedTreeBalanceTolerance;
13164 if (other.HasEnumerateAllSolutions) {
13165 EnumerateAllSolutions = other.EnumerateAllSolutions;
13167 if (other.HasKeepAllFeasibleSolutionsInPresolve) {
13168 KeepAllFeasibleSolutionsInPresolve = other.KeepAllFeasibleSolutionsInPresolve;
13170 if (other.HasFillTightenedDomainsInResponse) {
13171 FillTightenedDomainsInResponse = other.FillTightenedDomainsInResponse;
13173 if (other.HasFillAdditionalSolutionsInResponse) {
13174 FillAdditionalSolutionsInResponse = other.FillAdditionalSolutionsInResponse;
13176 if (other.HasInstantiateAllVariables) {
13177 InstantiateAllVariables = other.InstantiateAllVariables;
13179 if (other.HasAutoDetectGreaterThanAtLeastOneOf) {
13180 AutoDetectGreaterThanAtLeastOneOf = other.AutoDetectGreaterThanAtLeastOneOf;
13182 if (other.HasStopAfterFirstSolution) {
13183 StopAfterFirstSolution = other.StopAfterFirstSolution;
13185 if (other.HasStopAfterPresolve) {
13186 StopAfterPresolve = other.StopAfterPresolve;
13188 if (other.HasStopAfterRootPropagation) {
13189 StopAfterRootPropagation = other.StopAfterRootPropagation;
13191 if (other.HasLnsInitialDifficulty) {
13192 LnsInitialDifficulty = other.LnsInitialDifficulty;
13194 if (other.HasLnsInitialDeterministicLimit) {
13195 LnsInitialDeterministicLimit = other.LnsInitialDeterministicLimit;
13197 if (other.HasUseLns) {
13198 UseLns = other.UseLns;
13200 if (other.HasUseLnsOnly) {
13201 UseLnsOnly = other.UseLnsOnly;
13203 if (other.HasSolutionPoolSize) {
13204 SolutionPoolSize = other.SolutionPoolSize;
13206 if (other.HasUseRinsLns) {
13207 UseRinsLns = other.UseRinsLns;
13209 if (other.HasUseFeasibilityPump) {
13210 UseFeasibilityPump = other.UseFeasibilityPump;
13212 if (other.HasUseLbRelaxLns) {
13213 UseLbRelaxLns = other.UseLbRelaxLns;
13215 if (other.HasLbRelaxNumWorkersThreshold) {
13216 LbRelaxNumWorkersThreshold = other.LbRelaxNumWorkersThreshold;
13218 if (other.HasFpRounding) {
13219 FpRounding = other.FpRounding;
13221 if (other.HasDiversifyLnsParams) {
13222 DiversifyLnsParams = other.DiversifyLnsParams;
13224 if (other.HasRandomizeSearch) {
13225 RandomizeSearch = other.RandomizeSearch;
13227 if (other.HasSearchRandomVariablePoolSize) {
13228 SearchRandomVariablePoolSize = other.SearchRandomVariablePoolSize;
13230 if (other.HasPushAllTasksTowardStart) {
13231 PushAllTasksTowardStart = other.PushAllTasksTowardStart;
13233 if (other.HasUseOptionalVariables) {
13234 UseOptionalVariables = other.UseOptionalVariables;
13236 if (other.HasUseExactLpReason) {
13237 UseExactLpReason = other.UseExactLpReason;
13239 if (other.HasUseCombinedNoOverlap) {
13240 UseCombinedNoOverlap = other.UseCombinedNoOverlap;
13242 if (other.HasAtMostOneMaxExpansionSize) {
13243 AtMostOneMaxExpansionSize = other.AtMostOneMaxExpansionSize;
13245 if (other.HasCatchSigintSignal) {
13246 CatchSigintSignal = other.CatchSigintSignal;
13248 if (other.HasUseImpliedBounds) {
13249 UseImpliedBounds = other.UseImpliedBounds;
13251 if (other.HasPolishLpSolution) {
13252 PolishLpSolution = other.PolishLpSolution;
13254 if (other.HasLpPrimalTolerance) {
13255 LpPrimalTolerance = other.LpPrimalTolerance;
13257 if (other.HasLpDualTolerance) {
13258 LpDualTolerance = other.LpDualTolerance;
13260 if (other.HasConvertIntervals) {
13261 ConvertIntervals = other.ConvertIntervals;
13263 if (other.HasSymmetryLevel) {
13264 SymmetryLevel = other.SymmetryLevel;
13266 if (other.HasUseSymmetryInLp) {
13267 UseSymmetryInLp = other.UseSymmetryInLp;
13269 if (other.HasKeepSymmetryInPresolve) {
13270 KeepSymmetryInPresolve = other.KeepSymmetryInPresolve;
13272 if (other.HasSymmetryDetectionDeterministicTimeLimit) {
13273 SymmetryDetectionDeterministicTimeLimit = other.SymmetryDetectionDeterministicTimeLimit;
13275 if (other.HasNewLinearPropagation) {
13276 NewLinearPropagation = other.NewLinearPropagation;
13278 if (other.HasLinearSplitSize) {
13279 LinearSplitSize = other.LinearSplitSize;
13281 if (other.HasLinearizationLevel) {
13282 LinearizationLevel = other.LinearizationLevel;
13284 if (other.HasBooleanEncodingLevel) {
13285 BooleanEncodingLevel = other.BooleanEncodingLevel;
13287 if (other.HasMaxDomainSizeWhenEncodingEqNeqConstraints) {
13288 MaxDomainSizeWhenEncodingEqNeqConstraints = other.MaxDomainSizeWhenEncodingEqNeqConstraints;
13290 if (other.HasMaxNumCuts) {
13291 MaxNumCuts = other.MaxNumCuts;
13293 if (other.HasCutLevel) {
13294 CutLevel = other.CutLevel;
13296 if (other.HasOnlyAddCutsAtLevelZero) {
13297 OnlyAddCutsAtLevelZero = other.OnlyAddCutsAtLevelZero;
13299 if (other.HasAddObjectiveCut) {
13300 AddObjectiveCut = other.AddObjectiveCut;
13302 if (other.HasAddCgCuts) {
13303 AddCgCuts = other.AddCgCuts;
13305 if (other.HasAddMirCuts) {
13306 AddMirCuts = other.AddMirCuts;
13308 if (other.HasAddZeroHalfCuts) {
13309 AddZeroHalfCuts = other.AddZeroHalfCuts;
13311 if (other.HasAddCliqueCuts) {
13312 AddCliqueCuts = other.AddCliqueCuts;
13314 if (other.HasAddRltCuts) {
13315 AddRltCuts = other.AddRltCuts;
13317 if (other.HasMaxAllDiffCutSize) {
13318 MaxAllDiffCutSize = other.MaxAllDiffCutSize;
13320 if (other.HasAddLinMaxCuts) {
13321 AddLinMaxCuts = other.AddLinMaxCuts;
13323 if (other.HasMaxIntegerRoundingScaling) {
13324 MaxIntegerRoundingScaling = other.MaxIntegerRoundingScaling;
13326 if (other.HasAddLpConstraintsLazily) {
13327 AddLpConstraintsLazily = other.AddLpConstraintsLazily;
13329 if (other.HasRootLpIterations) {
13330 RootLpIterations = other.RootLpIterations;
13332 if (other.HasMinOrthogonalityForLpConstraints) {
13333 MinOrthogonalityForLpConstraints = other.MinOrthogonalityForLpConstraints;
13335 if (other.HasMaxCutRoundsAtLevelZero) {
13336 MaxCutRoundsAtLevelZero = other.MaxCutRoundsAtLevelZero;
13338 if (other.HasMaxConsecutiveInactiveCount) {
13339 MaxConsecutiveInactiveCount = other.MaxConsecutiveInactiveCount;
13341 if (other.HasCutMaxActiveCountValue) {
13342 CutMaxActiveCountValue = other.CutMaxActiveCountValue;
13344 if (other.HasCutActiveCountDecay) {
13345 CutActiveCountDecay = other.CutActiveCountDecay;
13347 if (other.HasCutCleanupTarget) {
13348 CutCleanupTarget = other.CutCleanupTarget;
13350 if (other.HasNewConstraintsBatchSize) {
13351 NewConstraintsBatchSize = other.NewConstraintsBatchSize;
13353 if (other.HasExploitIntegerLpSolution) {
13354 ExploitIntegerLpSolution = other.ExploitIntegerLpSolution;
13356 if (other.HasExploitAllLpSolution) {
13357 ExploitAllLpSolution = other.ExploitAllLpSolution;
13359 if (other.HasExploitBestSolution) {
13360 ExploitBestSolution = other.ExploitBestSolution;
13362 if (other.HasExploitRelaxationSolution) {
13363 ExploitRelaxationSolution = other.ExploitRelaxationSolution;
13365 if (other.HasExploitObjective) {
13366 ExploitObjective = other.ExploitObjective;
13368 if (other.HasDetectLinearizedProduct) {
13369 DetectLinearizedProduct = other.DetectLinearizedProduct;
13371 if (other.HasMipMaxBound) {
13372 MipMaxBound = other.MipMaxBound;
13374 if (other.HasMipVarScaling) {
13375 MipVarScaling = other.MipVarScaling;
13377 if (other.HasMipScaleLargeDomain) {
13378 MipScaleLargeDomain = other.MipScaleLargeDomain;
13380 if (other.HasMipAutomaticallyScaleVariables) {
13381 MipAutomaticallyScaleVariables = other.MipAutomaticallyScaleVariables;
13383 if (other.HasOnlySolveIp) {
13384 OnlySolveIp = other.OnlySolveIp;
13386 if (other.HasMipWantedPrecision) {
13387 MipWantedPrecision = other.MipWantedPrecision;
13389 if (other.HasMipMaxActivityExponent) {
13390 MipMaxActivityExponent = other.MipMaxActivityExponent;
13392 if (other.HasMipCheckPrecision) {
13393 MipCheckPrecision = other.MipCheckPrecision;
13395 if (other.HasMipComputeTrueObjectiveBound) {
13396 MipComputeTrueObjectiveBound = other.MipComputeTrueObjectiveBound;
13398 if (other.HasMipMaxValidMagnitude) {
13399 MipMaxValidMagnitude = other.MipMaxValidMagnitude;
13401 if (other.HasMipTreatHighMagnitudeBoundsAsInfinity) {
13402 MipTreatHighMagnitudeBoundsAsInfinity = other.MipTreatHighMagnitudeBoundsAsInfinity;
13404 if (other.HasMipDropTolerance) {
13405 MipDropTolerance = other.MipDropTolerance;
13407 if (other.HasMipPresolveLevel) {
13408 MipPresolveLevel = other.MipPresolveLevel;
13410 _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
13413 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
13414 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
13415 public void MergeFrom(pb::CodedInputStream input) {
13416 #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
13417 input.ReadRawMessage(
this);
13420 while ((tag = input.ReadTag()) != 0) {
13421 if ((tag & 7) == 4) {
13427 _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
13430 PreferredVariableOrder = (global::Google.OrTools.Sat.SatParameters.Types.VariableOrder) input.ReadEnum();
13434 InitialPolarity = (global::Google.OrTools.Sat.SatParameters.Types.Polarity) input.ReadEnum();
13438 MinimizationAlgorithm = (global::Google.OrTools.Sat.SatParameters.Types.ConflictMinimizationAlgorithm) input.ReadEnum();
13442 ClauseCleanupPeriod = input.ReadInt32();
13446 ClauseCleanupTarget = input.ReadInt32();
13450 VariableActivityDecay = input.ReadDouble();
13454 MaxVariableActivityValue = input.ReadDouble();
13458 ClauseActivityDecay = input.ReadDouble();
13462 MaxClauseActivityValue = input.ReadDouble();
13466 GlucoseMaxDecay = input.ReadDouble();
13474 GlucoseDecayIncrementPeriod = input.ReadInt32();
13478 RestartPeriod = input.ReadInt32();
13482 RandomSeed = input.ReadInt32();
13486 RandomBranchesRatio = input.ReadDouble();
13490 BinaryMinimizationAlgorithm = (global::Google.OrTools.Sat.SatParameters.Types.BinaryMinizationAlgorithm) input.ReadEnum();
13494 UseOptimizationHints = input.ReadBool();
13498 MaxTimeInSeconds = input.ReadDouble();
13502 MaxNumberOfConflicts = input.ReadInt64();
13506 MaxMemoryInMb = input.ReadInt64();
13510 LogSearchProgress = input.ReadBool();
13514 UsePbResolution = input.ReadBool();
13518 UsePhaseSaving = input.ReadBool();
13522 RandomPolarityRatio = input.ReadDouble();
13526 PbCleanupIncrement = input.ReadInt32();
13530 PbCleanupRatio = input.ReadDouble();
13534 MinimizeReductionDuringPbResolution = input.ReadBool();
13538 CountAssumptionLevelsInLbd = input.ReadBool();
13542 CoreMinimizationLevel = input.ReadInt32();
13546 MaxSatAssumptionOrder = (global::Google.OrTools.Sat.SatParameters.Types.MaxSatAssumptionOrder) input.ReadEnum();
13550 MaxSatReverseAssumptionOrder = input.ReadBool();
13554 MaxSatStratification = (global::Google.OrTools.Sat.SatParameters.Types.MaxSatStratificationAlgorithm) input.ReadEnum();
13558 PresolveBveThreshold = input.ReadInt32();
13562 PresolveBveClauseWeight = input.ReadInt32();
13566 SubsumptionDuringConflictAnalysis = input.ReadBool();
13570 PresolveProbingDeterministicTimeLimit = input.ReadDouble();
13574 ClauseCleanupProtection = (global::Google.OrTools.Sat.SatParameters.Types.ClauseProtection) input.ReadEnum();
13578 ClauseCleanupLbdBound = input.ReadInt32();
13582 ClauseCleanupOrdering = (global::Google.OrTools.Sat.SatParameters.Types.ClauseOrdering) input.ReadEnum();
13587 restartAlgorithms_.AddEntriesFrom(input, _repeated_restartAlgorithms_codec);
13591 RestartRunningWindowSize = input.ReadInt32();
13595 RestartDlAverageRatio = input.ReadDouble();
13599 UseBlockingRestart = input.ReadBool();
13603 BlockingRestartWindowSize = input.ReadInt32();
13607 BlockingRestartMultiplier = input.ReadDouble();
13611 MaxDeterministicTime = input.ReadDouble();
13615 NumConflictsBeforeStrategyChanges = input.ReadInt32();
13619 StrategyChangeIncreaseRatio = input.ReadDouble();
13623 DefaultRestartAlgorithms = input.ReadString();
13627 RestartLbdAverageRatio = input.ReadDouble();
13631 PresolveUseBva = input.ReadBool();
13635 PresolveBvaThreshold = input.ReadInt32();
13639 UsePrecedencesInDisjunctiveConstraint = input.ReadBool();
13643 UseErwaHeuristic = input.ReadBool();
13647 InitialVariablesActivity = input.ReadDouble();
13651 AlsoBumpVariablesInConflictReasons = input.ReadBool();
13655 UseOverloadCheckerInCumulative = input.ReadBool();
13659 UseTimetableEdgeFindingInCumulative = input.ReadBool();
13663 UseDisjunctiveConstraintInCumulative = input.ReadBool();
13667 SearchBranching = (global::Google.OrTools.Sat.SatParameters.Types.SearchBranching) input.ReadEnum();
13671 OptimizeWithCore = input.ReadBool();
13675 FindMultipleCores = input.ReadBool();
13679 OptimizeWithMaxHs = input.ReadBool();
13683 CpModelPresolve = input.ReadBool();
13687 EnumerateAllSolutions = input.ReadBool();
13691 PresolveBlockedClause = input.ReadBool();
13695 CoverOptimization = input.ReadBool();
13699 LinearizationLevel = input.ReadInt32();
13703 MaxNumCuts = input.ReadInt32();
13707 OnlyAddCutsAtLevelZero = input.ReadBool();
13711 CpModelUseSatPresolve = input.ReadBool();
13715 ExploitIntegerLpSolution = input.ReadBool();
13719 AutoDetectGreaterThanAtLeastOneOf = input.ReadBool();
13723 StopAfterFirstSolution = input.ReadBool();
13727 BinarySearchNumConflicts = input.ReadInt32();
13731 NumSearchWorkers = input.ReadInt32();
13735 UseLnsOnly = input.ReadBool();
13739 RandomizeSearch = input.ReadBool();
13743 SearchRandomVariablePoolSize = input.ReadInt64();
13747 InstantiateAllVariables = input.ReadBool();
13751 BooleanEncodingLevel = input.ReadInt32();
13755 UseOptionalVariables = input.ReadBool();
13759 UseExactLpReason = input.ReadBool();
13763 CpModelProbingLevel = input.ReadInt32();
13767 AddLpConstraintsLazily = input.ReadBool();
13771 ShareObjectiveBounds = input.ReadBool();
13775 ShareLevelZeroBounds = input.ReadBool();
13779 MinOrthogonalityForLpConstraints = input.ReadDouble();
13783 ExploitAllLpSolution = input.ReadBool();
13787 AddCgCuts = input.ReadBool();
13791 MaxIntegerRoundingScaling = input.ReadInt32();
13795 AddMirCuts = input.ReadBool();
13799 MaxConsecutiveInactiveCount = input.ReadInt32();
13803 NewConstraintsBatchSize = input.ReadInt32();
13807 PseudoCostReliabilityThreshold = input.ReadInt64();
13811 MipMaxBound = input.ReadDouble();
13815 MipVarScaling = input.ReadDouble();
13819 MipWantedPrecision = input.ReadDouble();
13823 MipMaxActivityExponent = input.ReadInt32();
13827 MipCheckPrecision = input.ReadDouble();
13831 UseRinsLns = input.ReadBool();
13835 ExploitBestSolution = input.ReadBool();
13839 ExploitObjective = input.ReadBool();
13843 FillTightenedDomainsInResponse = input.ReadBool();
13847 UseCombinedNoOverlap = input.ReadBool();
13851 InterleaveBatchSize = input.ReadInt32();
13855 CatchSigintSignal = input.ReadBool();
13859 InterleaveSearch = input.ReadBool();
13863 DiversifyLnsParams = input.ReadBool();
13867 MaxPresolveIterations = input.ReadInt32();
13871 UseImpliedBounds = input.ReadBool();
13875 MergeNoOverlapWorkLimit = input.ReadDouble();
13879 MergeAtMostOneWorkLimit = input.ReadDouble();
13883 PresolveSubstitutionLevel = input.ReadInt32();
13887 MaxAllDiffCutSize = input.ReadInt32();
13891 StopAfterPresolve = input.ReadBool();
13895 DebugMaxNumPresolveOperations = input.ReadInt32();
13899 AddLinMaxCuts = input.ReadBool();
13903 HintConflictLimit = input.ReadInt32();
13907 MaxCutRoundsAtLevelZero = input.ReadInt32();
13911 CutMaxActiveCountValue = input.ReadDouble();
13915 CutActiveCountDecay = input.ReadDouble();
13919 CutCleanupTarget = input.ReadInt32();
13923 AbsoluteGapLimit = input.ReadDouble();
13927 RelativeGapLimit = input.ReadDouble();
13931 ExploitRelaxationSolution = input.ReadBool();
13935 DebugPostsolveWithFullSolver = input.ReadBool();
13939 UseSatInprocessing = input.ReadBool();
13943 UseFeasibilityPump = input.ReadBool();
13947 FpRounding = (global::Google.OrTools.Sat.SatParameters.Types.FPRoundingMethod) input.ReadEnum();
13951 MipAutomaticallyScaleVariables = input.ReadBool();
13955 RepairHint = input.ReadBool();
13959 PolarityRephaseIncrement = input.ReadInt32();
13963 AddZeroHalfCuts = input.ReadBool();
13967 ExpandAlldiffConstraints = input.ReadBool();
13971 Name = input.ReadString();
13975 AddCliqueCuts = input.ReadBool();
13979 KeepAllFeasibleSolutionsInPresolve = input.ReadBool();
13983 PresolveExtractIntegerEnforcement = input.ReadBool();
13987 PolishLpSolution = input.ReadBool();
13991 UseProbingSearch = input.ReadBool();
13995 ConvertIntervals = input.ReadBool();
13999 PermuteVariableRandomly = input.ReadBool();
14003 PermutePresolveConstraintOrder = input.ReadBool();
14007 UseAbslRandom = input.ReadBool();
14011 DisableConstraintExpansion = input.ReadBool();
14015 ExpandReservoirConstraints = input.ReadBool();
14019 SymmetryLevel = input.ReadInt32();
14023 LogPrefix = input.ReadString();
14027 LogToStdout = input.ReadBool();
14031 LogToResponse = input.ReadBool();
14035 OptimizeWithLbTreeSearch = input.ReadBool();
14039 LogSubsolverStatistics = input.ReadBool();
14043 ClauseCleanupRatio = input.ReadDouble();
14047 MaxDomainSizeWhenEncodingEqNeqConstraints = input.ReadInt32();
14051 FixVariablesToTheirHintedValue = input.ReadBool();
14055 SolutionPoolSize = input.ReadInt32();
14059 FillAdditionalSolutionsInResponse = input.ReadBool();
14063 DebugCrashOnBadHint = input.ReadBool();
14067 CutLevel = input.ReadInt32();
14071 AddObjectiveCut = input.ReadBool();
14075 MipComputeTrueObjectiveBound = input.ReadBool();
14079 MipMaxValidMagnitude = input.ReadDouble();
14083 UseTimetablingInNoOverlap2D = input.ReadBool();
14087 PresolveInclusionWorkLimit = input.ReadInt64();
14091 IgnoreNames = input.ReadBool();
14095 ShareBinaryClauses = input.ReadBool();
14099 UseShavingInProbingSearch = input.ReadBool();
14103 ShavingSearchDeterministicTime = input.ReadDouble();
14107 NumWorkers = input.ReadInt32();
14111 subsolvers_.AddEntriesFrom(input, _repeated_subsolvers_codec);
14115 ignoreSubsolvers_.AddEntriesFrom(input, _repeated_ignoreSubsolvers_codec);
14119 subsolverParams_.AddEntriesFrom(input, _repeated_subsolverParams_codec);
14123 UseEnergeticReasoningInNoOverlap2D = input.ReadBool();
14127 UseDualSchedulingHeuristics = input.ReadBool();
14131 UseHardPrecedencesInCumulative = input.ReadBool();
14135 DetectTableWithCost = input.ReadBool();
14139 TableCompressionLevel = input.ReadInt32();
14143 extraSubsolvers_.AddEntriesFrom(input, _repeated_extraSubsolvers_codec);
14147 ExploitAllPrecedences = input.ReadBool();
14151 PropagationLoopDetectionFactor = input.ReadDouble();
14155 OnlySolveIp = input.ReadBool();
14159 EncodeComplexLinearConstraintWithInteger = input.ReadBool();
14163 NewLinearPropagation = input.ReadBool();
14167 MipScaleLargeDomain = input.ReadBool();
14171 ProbingDeterministicTimeLimit = input.ReadDouble();
14175 RootLpIterations = input.ReadInt32();
14179 UseObjectiveLbSearch = input.ReadBool();
14183 MaxSizeToCreatePrecedenceLiteralsInDisjunctive = input.ReadInt32();
14187 UseStrongPropagationInDisjunctive = input.ReadBool();
14191 MipDropTolerance = input.ReadDouble();
14195 InferAllDiffs = input.ReadBool();
14199 FindBigLinearOverlap = input.ReadBool();
14203 SharedTreeNumWorkers = input.ReadInt32();
14207 UseSharedTreeSearch = input.ReadBool();
14211 SharedTreeMaxNodesPerWorker = input.ReadInt32();
14215 SharedTreeSplitStrategy = (global::Google.OrTools.Sat.SatParameters.Types.SharedTreeSplitStrategy) input.ReadEnum();
14219 UseLsOnly = input.ReadBool();
14223 FeasibilityJumpDecay = input.ReadDouble();
14227 NumViolationLs = input.ReadInt32();
14231 FeasibilityJumpVarRandomizationProbability = input.ReadDouble();
14235 FeasibilityJumpVarPerburbationRangeRatio = input.ReadDouble();
14239 ViolationLsPerturbationPeriod = input.ReadInt32();
14243 FeasibilityJumpEnableRestarts = input.ReadBool();
14247 StopAfterRootPropagation = input.ReadBool();
14251 UseObjectiveShavingSearch = input.ReadBool();
14255 UseLbRelaxLns = input.ReadBool();
14259 LinearSplitSize = input.ReadInt32();
14263 FeasibilityJumpLinearizationLevel = input.ReadInt32();
14267 FeasibilityJumpRestartFactor = input.ReadInt32();
14271 ViolationLsCompoundMoveProbability = input.ReadDouble();
14275 MaxNumIntervalsForTimetableEdgeFinding = input.ReadInt32();
14279 MipPresolveLevel = input.ReadInt32();
14283 PushAllTasksTowardStart = input.ReadBool();
14287 UseDynamicPrecedenceInDisjunctive = input.ReadBool();
14291 FeasibilityJumpMaxExpandedConstraintSize = input.ReadInt32();
14295 UseFeasibilityJump = input.ReadBool();
14299 LpPrimalTolerance = input.ReadDouble();
14303 LpDualTolerance = input.ReadDouble();
14307 UseDynamicPrecedenceInCumulative = input.ReadBool();
14311 UseExtendedProbing = input.ReadBool();
14315 AtMostOneMaxExpansionSize = input.ReadInt32();
14319 UseAreaEnergeticReasoningInNoOverlap2D = input.ReadBool();
14323 ProbingNumCombinationsLimit = input.ReadInt32();
14327 InprocessingDtimeRatio = input.ReadDouble();
14331 InprocessingProbingDtime = input.ReadDouble();
14335 InprocessingMinimizationDtime = input.ReadDouble();
14339 MaxPairsPairwiseReasoningInNoOverlap2D = input.ReadInt32();
14343 DetectLinearizedProduct = input.ReadBool();
14347 MipTreatHighMagnitudeBoundsAsInfinity = input.ReadBool();
14351 AddRltCuts = input.ReadBool();
14355 MaxLinMaxSizeForExpansion = input.ReadInt32();
14359 SharedTreeOpenLeavesPerWorker = input.ReadDouble();
14363 SharedTreeWorkerMinRestartsPerSubtree = input.ReadInt32();
14367 UseLns = input.ReadBool();
14371 SaveLpBasisInLbTreeSearch = input.ReadBool();
14375 ShareGlueClauses = input.ReadBool();
14379 UseConservativeScaleOverloadChecker = input.ReadBool();
14383 EncodeCumulativeAsReservoir = input.ReadBool();
14387 ExpandReservoirUsingCircuit = input.ReadBool();
14391 UseVariablesShavingSearch = input.ReadBool();
14395 ShavingSearchThreshold = input.ReadInt64();
14399 MaxNumDeterministicBatches = input.ReadInt32();
14403 FeasibilityJumpBatchDtime = input.ReadDouble();
14407 filterSubsolvers_.AddEntriesFrom(input, _repeated_filterSubsolvers_codec);
14411 NumFullSubsolvers = input.ReadInt32();
14415 SharedTreeWorkerEnableTrailSharing = input.ReadBool();
14419 LbRelaxNumWorkersThreshold = input.ReadInt32();
14423 InprocessingMinimizationUseConflictAnalysis = input.ReadBool();
14427 InprocessingMinimizationUseAllOrderings = input.ReadBool();
14431 UseTryEdgeReasoningInNoOverlap2D = input.ReadBool();
14435 MinimizeSharedClauses = input.ReadBool();
14439 UseSymmetryInLp = input.ReadBool();
14443 SymmetryDetectionDeterministicTimeLimit = input.ReadDouble();
14447 KeepSymmetryInPresolve = input.ReadBool();
14451 SharedTreeWorkerEnablePhaseSharing = input.ReadBool();
14455 SharedTreeBalanceTolerance = input.ReadInt32();
14459 DebugCrashIfPresolveBreaksHint = input.ReadBool();
14463 LnsInitialDifficulty = input.ReadDouble();
14467 LnsInitialDeterministicLimit = input.ReadDouble();
14471 PolarityExploitLsHints = input.ReadBool();
14475 RemoveFixedVariablesEarly = input.ReadBool();
14479 UseAllDifferentForCircuit = input.ReadBool();
14483 RoutingCutSubsetSizeForBinaryRelationBound = input.ReadInt32();
14487 RoutingCutSubsetSizeForTightBinaryRelationBound = input.ReadInt32();
14491 RoutingCutDpEffort = input.ReadDouble();
14495 MaximumRegionsToSplitInDisconnectedNoOverlap2D = input.ReadInt32();
14503 #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
14504 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
14505 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
14506 void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) {
14508 while ((tag = input.ReadTag()) != 0) {
14509 if ((tag & 7) == 4) {
14515 _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);
14518 PreferredVariableOrder = (global::Google.OrTools.Sat.SatParameters.Types.VariableOrder) input.ReadEnum();
14522 InitialPolarity = (global::Google.OrTools.Sat.SatParameters.Types.Polarity) input.ReadEnum();
14526 MinimizationAlgorithm = (global::Google.OrTools.Sat.SatParameters.Types.ConflictMinimizationAlgorithm) input.ReadEnum();
14530 ClauseCleanupPeriod = input.ReadInt32();
14534 ClauseCleanupTarget = input.ReadInt32();
14538 VariableActivityDecay = input.ReadDouble();
14542 MaxVariableActivityValue = input.ReadDouble();
14546 ClauseActivityDecay = input.ReadDouble();
14550 MaxClauseActivityValue = input.ReadDouble();
14554 GlucoseMaxDecay = input.ReadDouble();
14558 GlucoseDecayIncrement = input.ReadDouble();
14562 GlucoseDecayIncrementPeriod = input.ReadInt32();
14566 RestartPeriod = input.ReadInt32();
14570 RandomSeed = input.ReadInt32();
14574 RandomBranchesRatio = input.ReadDouble();
14578 BinaryMinimizationAlgorithm = (global::Google.OrTools.Sat.SatParameters.Types.BinaryMinizationAlgorithm) input.ReadEnum();
14582 UseOptimizationHints = input.ReadBool();
14586 MaxTimeInSeconds = input.ReadDouble();
14590 MaxNumberOfConflicts = input.ReadInt64();
14594 MaxMemoryInMb = input.ReadInt64();
14598 LogSearchProgress = input.ReadBool();
14602 UsePbResolution = input.ReadBool();
14606 UsePhaseSaving = input.ReadBool();
14610 RandomPolarityRatio = input.ReadDouble();
14614 PbCleanupIncrement = input.ReadInt32();
14618 PbCleanupRatio = input.ReadDouble();
14622 MinimizeReductionDuringPbResolution = input.ReadBool();
14626 CountAssumptionLevelsInLbd = input.ReadBool();
14630 CoreMinimizationLevel = input.ReadInt32();
14634 MaxSatAssumptionOrder = (global::Google.OrTools.Sat.SatParameters.Types.MaxSatAssumptionOrder) input.ReadEnum();
14638 MaxSatReverseAssumptionOrder = input.ReadBool();
14642 MaxSatStratification = (global::Google.OrTools.Sat.SatParameters.Types.MaxSatStratificationAlgorithm) input.ReadEnum();
14646 PresolveBveThreshold = input.ReadInt32();
14650 PresolveBveClauseWeight = input.ReadInt32();
14654 SubsumptionDuringConflictAnalysis = input.ReadBool();
14658 PresolveProbingDeterministicTimeLimit = input.ReadDouble();
14662 ClauseCleanupProtection = (global::Google.OrTools.Sat.SatParameters.Types.ClauseProtection) input.ReadEnum();
14666 ClauseCleanupLbdBound = input.ReadInt32();
14670 ClauseCleanupOrdering = (global::Google.OrTools.Sat.SatParameters.Types.ClauseOrdering) input.ReadEnum();
14675 restartAlgorithms_.AddEntriesFrom(ref input, _repeated_restartAlgorithms_codec);
14679 RestartRunningWindowSize = input.ReadInt32();
14683 RestartDlAverageRatio = input.ReadDouble();
14687 UseBlockingRestart = input.ReadBool();
14691 BlockingRestartWindowSize = input.ReadInt32();
14695 BlockingRestartMultiplier = input.ReadDouble();
14699 MaxDeterministicTime = input.ReadDouble();
14703 NumConflictsBeforeStrategyChanges = input.ReadInt32();
14707 StrategyChangeIncreaseRatio = input.ReadDouble();
14711 DefaultRestartAlgorithms = input.ReadString();
14715 RestartLbdAverageRatio = input.ReadDouble();
14719 PresolveUseBva = input.ReadBool();
14723 PresolveBvaThreshold = input.ReadInt32();
14727 UsePrecedencesInDisjunctiveConstraint = input.ReadBool();
14731 UseErwaHeuristic = input.ReadBool();
14735 InitialVariablesActivity = input.ReadDouble();
14739 AlsoBumpVariablesInConflictReasons = input.ReadBool();
14743 UseOverloadCheckerInCumulative = input.ReadBool();
14747 UseTimetableEdgeFindingInCumulative = input.ReadBool();
14751 UseDisjunctiveConstraintInCumulative = input.ReadBool();
14755 SearchBranching = (global::Google.OrTools.Sat.SatParameters.Types.SearchBranching) input.ReadEnum();
14759 OptimizeWithCore = input.ReadBool();
14763 FindMultipleCores = input.ReadBool();
14767 OptimizeWithMaxHs = input.ReadBool();
14771 CpModelPresolve = input.ReadBool();
14775 EnumerateAllSolutions = input.ReadBool();
14779 PresolveBlockedClause = input.ReadBool();
14783 CoverOptimization = input.ReadBool();
14787 LinearizationLevel = input.ReadInt32();
14791 MaxNumCuts = input.ReadInt32();
14795 OnlyAddCutsAtLevelZero = input.ReadBool();
14799 CpModelUseSatPresolve = input.ReadBool();
14803 ExploitIntegerLpSolution = input.ReadBool();
14807 AutoDetectGreaterThanAtLeastOneOf = input.ReadBool();
14811 StopAfterFirstSolution = input.ReadBool();
14815 BinarySearchNumConflicts = input.ReadInt32();
14819 NumSearchWorkers = input.ReadInt32();
14823 UseLnsOnly = input.ReadBool();
14827 RandomizeSearch = input.ReadBool();
14831 SearchRandomVariablePoolSize = input.ReadInt64();
14835 InstantiateAllVariables = input.ReadBool();
14839 BooleanEncodingLevel = input.ReadInt32();
14843 UseOptionalVariables = input.ReadBool();
14847 UseExactLpReason = input.ReadBool();
14851 CpModelProbingLevel = input.ReadInt32();
14855 AddLpConstraintsLazily = input.ReadBool();
14859 ShareObjectiveBounds = input.ReadBool();
14863 ShareLevelZeroBounds = input.ReadBool();
14867 MinOrthogonalityForLpConstraints = input.ReadDouble();
14871 ExploitAllLpSolution = input.ReadBool();
14875 AddCgCuts = input.ReadBool();
14879 MaxIntegerRoundingScaling = input.ReadInt32();
14883 AddMirCuts = input.ReadBool();
14887 MaxConsecutiveInactiveCount = input.ReadInt32();
14891 NewConstraintsBatchSize = input.ReadInt32();
14895 PseudoCostReliabilityThreshold = input.ReadInt64();
14899 MipMaxBound = input.ReadDouble();
14903 MipVarScaling = input.ReadDouble();
14907 MipWantedPrecision = input.ReadDouble();
14911 MipMaxActivityExponent = input.ReadInt32();
14915 MipCheckPrecision = input.ReadDouble();
14919 UseRinsLns = input.ReadBool();
14923 ExploitBestSolution = input.ReadBool();
14927 ExploitObjective = input.ReadBool();
14931 FillTightenedDomainsInResponse = input.ReadBool();
14935 UseCombinedNoOverlap = input.ReadBool();
14939 InterleaveBatchSize = input.ReadInt32();
14943 CatchSigintSignal = input.ReadBool();
14947 InterleaveSearch = input.ReadBool();
14951 DiversifyLnsParams = input.ReadBool();
14955 MaxPresolveIterations = input.ReadInt32();
14959 UseImpliedBounds = input.ReadBool();
14963 MergeNoOverlapWorkLimit = input.ReadDouble();
14967 MergeAtMostOneWorkLimit = input.ReadDouble();
14971 PresolveSubstitutionLevel = input.ReadInt32();
14975 MaxAllDiffCutSize = input.ReadInt32();
14979 StopAfterPresolve = input.ReadBool();
14983 DebugMaxNumPresolveOperations = input.ReadInt32();
14987 AddLinMaxCuts = input.ReadBool();
14991 HintConflictLimit = input.ReadInt32();
14995 MaxCutRoundsAtLevelZero = input.ReadInt32();
14999 CutMaxActiveCountValue = input.ReadDouble();
15003 CutActiveCountDecay = input.ReadDouble();
15007 CutCleanupTarget = input.ReadInt32();
15011 AbsoluteGapLimit = input.ReadDouble();
15015 RelativeGapLimit = input.ReadDouble();
15019 ExploitRelaxationSolution = input.ReadBool();
15023 DebugPostsolveWithFullSolver = input.ReadBool();
15027 UseSatInprocessing = input.ReadBool();
15031 UseFeasibilityPump = input.ReadBool();
15035 FpRounding = (global::Google.OrTools.Sat.SatParameters.Types.FPRoundingMethod) input.ReadEnum();
15039 MipAutomaticallyScaleVariables = input.ReadBool();
15043 RepairHint = input.ReadBool();
15047 PolarityRephaseIncrement = input.ReadInt32();
15051 AddZeroHalfCuts = input.ReadBool();
15055 ExpandAlldiffConstraints = input.ReadBool();
15059 Name = input.ReadString();
15063 AddCliqueCuts = input.ReadBool();
15067 KeepAllFeasibleSolutionsInPresolve = input.ReadBool();
15071 PresolveExtractIntegerEnforcement = input.ReadBool();
15075 PolishLpSolution = input.ReadBool();
15079 UseProbingSearch = input.ReadBool();
15083 ConvertIntervals = input.ReadBool();
15087 PermuteVariableRandomly = input.ReadBool();
15091 PermutePresolveConstraintOrder = input.ReadBool();
15095 UseAbslRandom = input.ReadBool();
15099 DisableConstraintExpansion = input.ReadBool();
15103 ExpandReservoirConstraints = input.ReadBool();
15107 SymmetryLevel = input.ReadInt32();
15111 LogPrefix = input.ReadString();
15115 LogToStdout = input.ReadBool();
15119 LogToResponse = input.ReadBool();
15123 OptimizeWithLbTreeSearch = input.ReadBool();
15127 LogSubsolverStatistics = input.ReadBool();
15131 ClauseCleanupRatio = input.ReadDouble();
15135 MaxDomainSizeWhenEncodingEqNeqConstraints = input.ReadInt32();
15139 FixVariablesToTheirHintedValue = input.ReadBool();
15143 SolutionPoolSize = input.ReadInt32();
15147 FillAdditionalSolutionsInResponse = input.ReadBool();
15151 DebugCrashOnBadHint = input.ReadBool();
15155 CutLevel = input.ReadInt32();
15159 AddObjectiveCut = input.ReadBool();
15163 MipComputeTrueObjectiveBound = input.ReadBool();
15167 MipMaxValidMagnitude = input.ReadDouble();
15171 UseTimetablingInNoOverlap2D = input.ReadBool();
15175 PresolveInclusionWorkLimit = input.ReadInt64();
15179 IgnoreNames = input.ReadBool();
15183 ShareBinaryClauses = input.ReadBool();
15187 UseShavingInProbingSearch = input.ReadBool();
15191 ShavingSearchDeterministicTime = input.ReadDouble();
15195 NumWorkers = input.ReadInt32();
15199 subsolvers_.AddEntriesFrom(ref input, _repeated_subsolvers_codec);
15203 ignoreSubsolvers_.AddEntriesFrom(ref input, _repeated_ignoreSubsolvers_codec);
15207 subsolverParams_.AddEntriesFrom(ref input, _repeated_subsolverParams_codec);
15211 UseEnergeticReasoningInNoOverlap2D = input.ReadBool();
15215 UseDualSchedulingHeuristics = input.ReadBool();
15219 UseHardPrecedencesInCumulative = input.ReadBool();
15223 DetectTableWithCost = input.ReadBool();
15227 TableCompressionLevel = input.ReadInt32();
15231 extraSubsolvers_.AddEntriesFrom(ref input, _repeated_extraSubsolvers_codec);
15235 ExploitAllPrecedences = input.ReadBool();
15239 PropagationLoopDetectionFactor = input.ReadDouble();
15243 OnlySolveIp = input.ReadBool();
15247 EncodeComplexLinearConstraintWithInteger = input.ReadBool();
15251 NewLinearPropagation = input.ReadBool();
15255 MipScaleLargeDomain = input.ReadBool();
15259 ProbingDeterministicTimeLimit = input.ReadDouble();
15263 RootLpIterations = input.ReadInt32();
15267 UseObjectiveLbSearch = input.ReadBool();
15271 MaxSizeToCreatePrecedenceLiteralsInDisjunctive = input.ReadInt32();
15275 UseStrongPropagationInDisjunctive = input.ReadBool();
15279 MipDropTolerance = input.ReadDouble();
15283 InferAllDiffs = input.ReadBool();
15287 FindBigLinearOverlap = input.ReadBool();
15291 SharedTreeNumWorkers = input.ReadInt32();
15295 UseSharedTreeSearch = input.ReadBool();
15299 SharedTreeMaxNodesPerWorker = input.ReadInt32();
15303 SharedTreeSplitStrategy = (global::Google.OrTools.Sat.SatParameters.Types.SharedTreeSplitStrategy) input.ReadEnum();
15307 UseLsOnly = input.ReadBool();
15311 FeasibilityJumpDecay = input.ReadDouble();
15315 NumViolationLs = input.ReadInt32();
15319 FeasibilityJumpVarRandomizationProbability = input.ReadDouble();
15323 FeasibilityJumpVarPerburbationRangeRatio = input.ReadDouble();
15327 ViolationLsPerturbationPeriod = input.ReadInt32();
15331 FeasibilityJumpEnableRestarts = input.ReadBool();
15335 StopAfterRootPropagation = input.ReadBool();
15339 UseObjectiveShavingSearch = input.ReadBool();
15343 UseLbRelaxLns = input.ReadBool();
15347 LinearSplitSize = input.ReadInt32();
15351 FeasibilityJumpLinearizationLevel = input.ReadInt32();
15355 FeasibilityJumpRestartFactor = input.ReadInt32();
15359 ViolationLsCompoundMoveProbability = input.ReadDouble();
15363 MaxNumIntervalsForTimetableEdgeFinding = input.ReadInt32();
15367 MipPresolveLevel = input.ReadInt32();
15371 PushAllTasksTowardStart = input.ReadBool();
15375 UseDynamicPrecedenceInDisjunctive = input.ReadBool();
15379 FeasibilityJumpMaxExpandedConstraintSize = input.ReadInt32();
15383 UseFeasibilityJump = input.ReadBool();
15387 LpPrimalTolerance = input.ReadDouble();
15391 LpDualTolerance = input.ReadDouble();
15395 UseDynamicPrecedenceInCumulative = input.ReadBool();
15399 UseExtendedProbing = input.ReadBool();
15403 AtMostOneMaxExpansionSize = input.ReadInt32();
15407 UseAreaEnergeticReasoningInNoOverlap2D = input.ReadBool();
15411 ProbingNumCombinationsLimit = input.ReadInt32();
15415 InprocessingDtimeRatio = input.ReadDouble();
15419 InprocessingProbingDtime = input.ReadDouble();
15423 InprocessingMinimizationDtime = input.ReadDouble();
15427 MaxPairsPairwiseReasoningInNoOverlap2D = input.ReadInt32();
15431 DetectLinearizedProduct = input.ReadBool();
15435 MipTreatHighMagnitudeBoundsAsInfinity = input.ReadBool();
15439 AddRltCuts = input.ReadBool();
15443 MaxLinMaxSizeForExpansion = input.ReadInt32();
15447 SharedTreeOpenLeavesPerWorker = input.ReadDouble();
15451 SharedTreeWorkerMinRestartsPerSubtree = input.ReadInt32();
15455 UseLns = input.ReadBool();
15459 SaveLpBasisInLbTreeSearch = input.ReadBool();
15463 ShareGlueClauses = input.ReadBool();
15467 UseConservativeScaleOverloadChecker = input.ReadBool();
15471 EncodeCumulativeAsReservoir = input.ReadBool();
15475 ExpandReservoirUsingCircuit = input.ReadBool();
15479 UseVariablesShavingSearch = input.ReadBool();
15483 ShavingSearchThreshold = input.ReadInt64();
15487 MaxNumDeterministicBatches = input.ReadInt32();
15491 FeasibilityJumpBatchDtime = input.ReadDouble();
15495 filterSubsolvers_.AddEntriesFrom(ref input, _repeated_filterSubsolvers_codec);
15499 NumFullSubsolvers = input.ReadInt32();
15503 SharedTreeWorkerEnableTrailSharing = input.ReadBool();
15507 LbRelaxNumWorkersThreshold = input.ReadInt32();
15511 InprocessingMinimizationUseConflictAnalysis = input.ReadBool();
15515 InprocessingMinimizationUseAllOrderings = input.ReadBool();
15519 UseTryEdgeReasoningInNoOverlap2D = input.ReadBool();
15523 MinimizeSharedClauses = input.ReadBool();
15527 UseSymmetryInLp = input.ReadBool();
15531 SymmetryDetectionDeterministicTimeLimit = input.ReadDouble();
15535 KeepSymmetryInPresolve = input.ReadBool();
15539 SharedTreeWorkerEnablePhaseSharing = input.ReadBool();
15543 SharedTreeBalanceTolerance = input.ReadInt32();
15547 DebugCrashIfPresolveBreaksHint = input.ReadBool();
15551 LnsInitialDifficulty = input.ReadDouble();
15555 LnsInitialDeterministicLimit = input.ReadDouble();
15559 PolarityExploitLsHints = input.ReadBool();
15563 RemoveFixedVariablesEarly = input.ReadBool();
15567 UseAllDifferentForCircuit = input.ReadBool();
15571 RoutingCutSubsetSizeForBinaryRelationBound = input.ReadInt32();
15575 RoutingCutSubsetSizeForTightBinaryRelationBound = input.ReadInt32();
15579 RoutingCutDpEffort = input.ReadDouble();
15583 MaximumRegionsToSplitInDisconnectedNoOverlap2D = input.ReadInt32();
15591 #region Nested types
15593 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
15594 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
15595 public static partial class Types {
15600 public enum VariableOrder {
15604 [pbr::OriginalName(
"IN_ORDER")] InOrder = 0,
15605 [pbr::OriginalName(
"IN_REVERSE_ORDER")] InReverseOrder = 1,
15606 [pbr::OriginalName(
"IN_RANDOM_ORDER")] InRandomOrder = 2,
15617 public enum Polarity {
15618 [pbr::OriginalName(
"POLARITY_TRUE")] True = 0,
15619 [pbr::OriginalName(
"POLARITY_FALSE")] False = 1,
15620 [pbr::OriginalName(
"POLARITY_RANDOM")] Random = 2,
15626 public enum ConflictMinimizationAlgorithm {
15627 [pbr::OriginalName(
"NONE")]
None = 0,
15628 [pbr::OriginalName(
"SIMPLE")] Simple = 1,
15629 [pbr::OriginalName(
"RECURSIVE")] Recursive = 2,
15630 [pbr::OriginalName(
"EXPERIMENTAL")] Experimental = 3,
15636 public enum BinaryMinizationAlgorithm {
15637 [pbr::OriginalName(
"NO_BINARY_MINIMIZATION")] NoBinaryMinimization = 0,
15638 [pbr::OriginalName(
"BINARY_MINIMIZATION_FIRST")] BinaryMinimizationFirst = 1,
15639 [pbr::OriginalName(
"BINARY_MINIMIZATION_FIRST_WITH_TRANSITIVE_REDUCTION")] BinaryMinimizationFirstWithTransitiveReduction = 4,
15640 [pbr::OriginalName(
"BINARY_MINIMIZATION_WITH_REACHABILITY")] BinaryMinimizationWithReachability = 2,
15641 [pbr::OriginalName(
"EXPERIMENTAL_BINARY_MINIMIZATION")] ExperimentalBinaryMinimization = 3,
15668 public enum ClauseOrdering {
15676 [pbr::OriginalName(
"CLAUSE_LBD")]
ClauseLbd = 1,
15688 [pbr::OriginalName(
"NO_RESTART")]
NoRestart = 0,
15754 [pbr::OriginalName(
"FIXED_SEARCH")]
FixedSearch = 1,
15763 [pbr::OriginalName(
"LP_SEARCH")]
LpSearch = 3,
15781 [pbr::OriginalName(
"HINT_SEARCH")]
HintSearch = 6,
15838 [pbr::OriginalName(
"LOCK_BASED")]
LockBased = 1,
15864#endregion Designer generated code
1.13.2