383 #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
387 private static readonly pb::MessageParser<SatParameters> _parser =
new pb::MessageParser<SatParameters>(() =>
new SatParameters());
388 private pb::UnknownFieldSet _unknownFields;
389 private int _hasBits0;
390 private int _hasBits1;
391 private int _hasBits2;
392 private int _hasBits3;
393 private int _hasBits4;
394 private int _hasBits5;
395 private int _hasBits6;
396 private int _hasBits7;
397 private int _hasBits8;
398 private int _hasBits9;
399 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
400 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
401 public static pb::MessageParser<SatParameters>
Parser {
get {
return _parser; } }
403 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
404 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
405 public static pbr::MessageDescriptor
Descriptor {
406 get {
return global::Google.OrTools.Sat.SatParametersReflection.Descriptor.MessageTypes[0]; }
409 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
410 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
411 pbr::MessageDescriptor pb::IMessage.Descriptor {
415 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
416 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
421 partial
void OnConstruction();
423 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
424 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
426 _hasBits0 = other._hasBits0;
427 _hasBits1 = other._hasBits1;
428 _hasBits2 = other._hasBits2;
429 _hasBits3 = other._hasBits3;
430 _hasBits4 = other._hasBits4;
431 _hasBits5 = other._hasBits5;
432 _hasBits6 = other._hasBits6;
433 _hasBits7 = other._hasBits7;
434 _hasBits8 = other._hasBits8;
435 _hasBits9 = other._hasBits9;
437 preferredVariableOrder_ = other.preferredVariableOrder_;
438 initialPolarity_ = other.initialPolarity_;
439 usePhaseSaving_ = other.usePhaseSaving_;
440 polarityRephaseIncrement_ = other.polarityRephaseIncrement_;
441 polarityExploitLsHints_ = other.polarityExploitLsHints_;
442 randomPolarityRatio_ = other.randomPolarityRatio_;
443 randomBranchesRatio_ = other.randomBranchesRatio_;
444 useErwaHeuristic_ = other.useErwaHeuristic_;
445 initialVariablesActivity_ = other.initialVariablesActivity_;
446 alsoBumpVariablesInConflictReasons_ = other.alsoBumpVariablesInConflictReasons_;
447 minimizationAlgorithm_ = other.minimizationAlgorithm_;
448 binaryMinimizationAlgorithm_ = other.binaryMinimizationAlgorithm_;
449 subsumptionDuringConflictAnalysis_ = other.subsumptionDuringConflictAnalysis_;
450 extraSubsumptionDuringConflictAnalysis_ = other.extraSubsumptionDuringConflictAnalysis_;
451 decisionSubsumptionDuringConflictAnalysis_ = other.decisionSubsumptionDuringConflictAnalysis_;
452 eagerlySubsumeLastNConflicts_ = other.eagerlySubsumeLastNConflicts_;
453 subsumeDuringVivification_ = other.subsumeDuringVivification_;
454 useChronologicalBacktracking_ = other.useChronologicalBacktracking_;
455 maxBackjumpLevels_ = other.maxBackjumpLevels_;
456 chronologicalBacktrackMinConflicts_ = other.chronologicalBacktrackMinConflicts_;
457 clauseCleanupPeriod_ = other.clauseCleanupPeriod_;
458 clauseCleanupPeriodIncrement_ = other.clauseCleanupPeriodIncrement_;
459 clauseCleanupTarget_ = other.clauseCleanupTarget_;
460 clauseCleanupRatio_ = other.clauseCleanupRatio_;
461 clauseCleanupLbdBound_ = other.clauseCleanupLbdBound_;
462 clauseCleanupLbdTier1_ = other.clauseCleanupLbdTier1_;
463 clauseCleanupLbdTier2_ = other.clauseCleanupLbdTier2_;
464 clauseCleanupOrdering_ = other.clauseCleanupOrdering_;
465 pbCleanupIncrement_ = other.pbCleanupIncrement_;
466 pbCleanupRatio_ = other.pbCleanupRatio_;
467 variableActivityDecay_ = other.variableActivityDecay_;
468 maxVariableActivityValue_ = other.maxVariableActivityValue_;
469 glucoseMaxDecay_ = other.glucoseMaxDecay_;
470 glucoseDecayIncrement_ = other.glucoseDecayIncrement_;
471 glucoseDecayIncrementPeriod_ = other.glucoseDecayIncrementPeriod_;
472 clauseActivityDecay_ = other.clauseActivityDecay_;
473 maxClauseActivityValue_ = other.maxClauseActivityValue_;
474 restartAlgorithms_ = other.restartAlgorithms_.Clone();
475 defaultRestartAlgorithms_ = other.defaultRestartAlgorithms_;
476 restartPeriod_ = other.restartPeriod_;
477 restartRunningWindowSize_ = other.restartRunningWindowSize_;
478 restartDlAverageRatio_ = other.restartDlAverageRatio_;
479 restartLbdAverageRatio_ = other.restartLbdAverageRatio_;
480 useBlockingRestart_ = other.useBlockingRestart_;
481 blockingRestartWindowSize_ = other.blockingRestartWindowSize_;
482 blockingRestartMultiplier_ = other.blockingRestartMultiplier_;
483 numConflictsBeforeStrategyChanges_ = other.numConflictsBeforeStrategyChanges_;
484 strategyChangeIncreaseRatio_ = other.strategyChangeIncreaseRatio_;
485 maxTimeInSeconds_ = other.maxTimeInSeconds_;
486 maxDeterministicTime_ = other.maxDeterministicTime_;
487 maxNumDeterministicBatches_ = other.maxNumDeterministicBatches_;
488 maxNumberOfConflicts_ = other.maxNumberOfConflicts_;
489 maxMemoryInMb_ = other.maxMemoryInMb_;
490 absoluteGapLimit_ = other.absoluteGapLimit_;
491 relativeGapLimit_ = other.relativeGapLimit_;
492 randomSeed_ = other.randomSeed_;
493 permuteVariableRandomly_ = other.permuteVariableRandomly_;
494 permutePresolveConstraintOrder_ = other.permutePresolveConstraintOrder_;
495 useAbslRandom_ = other.useAbslRandom_;
496 logSearchProgress_ = other.logSearchProgress_;
497 logSubsolverStatistics_ = other.logSubsolverStatistics_;
498 logPrefix_ = other.logPrefix_;
499 logToStdout_ = other.logToStdout_;
500 logToResponse_ = other.logToResponse_;
501 usePbResolution_ = other.usePbResolution_;
502 minimizeReductionDuringPbResolution_ = other.minimizeReductionDuringPbResolution_;
503 countAssumptionLevelsInLbd_ = other.countAssumptionLevelsInLbd_;
504 presolveBveThreshold_ = other.presolveBveThreshold_;
505 filterSatPostsolveClauses_ = other.filterSatPostsolveClauses_;
506 presolveBveClauseWeight_ = other.presolveBveClauseWeight_;
507 probingDeterministicTimeLimit_ = other.probingDeterministicTimeLimit_;
508 presolveProbingDeterministicTimeLimit_ = other.presolveProbingDeterministicTimeLimit_;
509 presolveBlockedClause_ = other.presolveBlockedClause_;
510 presolveUseBva_ = other.presolveUseBva_;
511 presolveBvaThreshold_ = other.presolveBvaThreshold_;
512 maxPresolveIterations_ = other.maxPresolveIterations_;
513 cpModelPresolve_ = other.cpModelPresolve_;
514 cpModelProbingLevel_ = other.cpModelProbingLevel_;
515 cpModelUseSatPresolve_ = other.cpModelUseSatPresolve_;
516 loadAtMostOnesInSatPresolve_ = other.loadAtMostOnesInSatPresolve_;
517 removeFixedVariablesEarly_ = other.removeFixedVariablesEarly_;
518 detectTableWithCost_ = other.detectTableWithCost_;
519 tableCompressionLevel_ = other.tableCompressionLevel_;
520 expandAlldiffConstraints_ = other.expandAlldiffConstraints_;
521 maxAlldiffDomainSize_ = other.maxAlldiffDomainSize_;
522 expandReservoirConstraints_ = other.expandReservoirConstraints_;
523 maxDomainSizeForLinear2Expansion_ = other.maxDomainSizeForLinear2Expansion_;
524 expandReservoirUsingCircuit_ = other.expandReservoirUsingCircuit_;
525 encodeCumulativeAsReservoir_ = other.encodeCumulativeAsReservoir_;
526 maxLinMaxSizeForExpansion_ = other.maxLinMaxSizeForExpansion_;
527 disableConstraintExpansion_ = other.disableConstraintExpansion_;
528 encodeComplexLinearConstraintWithInteger_ = other.encodeComplexLinearConstraintWithInteger_;
529 mergeNoOverlapWorkLimit_ = other.mergeNoOverlapWorkLimit_;
530 mergeAtMostOneWorkLimit_ = other.mergeAtMostOneWorkLimit_;
531 presolveSubstitutionLevel_ = other.presolveSubstitutionLevel_;
532 presolveExtractIntegerEnforcement_ = other.presolveExtractIntegerEnforcement_;
533 presolveInclusionWorkLimit_ = other.presolveInclusionWorkLimit_;
534 ignoreNames_ = other.ignoreNames_;
535 inferAllDiffs_ = other.inferAllDiffs_;
536 findBigLinearOverlap_ = other.findBigLinearOverlap_;
537 findClausesThatAreExactlyOne_ = other.findClausesThatAreExactlyOne_;
538 useSatInprocessing_ = other.useSatInprocessing_;
539 inprocessingDtimeRatio_ = other.inprocessingDtimeRatio_;
540 inprocessingProbingDtime_ = other.inprocessingProbingDtime_;
541 inprocessingMinimizationDtime_ = other.inprocessingMinimizationDtime_;
542 inprocessingMinimizationUseConflictAnalysis_ = other.inprocessingMinimizationUseConflictAnalysis_;
543 inprocessingMinimizationUseAllOrderings_ = other.inprocessingMinimizationUseAllOrderings_;
544 inprocessingUseCongruenceClosure_ = other.inprocessingUseCongruenceClosure_;
545 inprocessingUseSatSweeping_ = other.inprocessingUseSatSweeping_;
546 numWorkers_ = other.numWorkers_;
547 numSearchWorkers_ = other.numSearchWorkers_;
548 numFullSubsolvers_ = other.numFullSubsolvers_;
549 subsolvers_ = other.subsolvers_.Clone();
550 extraSubsolvers_ = other.extraSubsolvers_.Clone();
551 ignoreSubsolvers_ = other.ignoreSubsolvers_.Clone();
552 filterSubsolvers_ = other.filterSubsolvers_.Clone();
553 subsolverParams_ = other.subsolverParams_.Clone();
554 interleaveSearch_ = other.interleaveSearch_;
555 interleaveBatchSize_ = other.interleaveBatchSize_;
556 shareObjectiveBounds_ = other.shareObjectiveBounds_;
557 shareLevelZeroBounds_ = other.shareLevelZeroBounds_;
558 shareLinear2Bounds_ = other.shareLinear2Bounds_;
559 shareBinaryClauses_ = other.shareBinaryClauses_;
560 shareGlueClauses_ = other.shareGlueClauses_;
561 minimizeSharedClauses_ = other.minimizeSharedClauses_;
562 shareGlueClausesDtime_ = other.shareGlueClausesDtime_;
563 checkLratProof_ = other.checkLratProof_;
564 checkMergedLratProof_ = other.checkMergedLratProof_;
565 outputLratProof_ = other.outputLratProof_;
566 checkDratProof_ = other.checkDratProof_;
567 outputDratProof_ = other.outputDratProof_;
568 maxDratTimeInSeconds_ = other.maxDratTimeInSeconds_;
569 debugPostsolveWithFullSolver_ = other.debugPostsolveWithFullSolver_;
570 debugMaxNumPresolveOperations_ = other.debugMaxNumPresolveOperations_;
571 debugCrashOnBadHint_ = other.debugCrashOnBadHint_;
572 debugCrashIfPresolveBreaksHint_ = other.debugCrashIfPresolveBreaksHint_;
573 debugCrashIfLratCheckFails_ = other.debugCrashIfLratCheckFails_;
574 useOptimizationHints_ = other.useOptimizationHints_;
575 coreMinimizationLevel_ = other.coreMinimizationLevel_;
576 findMultipleCores_ = other.findMultipleCores_;
577 coverOptimization_ = other.coverOptimization_;
578 maxSatAssumptionOrder_ = other.maxSatAssumptionOrder_;
579 maxSatReverseAssumptionOrder_ = other.maxSatReverseAssumptionOrder_;
580 maxSatStratification_ = other.maxSatStratification_;
581 propagationLoopDetectionFactor_ = other.propagationLoopDetectionFactor_;
582 usePrecedencesInDisjunctiveConstraint_ = other.usePrecedencesInDisjunctiveConstraint_;
583 transitivePrecedencesWorkLimit_ = other.transitivePrecedencesWorkLimit_;
584 maxSizeToCreatePrecedenceLiteralsInDisjunctive_ = other.maxSizeToCreatePrecedenceLiteralsInDisjunctive_;
585 useStrongPropagationInDisjunctive_ = other.useStrongPropagationInDisjunctive_;
586 useDynamicPrecedenceInDisjunctive_ = other.useDynamicPrecedenceInDisjunctive_;
587 useDynamicPrecedenceInCumulative_ = other.useDynamicPrecedenceInCumulative_;
588 useOverloadCheckerInCumulative_ = other.useOverloadCheckerInCumulative_;
589 useConservativeScaleOverloadChecker_ = other.useConservativeScaleOverloadChecker_;
590 useTimetableEdgeFindingInCumulative_ = other.useTimetableEdgeFindingInCumulative_;
591 maxNumIntervalsForTimetableEdgeFinding_ = other.maxNumIntervalsForTimetableEdgeFinding_;
592 useHardPrecedencesInCumulative_ = other.useHardPrecedencesInCumulative_;
593 exploitAllPrecedences_ = other.exploitAllPrecedences_;
594 useDisjunctiveConstraintInCumulative_ = other.useDisjunctiveConstraintInCumulative_;
595 noOverlap2DBooleanRelationsLimit_ = other.noOverlap2DBooleanRelationsLimit_;
596 useTimetablingInNoOverlap2D_ = other.useTimetablingInNoOverlap2D_;
597 useEnergeticReasoningInNoOverlap2D_ = other.useEnergeticReasoningInNoOverlap2D_;
598 useAreaEnergeticReasoningInNoOverlap2D_ = other.useAreaEnergeticReasoningInNoOverlap2D_;
599 useTryEdgeReasoningInNoOverlap2D_ = other.useTryEdgeReasoningInNoOverlap2D_;
600 maxPairsPairwiseReasoningInNoOverlap2D_ = other.maxPairsPairwiseReasoningInNoOverlap2D_;
601 maximumRegionsToSplitInDisconnectedNoOverlap2D_ = other.maximumRegionsToSplitInDisconnectedNoOverlap2D_;
602 useLinear3ForNoOverlap2DPrecedences_ = other.useLinear3ForNoOverlap2DPrecedences_;
603 useDualSchedulingHeuristics_ = other.useDualSchedulingHeuristics_;
604 useAllDifferentForCircuit_ = other.useAllDifferentForCircuit_;
605 routingCutSubsetSizeForBinaryRelationBound_ = other.routingCutSubsetSizeForBinaryRelationBound_;
606 routingCutSubsetSizeForTightBinaryRelationBound_ = other.routingCutSubsetSizeForTightBinaryRelationBound_;
607 routingCutSubsetSizeForExactBinaryRelationBound_ = other.routingCutSubsetSizeForExactBinaryRelationBound_;
608 routingCutSubsetSizeForShortestPathsBound_ = other.routingCutSubsetSizeForShortestPathsBound_;
609 routingCutDpEffort_ = other.routingCutDpEffort_;
610 routingCutMaxInfeasiblePathLength_ = other.routingCutMaxInfeasiblePathLength_;
611 searchBranching_ = other.searchBranching_;
612 hintConflictLimit_ = other.hintConflictLimit_;
613 repairHint_ = other.repairHint_;
614 fixVariablesToTheirHintedValue_ = other.fixVariablesToTheirHintedValue_;
615 useProbingSearch_ = other.useProbingSearch_;
616 useExtendedProbing_ = other.useExtendedProbing_;
617 probingNumCombinationsLimit_ = other.probingNumCombinationsLimit_;
618 shavingDeterministicTimeInProbingSearch_ = other.shavingDeterministicTimeInProbingSearch_;
619 shavingSearchDeterministicTime_ = other.shavingSearchDeterministicTime_;
620 shavingSearchThreshold_ = other.shavingSearchThreshold_;
621 useObjectiveLbSearch_ = other.useObjectiveLbSearch_;
622 useObjectiveShavingSearch_ = other.useObjectiveShavingSearch_;
623 variablesShavingLevel_ = other.variablesShavingLevel_;
624 pseudoCostReliabilityThreshold_ = other.pseudoCostReliabilityThreshold_;
625 optimizeWithCore_ = other.optimizeWithCore_;
626 optimizeWithLbTreeSearch_ = other.optimizeWithLbTreeSearch_;
627 saveLpBasisInLbTreeSearch_ = other.saveLpBasisInLbTreeSearch_;
628 binarySearchNumConflicts_ = other.binarySearchNumConflicts_;
629 optimizeWithMaxHs_ = other.optimizeWithMaxHs_;
630 useFeasibilityJump_ = other.useFeasibilityJump_;
631 useLsOnly_ = other.useLsOnly_;
632 feasibilityJumpDecay_ = other.feasibilityJumpDecay_;
633 feasibilityJumpLinearizationLevel_ = other.feasibilityJumpLinearizationLevel_;
634 feasibilityJumpRestartFactor_ = other.feasibilityJumpRestartFactor_;
635 feasibilityJumpBatchDtime_ = other.feasibilityJumpBatchDtime_;
636 feasibilityJumpVarRandomizationProbability_ = other.feasibilityJumpVarRandomizationProbability_;
637 feasibilityJumpVarPerburbationRangeRatio_ = other.feasibilityJumpVarPerburbationRangeRatio_;
638 feasibilityJumpEnableRestarts_ = other.feasibilityJumpEnableRestarts_;
639 feasibilityJumpMaxExpandedConstraintSize_ = other.feasibilityJumpMaxExpandedConstraintSize_;
640 numViolationLs_ = other.numViolationLs_;
641 violationLsPerturbationPeriod_ = other.violationLsPerturbationPeriod_;
642 violationLsCompoundMoveProbability_ = other.violationLsCompoundMoveProbability_;
643 sharedTreeNumWorkers_ = other.sharedTreeNumWorkers_;
644 useSharedTreeSearch_ = other.useSharedTreeSearch_;
645 sharedTreeWorkerMinRestartsPerSubtree_ = other.sharedTreeWorkerMinRestartsPerSubtree_;
646 sharedTreeWorkerEnableTrailSharing_ = other.sharedTreeWorkerEnableTrailSharing_;
647 sharedTreeWorkerEnablePhaseSharing_ = other.sharedTreeWorkerEnablePhaseSharing_;
648 sharedTreeOpenLeavesPerWorker_ = other.sharedTreeOpenLeavesPerWorker_;
649 sharedTreeMaxNodesPerWorker_ = other.sharedTreeMaxNodesPerWorker_;
650 sharedTreeSplitStrategy_ = other.sharedTreeSplitStrategy_;
651 sharedTreeBalanceTolerance_ = other.sharedTreeBalanceTolerance_;
652 sharedTreeSplitMinDtime_ = other.sharedTreeSplitMinDtime_;
653 enumerateAllSolutions_ = other.enumerateAllSolutions_;
654 keepAllFeasibleSolutionsInPresolve_ = other.keepAllFeasibleSolutionsInPresolve_;
655 fillTightenedDomainsInResponse_ = other.fillTightenedDomainsInResponse_;
656 fillAdditionalSolutionsInResponse_ = other.fillAdditionalSolutionsInResponse_;
657 instantiateAllVariables_ = other.instantiateAllVariables_;
658 autoDetectGreaterThanAtLeastOneOf_ = other.autoDetectGreaterThanAtLeastOneOf_;
659 stopAfterFirstSolution_ = other.stopAfterFirstSolution_;
660 stopAfterPresolve_ = other.stopAfterPresolve_;
661 stopAfterRootPropagation_ = other.stopAfterRootPropagation_;
662 lnsInitialDifficulty_ = other.lnsInitialDifficulty_;
663 lnsInitialDeterministicLimit_ = other.lnsInitialDeterministicLimit_;
664 useLns_ = other.useLns_;
665 useLnsOnly_ = other.useLnsOnly_;
666 solutionPoolSize_ = other.solutionPoolSize_;
667 solutionPoolDiversityLimit_ = other.solutionPoolDiversityLimit_;
668 alternativePoolSize_ = other.alternativePoolSize_;
669 useRinsLns_ = other.useRinsLns_;
670 useFeasibilityPump_ = other.useFeasibilityPump_;
671 useLbRelaxLns_ = other.useLbRelaxLns_;
672 lbRelaxNumWorkersThreshold_ = other.lbRelaxNumWorkersThreshold_;
673 fpRounding_ = other.fpRounding_;
674 diversifyLnsParams_ = other.diversifyLnsParams_;
675 randomizeSearch_ = other.randomizeSearch_;
676 searchRandomVariablePoolSize_ = other.searchRandomVariablePoolSize_;
677 pushAllTasksTowardStart_ = other.pushAllTasksTowardStart_;
678 useOptionalVariables_ = other.useOptionalVariables_;
679 useExactLpReason_ = other.useExactLpReason_;
680 useCombinedNoOverlap_ = other.useCombinedNoOverlap_;
681 atMostOneMaxExpansionSize_ = other.atMostOneMaxExpansionSize_;
682 catchSigintSignal_ = other.catchSigintSignal_;
683 useImpliedBounds_ = other.useImpliedBounds_;
684 polishLpSolution_ = other.polishLpSolution_;
685 lpPrimalTolerance_ = other.lpPrimalTolerance_;
686 lpDualTolerance_ = other.lpDualTolerance_;
687 convertIntervals_ = other.convertIntervals_;
688 symmetryLevel_ = other.symmetryLevel_;
689 useSymmetryInLp_ = other.useSymmetryInLp_;
690 keepSymmetryInPresolve_ = other.keepSymmetryInPresolve_;
691 symmetryDetectionDeterministicTimeLimit_ = other.symmetryDetectionDeterministicTimeLimit_;
692 newLinearPropagation_ = other.newLinearPropagation_;
693 linearSplitSize_ = other.linearSplitSize_;
694 linearizationLevel_ = other.linearizationLevel_;
695 booleanEncodingLevel_ = other.booleanEncodingLevel_;
696 maxDomainSizeWhenEncodingEqNeqConstraints_ = other.maxDomainSizeWhenEncodingEqNeqConstraints_;
697 maxNumCuts_ = other.maxNumCuts_;
698 cutLevel_ = other.cutLevel_;
699 onlyAddCutsAtLevelZero_ = other.onlyAddCutsAtLevelZero_;
700 addObjectiveCut_ = other.addObjectiveCut_;
701 addCgCuts_ = other.addCgCuts_;
702 addMirCuts_ = other.addMirCuts_;
703 addZeroHalfCuts_ = other.addZeroHalfCuts_;
704 addCliqueCuts_ = other.addCliqueCuts_;
705 addRltCuts_ = other.addRltCuts_;
706 maxAllDiffCutSize_ = other.maxAllDiffCutSize_;
707 addLinMaxCuts_ = other.addLinMaxCuts_;
708 maxIntegerRoundingScaling_ = other.maxIntegerRoundingScaling_;
709 addLpConstraintsLazily_ = other.addLpConstraintsLazily_;
710 rootLpIterations_ = other.rootLpIterations_;
711 minOrthogonalityForLpConstraints_ = other.minOrthogonalityForLpConstraints_;
712 maxCutRoundsAtLevelZero_ = other.maxCutRoundsAtLevelZero_;
713 maxConsecutiveInactiveCount_ = other.maxConsecutiveInactiveCount_;
714 cutMaxActiveCountValue_ = other.cutMaxActiveCountValue_;
715 cutActiveCountDecay_ = other.cutActiveCountDecay_;
716 cutCleanupTarget_ = other.cutCleanupTarget_;
717 newConstraintsBatchSize_ = other.newConstraintsBatchSize_;
718 exploitIntegerLpSolution_ = other.exploitIntegerLpSolution_;
719 exploitAllLpSolution_ = other.exploitAllLpSolution_;
720 exploitBestSolution_ = other.exploitBestSolution_;
721 exploitRelaxationSolution_ = other.exploitRelaxationSolution_;
722 exploitObjective_ = other.exploitObjective_;
723 detectLinearizedProduct_ = other.detectLinearizedProduct_;
724 useNewIntegerConflictResolution_ = other.useNewIntegerConflictResolution_;
725 create1UipBooleanDuringIcr_ = other.create1UipBooleanDuringIcr_;
726 mipMaxBound_ = other.mipMaxBound_;
727 mipVarScaling_ = other.mipVarScaling_;
728 mipScaleLargeDomain_ = other.mipScaleLargeDomain_;
729 mipAutomaticallyScaleVariables_ = other.mipAutomaticallyScaleVariables_;
730 onlySolveIp_ = other.onlySolveIp_;
731 mipWantedPrecision_ = other.mipWantedPrecision_;
732 mipMaxActivityExponent_ = other.mipMaxActivityExponent_;
733 mipCheckPrecision_ = other.mipCheckPrecision_;
734 mipComputeTrueObjectiveBound_ = other.mipComputeTrueObjectiveBound_;
735 mipMaxValidMagnitude_ = other.mipMaxValidMagnitude_;
736 mipTreatHighMagnitudeBoundsAsInfinity_ = other.mipTreatHighMagnitudeBoundsAsInfinity_;
737 mipDropTolerance_ = other.mipDropTolerance_;
738 mipPresolveLevel_ = other.mipPresolveLevel_;
739 _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
742 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
743 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
750 private readonly
static string NameDefaultValue =
"";
752 private string name_;
757 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
758 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
760 get {
return name_ ?? NameDefaultValue; }
762 name_ = pb::ProtoPreconditions.CheckNotNull(value,
"value");
766 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
767 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
769 get {
return name_ !=
null; }
772 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
773 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
780 private readonly
static global::Google.OrTools.Sat.SatParameters.Types.VariableOrder PreferredVariableOrderDefaultValue = global::Google.OrTools.Sat.SatParameters.Types.VariableOrder.InOrder;
782 private global::Google.OrTools.Sat.SatParameters.Types.VariableOrder preferredVariableOrder_;
783 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
784 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
786 get { if ((_hasBits0 & 1) != 0) { return preferredVariableOrder_; } else { return PreferredVariableOrderDefaultValue; } }
789 preferredVariableOrder_ = value;
793 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
794 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
795 public bool HasPreferredVariableOrder {
796 get {
return (_hasBits0 & 1) != 0; }
799 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
800 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
801 public void ClearPreferredVariableOrder() {
806 public const int InitialPolarityFieldNumber = 2;
807 private readonly
static global::Google.OrTools.Sat.SatParameters.Types.Polarity InitialPolarityDefaultValue = global::Google.OrTools.Sat.SatParameters.Types.Polarity.False;
809 private global::Google.OrTools.Sat.SatParameters.Types.Polarity initialPolarity_;
810 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
811 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
813 get { if ((_hasBits0 & 2) != 0) { return initialPolarity_; } else { return InitialPolarityDefaultValue; } }
816 initialPolarity_ = value;
820 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
821 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
822 public bool HasInitialPolarity {
823 get {
return (_hasBits0 & 2) != 0; }
826 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
827 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
828 public void ClearInitialPolarity() {
833 public const int UsePhaseSavingFieldNumber = 44;
834 private readonly
static bool UsePhaseSavingDefaultValue =
true;
836 private bool usePhaseSaving_;
850 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
851 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
853 get {
if ((_hasBits0 & 4194304) != 0) {
return usePhaseSaving_; }
else {
return UsePhaseSavingDefaultValue; } }
855 _hasBits0 |= 4194304;
856 usePhaseSaving_ = value;
860 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
861 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
862 public bool HasUsePhaseSaving {
863 get {
return (_hasBits0 & 4194304) != 0; }
866 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
867 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
869 _hasBits0 &= ~4194304;
874 private readonly
static int PolarityRephaseIncrementDefaultValue = 1000;
876 private int polarityRephaseIncrement_;
882 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
883 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
885 get {
if ((_hasBits4 & 2) != 0) {
return polarityRephaseIncrement_; }
else {
return PolarityRephaseIncrementDefaultValue; } }
888 polarityRephaseIncrement_ = value;
892 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
893 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
894 public bool HasPolarityRephaseIncrement {
895 get {
return (_hasBits4 & 2) != 0; }
898 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
899 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
906 private readonly
static bool PolarityExploitLsHintsDefaultValue =
false;
908 private bool polarityExploitLsHints_;
913 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
914 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
916 get {
if ((_hasBits7 & 67108864) != 0) {
return polarityExploitLsHints_; }
else {
return PolarityExploitLsHintsDefaultValue; } }
918 _hasBits7 |= 67108864;
919 polarityExploitLsHints_ = value;
923 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
924 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
925 public bool HasPolarityExploitLsHints {
926 get {
return (_hasBits7 & 67108864) != 0; }
929 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
930 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
932 _hasBits7 &= ~67108864;
937 private readonly
static double RandomPolarityRatioDefaultValue = 0D;
939 private double randomPolarityRatio_;
947 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
948 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
950 get {
if ((_hasBits0 & 8388608) != 0) {
return randomPolarityRatio_; }
else {
return RandomPolarityRatioDefaultValue; } }
952 _hasBits0 |= 8388608;
953 randomPolarityRatio_ = value;
957 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
958 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
959 public bool HasRandomPolarityRatio {
960 get {
return (_hasBits0 & 8388608) != 0; }
963 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
964 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
966 _hasBits0 &= ~8388608;
971 private readonly
static double RandomBranchesRatioDefaultValue = 0D;
973 private double randomBranchesRatio_;
979 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
980 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
982 get {
if ((_hasBits0 & 16384) != 0) {
return randomBranchesRatio_; }
else {
return RandomBranchesRatioDefaultValue; } }
985 randomBranchesRatio_ = value;
989 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
990 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
991 public bool HasRandomBranchesRatio {
992 get {
return (_hasBits0 & 16384) != 0; }
995 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
996 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1003 private readonly
static bool UseErwaHeuristicDefaultValue =
false;
1005 private bool useErwaHeuristic_;
1011 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1012 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1014 get {
if ((_hasBits1 & 262144) != 0) {
return useErwaHeuristic_; }
else {
return UseErwaHeuristicDefaultValue; } }
1016 _hasBits1 |= 262144;
1017 useErwaHeuristic_ = value;
1021 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1022 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1023 public bool HasUseErwaHeuristic {
1024 get {
return (_hasBits1 & 262144) != 0; }
1027 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1028 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1030 _hasBits1 &= ~262144;
1035 private readonly
static double InitialVariablesActivityDefaultValue = 0D;
1037 private double initialVariablesActivity_;
1046 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1047 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1049 get {
if ((_hasBits1 & 524288) != 0) {
return initialVariablesActivity_; }
else {
return InitialVariablesActivityDefaultValue; } }
1051 _hasBits1 |= 524288;
1052 initialVariablesActivity_ = value;
1056 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1057 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1058 public bool HasInitialVariablesActivity {
1059 get {
return (_hasBits1 & 524288) != 0; }
1062 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1063 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1065 _hasBits1 &= ~524288;
1070 private readonly
static bool AlsoBumpVariablesInConflictReasonsDefaultValue =
false;
1072 private bool alsoBumpVariablesInConflictReasons_;
1079 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1080 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1082 get {
if ((_hasBits1 & 1048576) != 0) {
return alsoBumpVariablesInConflictReasons_; }
else {
return AlsoBumpVariablesInConflictReasonsDefaultValue; } }
1084 _hasBits1 |= 1048576;
1085 alsoBumpVariablesInConflictReasons_ = value;
1089 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1090 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1091 public bool HasAlsoBumpVariablesInConflictReasons {
1092 get {
return (_hasBits1 & 1048576) != 0; }
1095 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1096 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1098 _hasBits1 &= ~1048576;
1103 private readonly
static global::Google.OrTools.Sat.SatParameters.Types.ConflictMinimizationAlgorithm MinimizationAlgorithmDefaultValue = global::Google.OrTools.Sat.SatParameters.Types.ConflictMinimizationAlgorithm.Recursive;
1105 private global::Google.OrTools.Sat.SatParameters.Types.ConflictMinimizationAlgorithm minimizationAlgorithm_;
1106 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1107 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1109 get { if ((_hasBits0 & 4) != 0) { return minimizationAlgorithm_; } else { return MinimizationAlgorithmDefaultValue; } }
1112 minimizationAlgorithm_ = value;
1116 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1117 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1118 public bool HasMinimizationAlgorithm {
1119 get {
return (_hasBits0 & 4) != 0; }
1122 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1123 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1130 private readonly
static global::Google.OrTools.Sat.SatParameters.Types.BinaryMinizationAlgorithm BinaryMinimizationAlgorithmDefaultValue = global::Google.OrTools.Sat.SatParameters.Types.BinaryMinizationAlgorithm.BinaryMinimizationFromUipAndDecisions;
1132 private global::Google.OrTools.Sat.SatParameters.Types.BinaryMinizationAlgorithm binaryMinimizationAlgorithm_;
1133 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1134 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1136 get { if ((_hasBits0 & 32768) != 0) { return binaryMinimizationAlgorithm_; } else { return BinaryMinimizationAlgorithmDefaultValue; } }
1139 binaryMinimizationAlgorithm_ = value;
1143 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1144 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1145 public bool HasBinaryMinimizationAlgorithm {
1146 get {
return (_hasBits0 & 32768) != 0; }
1149 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1150 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1152 _hasBits0 &= ~32768;
1157 private readonly
static bool SubsumptionDuringConflictAnalysisDefaultValue =
true;
1159 private bool subsumptionDuringConflictAnalysis_;
1166 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1167 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1169 get {
if ((_hasBits1 & 4) != 0) {
return subsumptionDuringConflictAnalysis_; }
else {
return SubsumptionDuringConflictAnalysisDefaultValue; } }
1172 subsumptionDuringConflictAnalysis_ = value;
1176 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1177 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1178 public bool HasSubsumptionDuringConflictAnalysis {
1179 get {
return (_hasBits1 & 4) != 0; }
1182 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1183 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1190 private readonly
static bool ExtraSubsumptionDuringConflictAnalysisDefaultValue =
true;
1192 private bool extraSubsumptionDuringConflictAnalysis_;
1198 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1199 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1201 get {
if ((_hasBits9 & 2) != 0) {
return extraSubsumptionDuringConflictAnalysis_; }
else {
return ExtraSubsumptionDuringConflictAnalysisDefaultValue; } }
1204 extraSubsumptionDuringConflictAnalysis_ = value;
1208 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1209 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1210 public bool HasExtraSubsumptionDuringConflictAnalysis {
1211 get {
return (_hasBits9 & 2) != 0; }
1214 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1215 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1222 private readonly
static bool DecisionSubsumptionDuringConflictAnalysisDefaultValue =
true;
1224 private bool decisionSubsumptionDuringConflictAnalysis_;
1228 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1229 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1231 get {
if ((_hasBits9 & 8) != 0) {
return decisionSubsumptionDuringConflictAnalysis_; }
else {
return DecisionSubsumptionDuringConflictAnalysisDefaultValue; } }
1234 decisionSubsumptionDuringConflictAnalysis_ = value;
1238 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1239 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1240 public bool HasDecisionSubsumptionDuringConflictAnalysis {
1241 get {
return (_hasBits9 & 8) != 0; }
1244 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1245 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1252 private readonly
static int EagerlySubsumeLastNConflictsDefaultValue = 4;
1254 private int eagerlySubsumeLastNConflicts_;
1259 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1260 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1262 get {
if ((_hasBits8 & 33554432) != 0) {
return eagerlySubsumeLastNConflicts_; }
else {
return EagerlySubsumeLastNConflictsDefaultValue; } }
1264 _hasBits8 |= 33554432;
1265 eagerlySubsumeLastNConflicts_ = value;
1269 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1270 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1271 public bool HasEagerlySubsumeLastNConflicts {
1272 get {
return (_hasBits8 & 33554432) != 0; }
1275 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1276 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1278 _hasBits8 &= ~33554432;
1283 private readonly
static bool SubsumeDuringVivificationDefaultValue =
true;
1285 private bool subsumeDuringVivification_;
1290 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1291 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1293 get {
if ((_hasBits9 & 32) != 0) {
return subsumeDuringVivification_; }
else {
return SubsumeDuringVivificationDefaultValue; } }
1296 subsumeDuringVivification_ = value;
1300 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1301 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1302 public bool HasSubsumeDuringVivification {
1303 get {
return (_hasBits9 & 32) != 0; }
1306 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1307 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1314 private readonly
static bool UseChronologicalBacktrackingDefaultValue =
false;
1316 private bool useChronologicalBacktracking_;
1324 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1325 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1327 get {
if ((_hasBits8 & 16384) != 0) {
return useChronologicalBacktracking_; }
else {
return UseChronologicalBacktrackingDefaultValue; } }
1330 useChronologicalBacktracking_ = value;
1334 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1335 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1336 public bool HasUseChronologicalBacktracking {
1337 get {
return (_hasBits8 & 16384) != 0; }
1340 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1341 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1343 _hasBits8 &= ~16384;
1348 private readonly
static int MaxBackjumpLevelsDefaultValue = 50;
1350 private int maxBackjumpLevels_;
1355 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1356 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1358 get {
if ((_hasBits8 & 32768) != 0) {
return maxBackjumpLevels_; }
else {
return MaxBackjumpLevelsDefaultValue; } }
1361 maxBackjumpLevels_ = value;
1365 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1366 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1367 public bool HasMaxBackjumpLevels {
1368 get {
return (_hasBits8 & 32768) != 0; }
1371 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1372 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1374 _hasBits8 &= ~32768;
1379 private readonly
static int ChronologicalBacktrackMinConflictsDefaultValue = 1000;
1381 private int chronologicalBacktrackMinConflicts_;
1386 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1387 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1389 get {
if ((_hasBits8 & 65536) != 0) {
return chronologicalBacktrackMinConflicts_; }
else {
return ChronologicalBacktrackMinConflictsDefaultValue; } }
1392 chronologicalBacktrackMinConflicts_ = value;
1396 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1397 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1398 public bool HasChronologicalBacktrackMinConflicts {
1399 get {
return (_hasBits8 & 65536) != 0; }
1402 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1403 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1405 _hasBits8 &= ~65536;
1410 private readonly
static int ClauseCleanupPeriodDefaultValue = 10000;
1412 private int clauseCleanupPeriod_;
1416 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1417 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1419 get {
if ((_hasBits0 & 8) != 0) {
return clauseCleanupPeriod_; }
else {
return ClauseCleanupPeriodDefaultValue; } }
1422 clauseCleanupPeriod_ = value;
1426 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1427 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1428 public bool HasClauseCleanupPeriod {
1429 get {
return (_hasBits0 & 8) != 0; }
1432 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1433 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1440 private readonly
static int ClauseCleanupPeriodIncrementDefaultValue = 0;
1442 private int clauseCleanupPeriodIncrement_;
1446 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1447 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1449 get {
if ((_hasBits8 & 1048576) != 0) {
return clauseCleanupPeriodIncrement_; }
else {
return ClauseCleanupPeriodIncrementDefaultValue; } }
1451 _hasBits8 |= 1048576;
1452 clauseCleanupPeriodIncrement_ = value;
1456 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1457 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1458 public bool HasClauseCleanupPeriodIncrement {
1459 get {
return (_hasBits8 & 1048576) != 0; }
1462 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1463 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1465 _hasBits8 &= ~1048576;
1470 private readonly
static int ClauseCleanupTargetDefaultValue = 0;
1472 private int clauseCleanupTarget_;
1477 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1478 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1480 get {
if ((_hasBits0 & 16) != 0) {
return clauseCleanupTarget_; }
else {
return ClauseCleanupTargetDefaultValue; } }
1483 clauseCleanupTarget_ = value;
1487 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1488 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1489 public bool HasClauseCleanupTarget {
1490 get {
return (_hasBits0 & 16) != 0; }
1493 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1494 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1501 private readonly
static double ClauseCleanupRatioDefaultValue = 0.5D;
1503 private double clauseCleanupRatio_;
1509 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1510 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1512 get {
if ((_hasBits4 & 1048576) != 0) {
return clauseCleanupRatio_; }
else {
return ClauseCleanupRatioDefaultValue; } }
1514 _hasBits4 |= 1048576;
1515 clauseCleanupRatio_ = value;
1519 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1520 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1521 public bool HasClauseCleanupRatio {
1522 get {
return (_hasBits4 & 1048576) != 0; }
1525 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1526 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1528 _hasBits4 &= ~1048576;
1533 private readonly
static int ClauseCleanupLbdBoundDefaultValue = 5;
1535 private int clauseCleanupLbdBound_;
1545 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1546 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1548 get {
if ((_hasBits1 & 16) != 0) {
return clauseCleanupLbdBound_; }
else {
return ClauseCleanupLbdBoundDefaultValue; } }
1551 clauseCleanupLbdBound_ = value;
1555 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1556 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1557 public bool HasClauseCleanupLbdBound {
1558 get {
return (_hasBits1 & 16) != 0; }
1561 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1562 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1569 private readonly
static int ClauseCleanupLbdTier1DefaultValue = 0;
1571 private int clauseCleanupLbdTier1_;
1577 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1578 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1580 get {
if ((_hasBits8 & -2147483648) != 0) {
return clauseCleanupLbdTier1_; }
else {
return ClauseCleanupLbdTier1DefaultValue; } }
1582 _hasBits8 |= -2147483648;
1583 clauseCleanupLbdTier1_ = value;
1587 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1588 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1589 public bool HasClauseCleanupLbdTier1 {
1590 get {
return (_hasBits8 & -2147483648) != 0; }
1593 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1594 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1596 _hasBits8 &= ~-2147483648;
1601 private readonly
static int ClauseCleanupLbdTier2DefaultValue = 0;
1603 private int clauseCleanupLbdTier2_;
1610 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1611 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1613 get {
if ((_hasBits9 & 1) != 0) {
return clauseCleanupLbdTier2_; }
else {
return ClauseCleanupLbdTier2DefaultValue; } }
1616 clauseCleanupLbdTier2_ = value;
1620 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1621 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1622 public bool HasClauseCleanupLbdTier2 {
1623 get {
return (_hasBits9 & 1) != 0; }
1626 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1627 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1634 private readonly
static global::Google.OrTools.Sat.SatParameters.Types.ClauseOrdering ClauseCleanupOrderingDefaultValue = global::Google.OrTools.Sat.SatParameters.Types.ClauseOrdering.ClauseActivity;
1636 private global::Google.OrTools.Sat.SatParameters.Types.ClauseOrdering clauseCleanupOrdering_;
1637 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1638 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1640 get { if ((_hasBits1 & 32) != 0) { return clauseCleanupOrdering_; } else { return ClauseCleanupOrderingDefaultValue; } }
1643 clauseCleanupOrdering_ = value;
1647 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1648 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1649 public bool HasClauseCleanupOrdering {
1650 get {
return (_hasBits1 & 32) != 0; }
1653 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1654 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1661 private readonly
static int PbCleanupIncrementDefaultValue = 200;
1663 private int pbCleanupIncrement_;
1667 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1668 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1670 get {
if ((_hasBits0 & 16777216) != 0) {
return pbCleanupIncrement_; }
else {
return PbCleanupIncrementDefaultValue; } }
1672 _hasBits0 |= 16777216;
1673 pbCleanupIncrement_ = value;
1677 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1678 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1679 public bool HasPbCleanupIncrement {
1680 get {
return (_hasBits0 & 16777216) != 0; }
1683 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1684 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1686 _hasBits0 &= ~16777216;
1691 private readonly
static double PbCleanupRatioDefaultValue = 0.5D;
1693 private double pbCleanupRatio_;
1694 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1695 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1697 get {
if ((_hasBits0 & 33554432) != 0) {
return pbCleanupRatio_; }
else {
return PbCleanupRatioDefaultValue; } }
1699 _hasBits0 |= 33554432;
1700 pbCleanupRatio_ = value;
1704 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1705 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1706 public bool HasPbCleanupRatio {
1707 get {
return (_hasBits0 & 33554432) != 0; }
1710 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1711 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1713 _hasBits0 &= ~33554432;
1718 private readonly
static double VariableActivityDecayDefaultValue = 0.8D;
1720 private double variableActivityDecay_;
1731 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1732 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1734 get {
if ((_hasBits0 & 32) != 0) {
return variableActivityDecay_; }
else {
return VariableActivityDecayDefaultValue; } }
1737 variableActivityDecay_ = value;
1741 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1742 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1743 public bool HasVariableActivityDecay {
1744 get {
return (_hasBits0 & 32) != 0; }
1747 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1748 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1755 private readonly
static double MaxVariableActivityValueDefaultValue = 1e+100D;
1757 private double maxVariableActivityValue_;
1758 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1759 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1761 get {
if ((_hasBits0 & 64) != 0) {
return maxVariableActivityValue_; }
else {
return MaxVariableActivityValueDefaultValue; } }
1764 maxVariableActivityValue_ = value;
1768 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1769 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1770 public bool HasMaxVariableActivityValue {
1771 get {
return (_hasBits0 & 64) != 0; }
1774 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1775 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1782 private readonly
static double GlucoseMaxDecayDefaultValue = 0.95D;
1784 private double glucoseMaxDecay_;
1792 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1793 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1795 get {
if ((_hasBits0 & 512) != 0) {
return glucoseMaxDecay_; }
else {
return GlucoseMaxDecayDefaultValue; } }
1798 glucoseMaxDecay_ = value;
1802 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1803 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1804 public bool HasGlucoseMaxDecay {
1805 get {
return (_hasBits0 & 512) != 0; }
1808 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1809 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1815 public const int GlucoseDecayIncrementFieldNumber = 23;
1816 private readonly
static double GlucoseDecayIncrementDefaultValue = 0.01D;
1818 private double glucoseDecayIncrement_;
1819 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1820 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1822 get {
if ((_hasBits0 & 1024) != 0) {
return glucoseDecayIncrement_; }
else {
return GlucoseDecayIncrementDefaultValue; } }
1825 glucoseDecayIncrement_ = value;
1829 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1830 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1831 public bool HasGlucoseDecayIncrement {
1832 get {
return (_hasBits0 & 1024) != 0; }
1835 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1836 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1842 public const int GlucoseDecayIncrementPeriodFieldNumber = 24;
1843 private readonly
static int GlucoseDecayIncrementPeriodDefaultValue = 5000;
1845 private int glucoseDecayIncrementPeriod_;
1846 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1847 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1849 get {
if ((_hasBits0 & 2048) != 0) {
return glucoseDecayIncrementPeriod_; }
else {
return GlucoseDecayIncrementPeriodDefaultValue; } }
1852 glucoseDecayIncrementPeriod_ = value;
1856 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1857 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1858 public bool HasGlucoseDecayIncrementPeriod {
1859 get {
return (_hasBits0 & 2048) != 0; }
1862 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1863 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1869 public const int ClauseActivityDecayFieldNumber = 17;
1870 private readonly
static double ClauseActivityDecayDefaultValue = 0.999D;
1872 private double clauseActivityDecay_;
1876 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1877 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1879 get {
if ((_hasBits0 & 128) != 0) {
return clauseActivityDecay_; }
else {
return ClauseActivityDecayDefaultValue; } }
1882 clauseActivityDecay_ = value;
1886 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1887 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1888 public bool HasClauseActivityDecay {
1889 get {
return (_hasBits0 & 128) != 0; }
1892 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1893 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1899 public const int MaxClauseActivityValueFieldNumber = 18;
1900 private readonly
static double MaxClauseActivityValueDefaultValue = 1e+20D;
1902 private double maxClauseActivityValue_;
1903 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1904 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1906 get {
if ((_hasBits0 & 256) != 0) {
return maxClauseActivityValue_; }
else {
return MaxClauseActivityValueDefaultValue; } }
1909 maxClauseActivityValue_ = value;
1913 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1914 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1915 public bool HasMaxClauseActivityValue {
1916 get {
return (_hasBits0 & 256) != 0; }
1919 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1920 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1926 public const int RestartAlgorithmsFieldNumber = 61;
1927 private static readonly pb::FieldCodec<global::Google.OrTools.Sat.SatParameters.Types.RestartAlgorithm> _repeated_restartAlgorithms_codec
1929 private readonly pbc::RepeatedField<global::Google.OrTools.Sat.SatParameters.Types.RestartAlgorithm> restartAlgorithms_ =
new pbc::RepeatedField<global::Google.OrTools.Sat.SatParameters.Types.RestartAlgorithm>();
1941 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1942 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1943 public pbc::RepeatedField<global::Google.OrTools.Sat.SatParameters.Types.RestartAlgorithm>
RestartAlgorithms {
1944 get { return restartAlgorithms_; }
1948 public const int DefaultRestartAlgorithmsFieldNumber = 70;
1949 private readonly
static string DefaultRestartAlgorithmsDefaultValue = global::System.Text.Encoding.UTF8.GetString(global::System.Convert.FromBase64String(
"TFVCWV9SRVNUQVJULExCRF9NT1ZJTkdfQVZFUkFHRV9SRVNUQVJULERMX01PVklOR19BVkVSQUdFX1JFU1RBUlQ="), 0, 65);
1951 private string defaultRestartAlgorithms_;
1952 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1953 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1955 get { return defaultRestartAlgorithms_ ?? DefaultRestartAlgorithmsDefaultValue; }
1957 defaultRestartAlgorithms_ = pb::ProtoPreconditions.CheckNotNull(value,
"value");
1961 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1962 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1964 get {
return defaultRestartAlgorithms_ !=
null; }
1967 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1968 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1969 public void ClearDefaultRestartAlgorithms() {
1970 defaultRestartAlgorithms_ =
null;
1974 public const int RestartPeriodFieldNumber = 30;
1975 private readonly
static int RestartPeriodDefaultValue = 50;
1977 private int restartPeriod_;
1982 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1983 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1985 get {
if ((_hasBits0 & 4096) != 0) {
return restartPeriod_; }
else {
return RestartPeriodDefaultValue; } }
1988 restartPeriod_ = value;
1992 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1993 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1995 get {
return (_hasBits0 & 4096) != 0; }
1998 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1999 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2000 public void ClearRestartPeriod() {
2005 public const int RestartRunningWindowSizeFieldNumber = 62;
2006 private readonly
static int RestartRunningWindowSizeDefaultValue = 50;
2008 private int restartRunningWindowSize_;
2012 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2013 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2015 get {
if ((_hasBits1 & 64) != 0) {
return restartRunningWindowSize_; }
else {
return RestartRunningWindowSizeDefaultValue; } }
2018 restartRunningWindowSize_ = value;
2022 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2023 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2025 get {
return (_hasBits1 & 64) != 0; }
2028 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2029 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2030 public void ClearRestartRunningWindowSize() {
2035 public const int RestartDlAverageRatioFieldNumber = 63;
2036 private readonly
static double RestartDlAverageRatioDefaultValue = 1D;
2038 private double restartDlAverageRatio_;
2043 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2044 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2046 get {
if ((_hasBits1 & 128) != 0) {
return restartDlAverageRatio_; }
else {
return RestartDlAverageRatioDefaultValue; } }
2049 restartDlAverageRatio_ = value;
2053 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2054 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2056 get {
return (_hasBits1 & 128) != 0; }
2059 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2060 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2061 public void ClearRestartDlAverageRatio() {
2066 public const int RestartLbdAverageRatioFieldNumber = 71;
2067 private readonly
static double RestartLbdAverageRatioDefaultValue = 1D;
2069 private double restartLbdAverageRatio_;
2070 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2071 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2073 get {
if ((_hasBits1 & 16384) != 0) {
return restartLbdAverageRatio_; }
else {
return RestartLbdAverageRatioDefaultValue; } }
2076 restartLbdAverageRatio_ = value;
2080 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2081 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2083 get {
return (_hasBits1 & 16384) != 0; }
2086 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2087 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2088 public void ClearRestartLbdAverageRatio() {
2089 _hasBits1 &= ~16384;
2093 public const int UseBlockingRestartFieldNumber = 64;
2094 private readonly
static bool UseBlockingRestartDefaultValue =
false;
2096 private bool useBlockingRestart_;
2102 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2103 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2105 get {
if ((_hasBits1 & 256) != 0) {
return useBlockingRestart_; }
else {
return UseBlockingRestartDefaultValue; } }
2108 useBlockingRestart_ = value;
2112 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2113 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2115 get {
return (_hasBits1 & 256) != 0; }
2118 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2119 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2120 public void ClearUseBlockingRestart() {
2125 public const int BlockingRestartWindowSizeFieldNumber = 65;
2126 private readonly
static int BlockingRestartWindowSizeDefaultValue = 5000;
2128 private int blockingRestartWindowSize_;
2129 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2130 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2132 get {
if ((_hasBits1 & 512) != 0) {
return blockingRestartWindowSize_; }
else {
return BlockingRestartWindowSizeDefaultValue; } }
2135 blockingRestartWindowSize_ = value;
2139 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2140 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2142 get {
return (_hasBits1 & 512) != 0; }
2145 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2146 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2147 public void ClearBlockingRestartWindowSize() {
2152 public const int BlockingRestartMultiplierFieldNumber = 66;
2153 private readonly
static double BlockingRestartMultiplierDefaultValue = 1.4D;
2155 private double blockingRestartMultiplier_;
2156 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2157 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2159 get {
if ((_hasBits1 & 1024) != 0) {
return blockingRestartMultiplier_; }
else {
return BlockingRestartMultiplierDefaultValue; } }
2162 blockingRestartMultiplier_ = value;
2166 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2167 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2169 get {
return (_hasBits1 & 1024) != 0; }
2172 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2173 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2174 public void ClearBlockingRestartMultiplier() {
2179 public const int NumConflictsBeforeStrategyChangesFieldNumber = 68;
2180 private readonly
static int NumConflictsBeforeStrategyChangesDefaultValue = 0;
2182 private int numConflictsBeforeStrategyChanges_;
2188 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2189 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2191 get {
if ((_hasBits1 & 4096) != 0) {
return numConflictsBeforeStrategyChanges_; }
else {
return NumConflictsBeforeStrategyChangesDefaultValue; } }
2194 numConflictsBeforeStrategyChanges_ = value;
2198 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2199 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2201 get {
return (_hasBits1 & 4096) != 0; }
2204 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2205 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2206 public void ClearNumConflictsBeforeStrategyChanges() {
2211 public const int StrategyChangeIncreaseRatioFieldNumber = 69;
2212 private readonly
static double StrategyChangeIncreaseRatioDefaultValue = 0D;
2214 private double strategyChangeIncreaseRatio_;
2219 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2220 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2222 get {
if ((_hasBits1 & 8192) != 0) {
return strategyChangeIncreaseRatio_; }
else {
return StrategyChangeIncreaseRatioDefaultValue; } }
2225 strategyChangeIncreaseRatio_ = value;
2229 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2230 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2232 get {
return (_hasBits1 & 8192) != 0; }
2235 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2236 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2237 public void ClearStrategyChangeIncreaseRatio() {
2242 public const int MaxTimeInSecondsFieldNumber = 36;
2243 private readonly
static double MaxTimeInSecondsDefaultValue =
double.PositiveInfinity;
2245 private double maxTimeInSeconds_;
2250 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2251 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2253 get {
if ((_hasBits0 & 131072) != 0) {
return maxTimeInSeconds_; }
else {
return MaxTimeInSecondsDefaultValue; } }
2255 _hasBits0 |= 131072;
2256 maxTimeInSeconds_ = value;
2260 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2261 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2263 get {
return (_hasBits0 & 131072) != 0; }
2266 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2267 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2268 public void ClearMaxTimeInSeconds() {
2269 _hasBits0 &= ~131072;
2273 public const int MaxDeterministicTimeFieldNumber = 67;
2274 private readonly
static double MaxDeterministicTimeDefaultValue =
double.PositiveInfinity;
2276 private double maxDeterministicTime_;
2282 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2283 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2285 get {
if ((_hasBits1 & 2048) != 0) {
return maxDeterministicTime_; }
else {
return MaxDeterministicTimeDefaultValue; } }
2288 maxDeterministicTime_ = value;
2292 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2293 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2295 get {
return (_hasBits1 & 2048) != 0; }
2298 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2299 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2300 public void ClearMaxDeterministicTime() {
2305 public const int MaxNumDeterministicBatchesFieldNumber = 291;
2306 private readonly
static int MaxNumDeterministicBatchesDefaultValue = 0;
2308 private int maxNumDeterministicBatches_;
2313 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2314 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2316 get {
if ((_hasBits7 & 512) != 0) {
return maxNumDeterministicBatches_; }
else {
return MaxNumDeterministicBatchesDefaultValue; } }
2319 maxNumDeterministicBatches_ = value;
2323 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2324 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2326 get {
return (_hasBits7 & 512) != 0; }
2329 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2330 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2331 public void ClearMaxNumDeterministicBatches() {
2336 public const int MaxNumberOfConflictsFieldNumber = 37;
2337 private readonly
static long MaxNumberOfConflictsDefaultValue = 9223372036854775807L;
2339 private long maxNumberOfConflicts_;
2349 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2350 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2352 get {
if ((_hasBits0 & 262144) != 0) {
return maxNumberOfConflicts_; }
else {
return MaxNumberOfConflictsDefaultValue; } }
2354 _hasBits0 |= 262144;
2355 maxNumberOfConflicts_ = value;
2359 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2360 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2362 get {
return (_hasBits0 & 262144) != 0; }
2365 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2366 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2367 public void ClearMaxNumberOfConflicts() {
2368 _hasBits0 &= ~262144;
2372 public const int MaxMemoryInMbFieldNumber = 40;
2373 private readonly
static long MaxMemoryInMbDefaultValue = 10000L;
2375 private long maxMemoryInMb_;
2384 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2385 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2387 get {
if ((_hasBits0 & 524288) != 0) {
return maxMemoryInMb_; }
else {
return MaxMemoryInMbDefaultValue; } }
2389 _hasBits0 |= 524288;
2390 maxMemoryInMb_ = value;
2394 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2395 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2397 get {
return (_hasBits0 & 524288) != 0; }
2400 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2401 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2402 public void ClearMaxMemoryInMb() {
2403 _hasBits0 &= ~524288;
2408 private readonly
static double AbsoluteGapLimitDefaultValue = 0.0001D;
2410 private double absoluteGapLimit_;
2431 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2432 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2434 get {
if ((_hasBits3 & 16777216) != 0) {
return absoluteGapLimit_; }
else {
return AbsoluteGapLimitDefaultValue; } }
2436 _hasBits3 |= 16777216;
2437 absoluteGapLimit_ = value;
2441 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2442 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2443 public bool HasAbsoluteGapLimit {
2444 get {
return (_hasBits3 & 16777216) != 0; }
2447 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2448 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2449 public void ClearAbsoluteGapLimit() {
2450 _hasBits3 &= ~16777216;
2454 public const int RelativeGapLimitFieldNumber = 160;
2455 private readonly
static double RelativeGapLimitDefaultValue = 0D;
2457 private double relativeGapLimit_;
2458 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2459 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2461 get {
if ((_hasBits3 & 33554432) != 0) {
return relativeGapLimit_; }
else {
return RelativeGapLimitDefaultValue; } }
2463 _hasBits3 |= 33554432;
2464 relativeGapLimit_ = value;
2468 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2469 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2470 public bool HasRelativeGapLimit {
2471 get {
return (_hasBits3 & 33554432) != 0; }
2474 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2475 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2476 public void ClearRelativeGapLimit() {
2477 _hasBits3 &= ~33554432;
2481 public const int RandomSeedFieldNumber = 31;
2482 private readonly
static int RandomSeedDefaultValue = 1;
2484 private int randomSeed_;
2494 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2495 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2497 get {
if ((_hasBits0 & 8192) != 0) {
return randomSeed_; }
else {
return RandomSeedDefaultValue; } }
2500 randomSeed_ = value;
2504 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2505 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2506 public bool HasRandomSeed {
2507 get {
return (_hasBits0 & 8192) != 0; }
2510 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2511 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2517 public const int PermuteVariableRandomlyFieldNumber = 178;
2518 private readonly
static bool PermuteVariableRandomlyDefaultValue =
false;
2520 private bool permuteVariableRandomly_;
2527 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2528 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2530 get {
if ((_hasBits4 & 1024) != 0) {
return permuteVariableRandomly_; }
else {
return PermuteVariableRandomlyDefaultValue; } }
2533 permuteVariableRandomly_ = value;
2537 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2538 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2539 public bool HasPermuteVariableRandomly {
2540 get {
return (_hasBits4 & 1024) != 0; }
2543 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2544 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2550 public const int PermutePresolveConstraintOrderFieldNumber = 179;
2551 private readonly
static bool PermutePresolveConstraintOrderDefaultValue =
false;
2553 private bool permutePresolveConstraintOrder_;
2554 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2555 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2557 get {
if ((_hasBits4 & 2048) != 0) {
return permutePresolveConstraintOrder_; }
else {
return PermutePresolveConstraintOrderDefaultValue; } }
2560 permutePresolveConstraintOrder_ = value;
2564 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2565 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2567 get {
return (_hasBits4 & 2048) != 0; }
2570 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2571 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2577 public const int UseAbslRandomFieldNumber = 180;
2578 private readonly
static bool UseAbslRandomDefaultValue =
false;
2580 private bool useAbslRandom_;
2581 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2582 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2584 get {
if ((_hasBits4 & 4096) != 0) {
return useAbslRandom_; }
else {
return UseAbslRandomDefaultValue; } }
2587 useAbslRandom_ = value;
2591 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2592 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2594 get {
return (_hasBits4 & 4096) != 0; }
2597 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2598 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2604 public const int LogSearchProgressFieldNumber = 41;
2605 private readonly
static bool LogSearchProgressDefaultValue =
false;
2607 private bool logSearchProgress_;
2613 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2614 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2616 get {
if ((_hasBits0 & 1048576) != 0) {
return logSearchProgress_; }
else {
return LogSearchProgressDefaultValue; } }
2618 _hasBits0 |= 1048576;
2619 logSearchProgress_ = value;
2623 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2624 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2625 public bool HasLogSearchProgress {
2626 get {
return (_hasBits0 & 1048576) != 0; }
2629 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2630 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2632 _hasBits0 &= ~1048576;
2636 public const int LogSubsolverStatisticsFieldNumber = 189;
2637 private readonly
static bool LogSubsolverStatisticsDefaultValue =
false;
2639 private bool logSubsolverStatistics_;
2646 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2647 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2649 get {
if ((_hasBits4 & 524288) != 0) {
return logSubsolverStatistics_; }
else {
return LogSubsolverStatisticsDefaultValue; } }
2651 _hasBits4 |= 524288;
2652 logSubsolverStatistics_ = value;
2656 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2657 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2658 public bool HasLogSubsolverStatistics {
2659 get {
return (_hasBits4 & 524288) != 0; }
2662 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2663 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2665 _hasBits4 &= ~524288;
2669 public const int LogPrefixFieldNumber = 185;
2670 private readonly
static string LogPrefixDefaultValue =
"";
2672 private string logPrefix_;
2676 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2677 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2679 get {
return logPrefix_ ?? LogPrefixDefaultValue; }
2681 logPrefix_ = pb::ProtoPreconditions.CheckNotNull(value,
"value");
2685 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2686 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2687 public bool HasLogPrefix {
2688 get {
return logPrefix_ !=
null; }
2691 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2692 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2698 public const int LogToStdoutFieldNumber = 186;
2699 private readonly
static bool LogToStdoutDefaultValue =
true;
2701 private bool logToStdout_;
2705 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2706 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2708 get {
if ((_hasBits4 & 65536) != 0) {
return logToStdout_; }
else {
return LogToStdoutDefaultValue; } }
2711 logToStdout_ = value;
2715 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2716 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2717 public bool HasLogToStdout {
2718 get {
return (_hasBits4 & 65536) != 0; }
2721 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2722 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2724 _hasBits4 &= ~65536;
2728 public const int LogToResponseFieldNumber = 187;
2729 private readonly
static bool LogToResponseDefaultValue =
false;
2731 private bool logToResponse_;
2735 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2736 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2738 get {
if ((_hasBits4 & 131072) != 0) {
return logToResponse_; }
else {
return LogToResponseDefaultValue; } }
2740 _hasBits4 |= 131072;
2741 logToResponse_ = value;
2745 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2746 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2747 public bool HasLogToResponse {
2748 get {
return (_hasBits4 & 131072) != 0; }
2751 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2752 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2754 _hasBits4 &= ~131072;
2758 public const int UsePbResolutionFieldNumber = 43;
2759 private readonly
static bool UsePbResolutionDefaultValue =
false;
2761 private bool usePbResolution_;
2775 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2776 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2778 get {
if ((_hasBits0 & 2097152) != 0) {
return usePbResolution_; }
else {
return UsePbResolutionDefaultValue; } }
2780 _hasBits0 |= 2097152;
2781 usePbResolution_ = value;
2785 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2786 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2787 public bool HasUsePbResolution {
2788 get {
return (_hasBits0 & 2097152) != 0; }
2791 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2792 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2794 _hasBits0 &= ~2097152;
2798 public const int MinimizeReductionDuringPbResolutionFieldNumber = 48;
2799 private readonly
static bool MinimizeReductionDuringPbResolutionDefaultValue =
false;
2801 private bool minimizeReductionDuringPbResolution_;
2808 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2809 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2811 get {
if ((_hasBits0 & 67108864) != 0) {
return minimizeReductionDuringPbResolution_; }
else {
return MinimizeReductionDuringPbResolutionDefaultValue; } }
2813 _hasBits0 |= 67108864;
2814 minimizeReductionDuringPbResolution_ = value;
2818 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2819 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2820 public bool HasMinimizeReductionDuringPbResolution {
2821 get {
return (_hasBits0 & 67108864) != 0; }
2824 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2825 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2827 _hasBits0 &= ~67108864;
2831 public const int CountAssumptionLevelsInLbdFieldNumber = 49;
2832 private readonly
static bool CountAssumptionLevelsInLbdDefaultValue =
true;
2834 private bool countAssumptionLevelsInLbd_;
2846 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2847 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2849 get {
if ((_hasBits0 & 134217728) != 0) {
return countAssumptionLevelsInLbd_; }
else {
return CountAssumptionLevelsInLbdDefaultValue; } }
2851 _hasBits0 |= 134217728;
2852 countAssumptionLevelsInLbd_ = value;
2856 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2857 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2858 public bool HasCountAssumptionLevelsInLbd {
2859 get {
return (_hasBits0 & 134217728) != 0; }
2862 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2863 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2865 _hasBits0 &= ~134217728;
2869 public const int PresolveBveThresholdFieldNumber = 54;
2870 private readonly
static int PresolveBveThresholdDefaultValue = 500;
2872 private int presolveBveThreshold_;
2878 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2879 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2881 get {
if ((_hasBits1 & 1) != 0) {
return presolveBveThreshold_; }
else {
return PresolveBveThresholdDefaultValue; } }
2884 presolveBveThreshold_ = value;
2888 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2889 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2890 public bool HasPresolveBveThreshold {
2891 get {
return (_hasBits1 & 1) != 0; }
2894 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2895 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2901 public const int FilterSatPostsolveClausesFieldNumber = 324;
2902 private readonly
static bool FilterSatPostsolveClausesDefaultValue =
false;
2904 private bool filterSatPostsolveClauses_;
2914 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2915 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2917 get {
if ((_hasBits8 & 256) != 0) {
return filterSatPostsolveClauses_; }
else {
return FilterSatPostsolveClausesDefaultValue; } }
2920 filterSatPostsolveClauses_ = value;
2924 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2925 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2926 public bool HasFilterSatPostsolveClauses {
2927 get {
return (_hasBits8 & 256) != 0; }
2930 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2931 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2937 public const int PresolveBveClauseWeightFieldNumber = 55;
2938 private readonly
static int PresolveBveClauseWeightDefaultValue = 3;
2940 private int presolveBveClauseWeight_;
2945 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2946 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2948 get {
if ((_hasBits1 & 2) != 0) {
return presolveBveClauseWeight_; }
else {
return PresolveBveClauseWeightDefaultValue; } }
2951 presolveBveClauseWeight_ = value;
2955 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2956 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2957 public bool HasPresolveBveClauseWeight {
2958 get {
return (_hasBits1 & 2) != 0; }
2961 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2962 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2968 public const int ProbingDeterministicTimeLimitFieldNumber = 226;
2969 private readonly
static double ProbingDeterministicTimeLimitDefaultValue = 1D;
2971 private double probingDeterministicTimeLimit_;
2979 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2980 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2982 get {
if ((_hasBits5 & 65536) != 0) {
return probingDeterministicTimeLimit_; }
else {
return ProbingDeterministicTimeLimitDefaultValue; } }
2985 probingDeterministicTimeLimit_ = value;
2989 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2990 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2991 public bool HasProbingDeterministicTimeLimit {
2992 get {
return (_hasBits5 & 65536) != 0; }
2995 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2996 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2997 public void ClearProbingDeterministicTimeLimit() {
2998 _hasBits5 &= ~65536;
3002 public const int PresolveProbingDeterministicTimeLimitFieldNumber = 57;
3003 private readonly
static double PresolveProbingDeterministicTimeLimitDefaultValue = 30D;
3005 private double presolveProbingDeterministicTimeLimit_;
3006 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3007 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3009 get {
if ((_hasBits1 & 8) != 0) {
return presolveProbingDeterministicTimeLimit_; }
else {
return PresolveProbingDeterministicTimeLimitDefaultValue; } }
3012 presolveProbingDeterministicTimeLimit_ = value;
3016 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3017 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3018 public bool HasPresolveProbingDeterministicTimeLimit {
3019 get {
return (_hasBits1 & 8) != 0; }
3022 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3023 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3024 public void ClearPresolveProbingDeterministicTimeLimit() {
3029 public const int PresolveBlockedClauseFieldNumber = 88;
3030 private readonly
static bool PresolveBlockedClauseDefaultValue =
true;
3032 private bool presolveBlockedClause_;
3037 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3038 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3040 get {
if ((_hasBits1 & 1073741824) != 0) {
return presolveBlockedClause_; }
else {
return PresolveBlockedClauseDefaultValue; } }
3042 _hasBits1 |= 1073741824;
3043 presolveBlockedClause_ = value;
3047 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3048 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3050 get {
return (_hasBits1 & 1073741824) != 0; }
3053 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3054 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3055 public void ClearPresolveBlockedClause() {
3056 _hasBits1 &= ~1073741824;
3060 public const int PresolveUseBvaFieldNumber = 72;
3061 private readonly
static bool PresolveUseBvaDefaultValue =
true;
3063 private bool presolveUseBva_;
3067 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3068 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3070 get {
if ((_hasBits1 & 32768) != 0) {
return presolveUseBva_; }
else {
return PresolveUseBvaDefaultValue; } }
3073 presolveUseBva_ = value;
3077 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3078 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3080 get {
return (_hasBits1 & 32768) != 0; }
3083 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3084 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3085 public void ClearPresolveUseBva() {
3086 _hasBits1 &= ~32768;
3090 public const int PresolveBvaThresholdFieldNumber = 73;
3091 private readonly
static int PresolveBvaThresholdDefaultValue = 1;
3093 private int presolveBvaThreshold_;
3100 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3101 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3103 get {
if ((_hasBits1 & 65536) != 0) {
return presolveBvaThreshold_; }
else {
return PresolveBvaThresholdDefaultValue; } }
3106 presolveBvaThreshold_ = value;
3110 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3111 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3112 public bool HasPresolveBvaThreshold {
3113 get {
return (_hasBits1 & 65536) != 0; }
3116 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3117 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3118 public void ClearPresolveBvaThreshold() {
3119 _hasBits1 &= ~65536;
3123 public const int MaxPresolveIterationsFieldNumber = 138;
3124 private readonly
static int MaxPresolveIterationsDefaultValue = 3;
3126 private int maxPresolveIterations_;
3132 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3133 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3135 get {
if ((_hasBits3 & 1024) != 0) {
return maxPresolveIterations_; }
else {
return MaxPresolveIterationsDefaultValue; } }
3138 maxPresolveIterations_ = value;
3142 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3143 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3144 public bool HasMaxPresolveIterations {
3145 get {
return (_hasBits3 & 1024) != 0; }
3148 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3149 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3150 public void ClearMaxPresolveIterations() {
3155 public const int CpModelPresolveFieldNumber = 86;
3156 private readonly
static bool CpModelPresolveDefaultValue =
true;
3158 private bool cpModelPresolve_;
3162 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3163 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3165 get {
if ((_hasBits1 & 268435456) != 0) {
return cpModelPresolve_; }
else {
return CpModelPresolveDefaultValue; } }
3167 _hasBits1 |= 268435456;
3168 cpModelPresolve_ = value;
3172 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3173 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3175 get {
return (_hasBits1 & 268435456) != 0; }
3178 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3179 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3180 public void ClearCpModelPresolve() {
3181 _hasBits1 &= ~268435456;
3185 public const int CpModelProbingLevelFieldNumber = 110;
3186 private readonly
static int CpModelProbingLevelDefaultValue = 2;
3188 private int cpModelProbingLevel_;
3192 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3193 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3195 get {
if ((_hasBits2 & 65536) != 0) {
return cpModelProbingLevel_; }
else {
return CpModelProbingLevelDefaultValue; } }
3198 cpModelProbingLevel_ = value;
3202 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3203 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3205 get {
return (_hasBits2 & 65536) != 0; }
3208 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3209 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3210 public void ClearCpModelProbingLevel() {
3211 _hasBits2 &= ~65536;
3215 public const int CpModelUseSatPresolveFieldNumber = 93;
3216 private readonly
static bool CpModelUseSatPresolveDefaultValue =
true;
3218 private bool cpModelUseSatPresolve_;
3222 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3223 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3225 get {
if ((_hasBits2 & 8) != 0) {
return cpModelUseSatPresolve_; }
else {
return CpModelUseSatPresolveDefaultValue; } }
3228 cpModelUseSatPresolve_ = value;
3232 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3233 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3235 get {
return (_hasBits2 & 8) != 0; }
3238 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3239 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3240 public void ClearCpModelUseSatPresolve() {
3245 public const int LoadAtMostOnesInSatPresolveFieldNumber = 335;
3246 private readonly
static bool LoadAtMostOnesInSatPresolveDefaultValue =
false;
3248 private bool loadAtMostOnesInSatPresolve_;
3257 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3258 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3260 get {
if ((_hasBits8 & 262144) != 0) {
return loadAtMostOnesInSatPresolve_; }
else {
return LoadAtMostOnesInSatPresolveDefaultValue; } }
3262 _hasBits8 |= 262144;
3263 loadAtMostOnesInSatPresolve_ = value;
3267 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3268 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3269 public bool HasLoadAtMostOnesInSatPresolve {
3270 get {
return (_hasBits8 & 262144) != 0; }
3273 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3274 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3275 public void ClearLoadAtMostOnesInSatPresolve() {
3276 _hasBits8 &= ~262144;
3280 public const int RemoveFixedVariablesEarlyFieldNumber = 310;
3281 private readonly
static bool RemoveFixedVariablesEarlyDefaultValue =
true;
3283 private bool removeFixedVariablesEarly_;
3290 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3291 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3293 get {
if ((_hasBits7 & 134217728) != 0) {
return removeFixedVariablesEarly_; }
else {
return RemoveFixedVariablesEarlyDefaultValue; } }
3295 _hasBits7 |= 134217728;
3296 removeFixedVariablesEarly_ = value;
3300 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3301 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3302 public bool HasRemoveFixedVariablesEarly {
3303 get {
return (_hasBits7 & 134217728) != 0; }
3306 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3307 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3308 public void ClearRemoveFixedVariablesEarly() {
3309 _hasBits7 &= ~134217728;
3313 public const int DetectTableWithCostFieldNumber = 216;
3314 private readonly
static bool DetectTableWithCostDefaultValue =
false;
3316 private bool detectTableWithCost_;
3325 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3326 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3328 get {
if ((_hasBits5 & 256) != 0) {
return detectTableWithCost_; }
else {
return DetectTableWithCostDefaultValue; } }
3331 detectTableWithCost_ = value;
3335 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3336 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3337 public bool HasDetectTableWithCost {
3338 get {
return (_hasBits5 & 256) != 0; }
3341 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3342 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3343 public void ClearDetectTableWithCost() {
3349 private readonly
static int TableCompressionLevelDefaultValue = 2;
3351 private int tableCompressionLevel_;
3358 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3359 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3361 get {
if ((_hasBits5 & 512) != 0) {
return tableCompressionLevel_; }
else {
return TableCompressionLevelDefaultValue; } }
3364 tableCompressionLevel_ = value;
3368 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3369 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3371 get {
return (_hasBits5 & 512) != 0; }
3374 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3375 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3376 public void ClearTableCompressionLevel() {
3382 private readonly
static bool ExpandAlldiffConstraintsDefaultValue =
false;
3384 private bool expandAlldiffConstraints_;
3389 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3390 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3392 get {
if ((_hasBits4 & 8) != 0) {
return expandAlldiffConstraints_; }
else {
return ExpandAlldiffConstraintsDefaultValue; } }
3395 expandAlldiffConstraints_ = value;
3399 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3400 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3402 get {
return (_hasBits4 & 8) != 0; }
3405 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3406 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3407 public void ClearExpandAlldiffConstraints() {
3413 private readonly
static int MaxAlldiffDomainSizeDefaultValue = 256;
3415 private int maxAlldiffDomainSize_;
3419 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3420 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3422 get {
if ((_hasBits8 & 16) != 0) {
return maxAlldiffDomainSize_; }
else {
return MaxAlldiffDomainSizeDefaultValue; } }
3425 maxAlldiffDomainSize_ = value;
3429 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3430 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3432 get {
return (_hasBits8 & 16) != 0; }
3435 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3436 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3437 public void ClearMaxAlldiffDomainSize() {
3443 private readonly
static bool ExpandReservoirConstraintsDefaultValue =
true;
3445 private bool expandReservoirConstraints_;
3450 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3451 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3453 get {
if ((_hasBits4 & 16384) != 0) {
return expandReservoirConstraints_; }
else {
return ExpandReservoirConstraintsDefaultValue; } }
3456 expandReservoirConstraints_ = value;
3460 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3461 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3463 get {
return (_hasBits4 & 16384) != 0; }
3466 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3467 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3468 public void ClearExpandReservoirConstraints() {
3469 _hasBits4 &= ~16384;
3474 private readonly
static int MaxDomainSizeForLinear2ExpansionDefaultValue = 8;
3476 private int maxDomainSizeForLinear2Expansion_;
3480 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3481 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3483 get {
if ((_hasBits8 & 4194304) != 0) {
return maxDomainSizeForLinear2Expansion_; }
else {
return MaxDomainSizeForLinear2ExpansionDefaultValue; } }
3485 _hasBits8 |= 4194304;
3486 maxDomainSizeForLinear2Expansion_ = value;
3490 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3491 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3493 get {
return (_hasBits8 & 4194304) != 0; }
3496 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3497 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3498 public void ClearMaxDomainSizeForLinear2Expansion() {
3499 _hasBits8 &= ~4194304;
3504 private readonly
static bool ExpandReservoirUsingCircuitDefaultValue =
false;
3506 private bool expandReservoirUsingCircuit_;
3523 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3524 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3526 get {
if ((_hasBits7 & 64) != 0) {
return expandReservoirUsingCircuit_; }
else {
return ExpandReservoirUsingCircuitDefaultValue; } }
3529 expandReservoirUsingCircuit_ = value;
3533 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3534 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3535 public bool HasExpandReservoirUsingCircuit {
3536 get {
return (_hasBits7 & 64) != 0; }
3539 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3540 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3541 public void ClearExpandReservoirUsingCircuit() {
3547 private readonly
static bool EncodeCumulativeAsReservoirDefaultValue =
false;
3549 private bool encodeCumulativeAsReservoir_;
3555 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3556 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3558 get {
if ((_hasBits7 & 32) != 0) {
return encodeCumulativeAsReservoir_; }
else {
return EncodeCumulativeAsReservoirDefaultValue; } }
3561 encodeCumulativeAsReservoir_ = value;
3565 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3566 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3568 get {
return (_hasBits7 & 32) != 0; }
3571 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3572 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3573 public void ClearEncodeCumulativeAsReservoir() {
3579 private readonly
static int MaxLinMaxSizeForExpansionDefaultValue = 0;
3581 private int maxLinMaxSizeForExpansion_;
3589 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3590 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3592 get {
if ((_hasBits6 & 1073741824) != 0) {
return maxLinMaxSizeForExpansion_; }
else {
return MaxLinMaxSizeForExpansionDefaultValue; } }
3594 _hasBits6 |= 1073741824;
3595 maxLinMaxSizeForExpansion_ = value;
3599 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3600 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3602 get {
return (_hasBits6 & 1073741824) != 0; }
3605 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3606 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3607 public void ClearMaxLinMaxSizeForExpansion() {
3608 _hasBits6 &= ~1073741824;
3612 public const int DisableConstraintExpansionFieldNumber = 181;
3613 private readonly
static bool DisableConstraintExpansionDefaultValue =
false;
3615 private bool disableConstraintExpansion_;
3620 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3621 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3623 get {
if ((_hasBits4 & 8192) != 0) {
return disableConstraintExpansion_; }
else {
return DisableConstraintExpansionDefaultValue; } }
3626 disableConstraintExpansion_ = value;
3630 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3631 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3633 get {
return (_hasBits4 & 8192) != 0; }
3636 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3637 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3638 public void ClearDisableConstraintExpansion() {
3643 public const int EncodeComplexLinearConstraintWithIntegerFieldNumber = 223;
3644 private readonly
static bool EncodeComplexLinearConstraintWithIntegerDefaultValue =
false;
3646 private bool encodeComplexLinearConstraintWithInteger_;
3651 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3652 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3654 get {
if ((_hasBits5 & 8192) != 0) {
return encodeComplexLinearConstraintWithInteger_; }
else {
return EncodeComplexLinearConstraintWithIntegerDefaultValue; } }
3657 encodeComplexLinearConstraintWithInteger_ = value;
3661 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3662 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3664 get {
return (_hasBits5 & 8192) != 0; }
3667 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3668 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3669 public void ClearEncodeComplexLinearConstraintWithInteger() {
3674 public const int MergeNoOverlapWorkLimitFieldNumber = 145;
3675 private readonly
static double MergeNoOverlapWorkLimitDefaultValue = 1e+12D;
3677 private double mergeNoOverlapWorkLimit_;
3685 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3686 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3688 get {
if ((_hasBits3 & 4096) != 0) {
return mergeNoOverlapWorkLimit_; }
else {
return MergeNoOverlapWorkLimitDefaultValue; } }
3691 mergeNoOverlapWorkLimit_ = value;
3695 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3696 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3698 get {
return (_hasBits3 & 4096) != 0; }
3701 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3702 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3703 public void ClearMergeNoOverlapWorkLimit() {
3708 public const int MergeAtMostOneWorkLimitFieldNumber = 146;
3709 private readonly
static double MergeAtMostOneWorkLimitDefaultValue = 1e+08D;
3711 private double mergeAtMostOneWorkLimit_;
3712 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3713 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3715 get {
if ((_hasBits3 & 8192) != 0) {
return mergeAtMostOneWorkLimit_; }
else {
return MergeAtMostOneWorkLimitDefaultValue; } }
3718 mergeAtMostOneWorkLimit_ = value;
3722 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3723 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3724 public bool HasMergeAtMostOneWorkLimit {
3725 get {
return (_hasBits3 & 8192) != 0; }
3728 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3729 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3735 public const int PresolveSubstitutionLevelFieldNumber = 147;
3736 private readonly
static int PresolveSubstitutionLevelDefaultValue = 1;
3738 private int presolveSubstitutionLevel_;
3745 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3746 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3748 get {
if ((_hasBits3 & 16384) != 0) {
return presolveSubstitutionLevel_; }
else {
return PresolveSubstitutionLevelDefaultValue; } }
3751 presolveSubstitutionLevel_ = value;
3755 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3756 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3758 get {
return (_hasBits3 & 16384) != 0; }
3761 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3762 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3763 public void ClearPresolveSubstitutionLevel() {
3764 _hasBits3 &= ~16384;
3768 public const int PresolveExtractIntegerEnforcementFieldNumber = 174;
3769 private readonly
static bool PresolveExtractIntegerEnforcementDefaultValue =
false;
3771 private bool presolveExtractIntegerEnforcement_;
3780 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3781 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3783 get {
if ((_hasBits4 & 64) != 0) {
return presolveExtractIntegerEnforcement_; }
else {
return PresolveExtractIntegerEnforcementDefaultValue; } }
3786 presolveExtractIntegerEnforcement_ = value;
3790 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3791 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3793 get {
return (_hasBits4 & 64) != 0; }
3796 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3797 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3798 public void ClearPresolveExtractIntegerEnforcement() {
3803 public const int PresolveInclusionWorkLimitFieldNumber = 201;
3804 private readonly
static long PresolveInclusionWorkLimitDefaultValue = 100000000L;
3806 private long presolveInclusionWorkLimit_;
3816 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3817 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3819 get {
if ((_hasBits4 & -2147483648) != 0) {
return presolveInclusionWorkLimit_; }
else {
return PresolveInclusionWorkLimitDefaultValue; } }
3821 _hasBits4 |= -2147483648;
3822 presolveInclusionWorkLimit_ = value;
3826 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3827 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3829 get {
return (_hasBits4 & -2147483648) != 0; }
3832 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3833 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3834 public void ClearPresolveInclusionWorkLimit() {
3835 _hasBits4 &= ~-2147483648;
3839 public const int IgnoreNamesFieldNumber = 202;
3840 private readonly
static bool IgnoreNamesDefaultValue =
true;
3842 private bool ignoreNames_;
3846 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3847 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3849 get {
if ((_hasBits5 & 1) != 0) {
return ignoreNames_; }
else {
return IgnoreNamesDefaultValue; } }
3852 ignoreNames_ = value;
3856 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3857 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3859 get {
return (_hasBits5 & 1) != 0; }
3862 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3863 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3869 public const int InferAllDiffsFieldNumber = 233;
3870 private readonly
static bool InferAllDiffsDefaultValue =
true;
3872 private bool inferAllDiffs_;
3883 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3884 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3886 get {
if ((_hasBits5 & 4194304) != 0) {
return inferAllDiffs_; }
else {
return InferAllDiffsDefaultValue; } }
3888 _hasBits5 |= 4194304;
3889 inferAllDiffs_ = value;
3893 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3894 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3896 get {
return (_hasBits5 & 4194304) != 0; }
3899 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3900 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3901 public void ClearInferAllDiffs() {
3902 _hasBits5 &= ~4194304;
3906 public const int FindBigLinearOverlapFieldNumber = 234;
3907 private readonly
static bool FindBigLinearOverlapDefaultValue =
true;
3909 private bool findBigLinearOverlap_;
3916 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3917 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3919 get {
if ((_hasBits5 & 8388608) != 0) {
return findBigLinearOverlap_; }
else {
return FindBigLinearOverlapDefaultValue; } }
3921 _hasBits5 |= 8388608;
3922 findBigLinearOverlap_ = value;
3926 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3927 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3929 get {
return (_hasBits5 & 8388608) != 0; }
3932 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3933 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3934 public void ClearFindBigLinearOverlap() {
3935 _hasBits5 &= ~8388608;
3939 public const int FindClausesThatAreExactlyOneFieldNumber = 333;
3940 private readonly
static bool FindClausesThatAreExactlyOneDefaultValue =
true;
3942 private bool findClausesThatAreExactlyOne_;
3950 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3951 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3953 get {
if ((_hasBits8 & 131072) != 0) {
return findClausesThatAreExactlyOne_; }
else {
return FindClausesThatAreExactlyOneDefaultValue; } }
3955 _hasBits8 |= 131072;
3956 findClausesThatAreExactlyOne_ = value;
3960 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3961 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3962 public bool HasFindClausesThatAreExactlyOne {
3963 get {
return (_hasBits8 & 131072) != 0; }
3966 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3967 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3968 public void ClearFindClausesThatAreExactlyOne() {
3969 _hasBits8 &= ~131072;
3973 public const int UseSatInprocessingFieldNumber = 163;
3974 private readonly
static bool UseSatInprocessingDefaultValue =
true;
3976 private bool useSatInprocessing_;
3981 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3982 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3984 get {
if ((_hasBits3 & 268435456) != 0) {
return useSatInprocessing_; }
else {
return UseSatInprocessingDefaultValue; } }
3986 _hasBits3 |= 268435456;
3987 useSatInprocessing_ = value;
3991 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3992 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3994 get {
return (_hasBits3 & 268435456) != 0; }
3997 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3998 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4000 _hasBits3 &= ~268435456;
4004 public const int InprocessingDtimeRatioFieldNumber = 273;
4005 private readonly
static double InprocessingDtimeRatioDefaultValue = 0.2D;
4007 private double inprocessingDtimeRatio_;
4013 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4014 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4016 get {
if ((_hasBits6 & 8388608) != 0) {
return inprocessingDtimeRatio_; }
else {
return InprocessingDtimeRatioDefaultValue; } }
4018 _hasBits6 |= 8388608;
4019 inprocessingDtimeRatio_ = value;
4023 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4024 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4026 get {
return (_hasBits6 & 8388608) != 0; }
4029 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4030 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4032 _hasBits6 &= ~8388608;
4036 public const int InprocessingProbingDtimeFieldNumber = 274;
4037 private readonly
static double InprocessingProbingDtimeDefaultValue = 1D;
4039 private double inprocessingProbingDtime_;
4043 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4044 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4046 get {
if ((_hasBits6 & 16777216) != 0) {
return inprocessingProbingDtime_; }
else {
return InprocessingProbingDtimeDefaultValue; } }
4048 _hasBits6 |= 16777216;
4049 inprocessingProbingDtime_ = value;
4053 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4054 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4056 get {
return (_hasBits6 & 16777216) != 0; }
4059 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4060 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4062 _hasBits6 &= ~16777216;
4066 public const int InprocessingMinimizationDtimeFieldNumber = 275;
4067 private readonly
static double InprocessingMinimizationDtimeDefaultValue = 1D;
4069 private double inprocessingMinimizationDtime_;
4082 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4083 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4085 get {
if ((_hasBits6 & 33554432) != 0) {
return inprocessingMinimizationDtime_; }
else {
return InprocessingMinimizationDtimeDefaultValue; } }
4087 _hasBits6 |= 33554432;
4088 inprocessingMinimizationDtime_ = value;
4092 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4093 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4094 public bool HasInprocessingMinimizationDtime {
4095 get {
return (_hasBits6 & 33554432) != 0; }
4098 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4099 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4100 public void ClearInprocessingMinimizationDtime() {
4101 _hasBits6 &= ~33554432;
4105 public const int InprocessingMinimizationUseConflictAnalysisFieldNumber = 297;
4106 private readonly
static bool InprocessingMinimizationUseConflictAnalysisDefaultValue =
true;
4108 private bool inprocessingMinimizationUseConflictAnalysis_;
4109 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4110 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4112 get {
if ((_hasBits7 & 16384) != 0) {
return inprocessingMinimizationUseConflictAnalysis_; }
else {
return InprocessingMinimizationUseConflictAnalysisDefaultValue; } }
4115 inprocessingMinimizationUseConflictAnalysis_ = value;
4119 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4120 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4122 get {
return (_hasBits7 & 16384) != 0; }
4125 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4126 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4128 _hasBits7 &= ~16384;
4133 private readonly
static bool InprocessingMinimizationUseAllOrderingsDefaultValue =
false;
4135 private bool inprocessingMinimizationUseAllOrderings_;
4136 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4137 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4139 get {
if ((_hasBits7 & 32768) != 0) {
return inprocessingMinimizationUseAllOrderings_; }
else {
return InprocessingMinimizationUseAllOrderingsDefaultValue; } }
4142 inprocessingMinimizationUseAllOrderings_ = value;
4146 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4147 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4149 get {
return (_hasBits7 & 32768) != 0; }
4152 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4153 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4155 _hasBits7 &= ~32768;
4160 private readonly
static bool InprocessingUseCongruenceClosureDefaultValue =
true;
4162 private bool inprocessingUseCongruenceClosure_;
4169 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4170 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4172 get {
if ((_hasBits8 & 16777216) != 0) {
return inprocessingUseCongruenceClosure_; }
else {
return InprocessingUseCongruenceClosureDefaultValue; } }
4174 _hasBits8 |= 16777216;
4175 inprocessingUseCongruenceClosure_ = value;
4179 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4180 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4182 get {
return (_hasBits8 & 16777216) != 0; }
4185 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4186 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4188 _hasBits8 &= ~16777216;
4192 public const int InprocessingUseSatSweepingFieldNumber = 354;
4193 private readonly
static bool InprocessingUseSatSweepingDefaultValue =
false;
4195 private bool inprocessingUseSatSweeping_;
4201 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4202 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4204 get {
if ((_hasBits9 & 16) != 0) {
return inprocessingUseSatSweeping_; }
else {
return InprocessingUseSatSweepingDefaultValue; } }
4207 inprocessingUseSatSweeping_ = value;
4211 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4212 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4213 public bool HasInprocessingUseSatSweeping {
4214 get {
return (_hasBits9 & 16) != 0; }
4217 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4218 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4224 public const int NumWorkersFieldNumber = 206;
4225 private readonly
static int NumWorkersDefaultValue = 0;
4227 private int numWorkers_;
4244 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4245 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4247 get {
if ((_hasBits5 & 16) != 0) {
return numWorkers_; }
else {
return NumWorkersDefaultValue; } }
4250 numWorkers_ = value;
4254 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4255 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4256 public bool HasNumWorkers {
4257 get {
return (_hasBits5 & 16) != 0; }
4260 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4261 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4262 public void ClearNumWorkers() {
4267 public const int NumSearchWorkersFieldNumber = 100;
4268 private readonly
static int NumSearchWorkersDefaultValue = 0;
4270 private int numSearchWorkers_;
4271 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4272 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4273 public int NumSearchWorkers {
4274 get {
if ((_hasBits2 & 256) != 0) {
return numSearchWorkers_; }
else {
return NumSearchWorkersDefaultValue; } }
4277 numSearchWorkers_ = value;
4281 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4282 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4283 public bool HasNumSearchWorkers {
4284 get {
return (_hasBits2 & 256) != 0; }
4287 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4288 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4295 private readonly
static int NumFullSubsolversDefaultValue = 0;
4297 private int numFullSubsolvers_;
4305 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4306 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4308 get {
if ((_hasBits7 & 2048) != 0) {
return numFullSubsolvers_; }
else {
return NumFullSubsolversDefaultValue; } }
4311 numFullSubsolvers_ = value;
4315 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4316 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4317 public bool HasNumFullSubsolvers {
4318 get {
return (_hasBits7 & 2048) != 0; }
4321 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4322 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4323 public void ClearNumFullSubsolvers() {
4328 public const int SubsolversFieldNumber = 207;
4329 private static readonly pb::FieldCodec<string> _repeated_subsolvers_codec
4330 = pb::FieldCodec.ForString(1658);
4331 private readonly pbc::RepeatedField<string> subsolvers_ =
new pbc::RepeatedField<string>();
4359 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4360 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4361 public pbc::RepeatedField<string>
Subsolvers {
4362 get {
return subsolvers_; }
4366 public const int ExtraSubsolversFieldNumber = 219;
4367 private static readonly pb::FieldCodec<string> _repeated_extraSubsolvers_codec
4368 = pb::FieldCodec.ForString(1754);
4369 private readonly pbc::RepeatedField<string> extraSubsolvers_ =
new pbc::RepeatedField<string>();
4374 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4375 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4376 public pbc::RepeatedField<string> ExtraSubsolvers {
4377 get {
return extraSubsolvers_; }
4381 public const int IgnoreSubsolversFieldNumber = 209;
4382 private static readonly pb::FieldCodec<string> _repeated_ignoreSubsolvers_codec
4383 = pb::FieldCodec.ForString(1674);
4384 private readonly pbc::RepeatedField<string> ignoreSubsolvers_ =
new pbc::RepeatedField<string>();
4396 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4397 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4399 get {
return ignoreSubsolvers_; }
4403 public const int FilterSubsolversFieldNumber = 293;
4404 private static readonly pb::FieldCodec<string> _repeated_filterSubsolvers_codec
4405 = pb::FieldCodec.ForString(2346);
4406 private readonly pbc::RepeatedField<string> filterSubsolvers_ =
new pbc::RepeatedField<string>();
4407 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4408 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4410 get {
return filterSubsolvers_; }
4415 private static readonly pb::FieldCodec<global::Google.OrTools.Sat.SatParameters> _repeated_subsolverParams_codec
4417 private readonly pbc::RepeatedField<global::Google.OrTools.Sat.SatParameters> subsolverParams_ =
new pbc::RepeatedField<global::Google.OrTools.Sat.SatParameters>();
4425 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4426 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4427 public pbc::RepeatedField<global::Google.OrTools.Sat.SatParameters>
SubsolverParams {
4428 get {
return subsolverParams_; }
4433 private readonly
static bool InterleaveSearchDefaultValue =
false;
4435 private bool interleaveSearch_;
4444 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4445 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4447 get {
if ((_hasBits3 & 256) != 0) {
return interleaveSearch_; }
else {
return InterleaveSearchDefaultValue; } }
4450 interleaveSearch_ = value;
4454 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4455 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4456 public bool HasInterleaveSearch {
4457 get {
return (_hasBits3 & 256) != 0; }
4460 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4461 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4468 private readonly
static int InterleaveBatchSizeDefaultValue = 0;
4470 private int interleaveBatchSize_;
4471 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4472 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4474 get {
if ((_hasBits3 & 64) != 0) {
return interleaveBatchSize_; }
else {
return InterleaveBatchSizeDefaultValue; } }
4477 interleaveBatchSize_ = value;
4481 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4482 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4484 get {
return (_hasBits3 & 64) != 0; }
4487 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4488 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4489 public void ClearInterleaveBatchSize() {
4494 public const int ShareObjectiveBoundsFieldNumber = 113;
4495 private readonly
static bool ShareObjectiveBoundsDefaultValue =
true;
4497 private bool shareObjectiveBounds_;
4501 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4502 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4504 get {
if ((_hasBits2 & 262144) != 0) {
return shareObjectiveBounds_; }
else {
return ShareObjectiveBoundsDefaultValue; } }
4506 _hasBits2 |= 262144;
4507 shareObjectiveBounds_ = value;
4511 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4512 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4513 public bool HasShareObjectiveBounds {
4514 get {
return (_hasBits2 & 262144) != 0; }
4517 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4518 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4520 _hasBits2 &= ~262144;
4525 private readonly
static bool ShareLevelZeroBoundsDefaultValue =
true;
4527 private bool shareLevelZeroBounds_;
4531 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4532 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4534 get {
if ((_hasBits2 & 524288) != 0) {
return shareLevelZeroBounds_; }
else {
return ShareLevelZeroBoundsDefaultValue; } }
4536 _hasBits2 |= 524288;
4537 shareLevelZeroBounds_ = value;
4541 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4542 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4543 public bool HasShareLevelZeroBounds {
4544 get {
return (_hasBits2 & 524288) != 0; }
4547 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4548 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4550 _hasBits2 &= ~524288;
4555 private readonly
static bool ShareLinear2BoundsDefaultValue =
false;
4557 private bool shareLinear2Bounds_;
4565 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4566 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4568 get {
if ((_hasBits8 & 1024) != 0) {
return shareLinear2Bounds_; }
else {
return ShareLinear2BoundsDefaultValue; } }
4571 shareLinear2Bounds_ = value;
4575 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4576 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4577 public bool HasShareLinear2Bounds {
4578 get {
return (_hasBits8 & 1024) != 0; }
4581 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4582 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4583 public void ClearShareLinear2Bounds() {
4588 public const int ShareBinaryClausesFieldNumber = 203;
4589 private readonly
static bool ShareBinaryClausesDefaultValue =
true;
4591 private bool shareBinaryClauses_;
4595 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4596 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4598 get {
if ((_hasBits5 & 2) != 0) {
return shareBinaryClauses_; }
else {
return ShareBinaryClausesDefaultValue; } }
4601 shareBinaryClauses_ = value;
4605 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4606 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4607 public bool HasShareBinaryClauses {
4608 get {
return (_hasBits5 & 2) != 0; }
4611 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4612 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4618 public const int ShareGlueClausesFieldNumber = 285;
4619 private readonly
static bool ShareGlueClausesDefaultValue =
true;
4621 private bool shareGlueClauses_;
4626 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4627 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4629 get {
if ((_hasBits7 & 8) != 0) {
return shareGlueClauses_; }
else {
return ShareGlueClausesDefaultValue; } }
4632 shareGlueClauses_ = value;
4636 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4637 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4638 public bool HasShareGlueClauses {
4639 get {
return (_hasBits7 & 8) != 0; }
4642 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4643 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4650 private readonly
static bool MinimizeSharedClausesDefaultValue =
true;
4652 private bool minimizeSharedClauses_;
4657 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4658 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4660 get {
if ((_hasBits7 & 131072) != 0) {
return minimizeSharedClauses_; }
else {
return MinimizeSharedClausesDefaultValue; } }
4662 _hasBits7 |= 131072;
4663 minimizeSharedClauses_ = value;
4667 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4668 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4669 public bool HasMinimizeSharedClauses {
4670 get {
return (_hasBits7 & 131072) != 0; }
4673 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4674 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4676 _hasBits7 &= ~131072;
4681 private readonly
static double ShareGlueClausesDtimeDefaultValue = 1D;
4683 private double shareGlueClausesDtime_;
4687 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4688 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4690 get {
if ((_hasBits8 & 64) != 0) {
return shareGlueClausesDtime_; }
else {
return ShareGlueClausesDtimeDefaultValue; } }
4693 shareGlueClausesDtime_ = value;
4697 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4698 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4699 public bool HasShareGlueClausesDtime {
4700 get {
return (_hasBits8 & 64) != 0; }
4703 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4704 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4710 public const int CheckLratProofFieldNumber = 344;
4711 private readonly
static bool CheckLratProofDefaultValue =
false;
4713 private bool checkLratProof_;
4723 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4724 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4726 get {
if ((_hasBits8 & 67108864) != 0) {
return checkLratProof_; }
else {
return CheckLratProofDefaultValue; } }
4728 _hasBits8 |= 67108864;
4729 checkLratProof_ = value;
4733 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4734 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4736 get {
return (_hasBits8 & 67108864) != 0; }
4739 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4740 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4742 _hasBits8 &= ~67108864;
4747 private readonly
static bool CheckMergedLratProofDefaultValue =
false;
4749 private bool checkMergedLratProof_;
4757 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4758 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4760 get {
if ((_hasBits9 & 4) != 0) {
return checkMergedLratProof_; }
else {
return CheckMergedLratProofDefaultValue; } }
4763 checkMergedLratProof_ = value;
4767 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4768 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4769 public bool HasCheckMergedLratProof {
4770 get {
return (_hasBits9 & 4) != 0; }
4773 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4774 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4775 public void ClearCheckMergedLratProof() {
4780 public const int OutputLratProofFieldNumber = 345;
4781 private readonly
static bool OutputLratProofDefaultValue =
false;
4783 private bool outputLratProof_;
4794 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4795 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4797 get {
if ((_hasBits8 & 134217728) != 0) {
return outputLratProof_; }
else {
return OutputLratProofDefaultValue; } }
4799 _hasBits8 |= 134217728;
4800 outputLratProof_ = value;
4804 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4805 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4807 get {
return (_hasBits8 & 134217728) != 0; }
4810 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4811 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4813 _hasBits8 &= ~134217728;
4818 private readonly
static bool CheckDratProofDefaultValue =
false;
4820 private bool checkDratProof_;
4830 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4831 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4833 get {
if ((_hasBits8 & 268435456) != 0) {
return checkDratProof_; }
else {
return CheckDratProofDefaultValue; } }
4835 _hasBits8 |= 268435456;
4836 checkDratProof_ = value;
4840 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4841 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4843 get {
return (_hasBits8 & 268435456) != 0; }
4846 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4847 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4849 _hasBits8 &= ~268435456;
4854 private readonly
static bool OutputDratProofDefaultValue =
false;
4856 private bool outputDratProof_;
4866 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4867 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4869 get {
if ((_hasBits8 & 536870912) != 0) {
return outputDratProof_; }
else {
return OutputDratProofDefaultValue; } }
4871 _hasBits8 |= 536870912;
4872 outputDratProof_ = value;
4876 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4877 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4879 get {
return (_hasBits8 & 536870912) != 0; }
4882 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4883 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4885 _hasBits8 &= ~536870912;
4890 private readonly
static double MaxDratTimeInSecondsDefaultValue =
double.PositiveInfinity;
4892 private double maxDratTimeInSeconds_;
4897 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4898 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4900 get {
if ((_hasBits8 & 1073741824) != 0) {
return maxDratTimeInSeconds_; }
else {
return MaxDratTimeInSecondsDefaultValue; } }
4902 _hasBits8 |= 1073741824;
4903 maxDratTimeInSeconds_ = value;
4907 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4908 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4909 public bool HasMaxDratTimeInSeconds {
4910 get {
return (_hasBits8 & 1073741824) != 0; }
4913 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4914 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4916 _hasBits8 &= ~1073741824;
4921 private readonly
static bool DebugPostsolveWithFullSolverDefaultValue =
false;
4923 private bool debugPostsolveWithFullSolver_;
4929 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4930 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4932 get {
if ((_hasBits3 & 134217728) != 0) {
return debugPostsolveWithFullSolver_; }
else {
return DebugPostsolveWithFullSolverDefaultValue; } }
4934 _hasBits3 |= 134217728;
4935 debugPostsolveWithFullSolver_ = value;
4939 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4940 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4941 public bool HasDebugPostsolveWithFullSolver {
4942 get {
return (_hasBits3 & 134217728) != 0; }
4945 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4946 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4948 _hasBits3 &= ~134217728;
4953 private readonly
static int DebugMaxNumPresolveOperationsDefaultValue = 0;
4955 private int debugMaxNumPresolveOperations_;
4960 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4961 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4963 get {
if ((_hasBits3 & 131072) != 0) {
return debugMaxNumPresolveOperations_; }
else {
return DebugMaxNumPresolveOperationsDefaultValue; } }
4965 _hasBits3 |= 131072;
4966 debugMaxNumPresolveOperations_ = value;
4970 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4971 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4972 public bool HasDebugMaxNumPresolveOperations {
4973 get {
return (_hasBits3 & 131072) != 0; }
4976 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4977 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4979 _hasBits3 &= ~131072;
4984 private readonly
static bool DebugCrashOnBadHintDefaultValue =
false;
4986 private bool debugCrashOnBadHint_;
4990 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4991 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4993 get {
if ((_hasBits4 & 33554432) != 0) {
return debugCrashOnBadHint_; }
else {
return DebugCrashOnBadHintDefaultValue; } }
4995 _hasBits4 |= 33554432;
4996 debugCrashOnBadHint_ = value;
5000 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5001 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5002 public bool HasDebugCrashOnBadHint {
5003 get {
return (_hasBits4 & 33554432) != 0; }
5006 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5007 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5009 _hasBits4 &= ~33554432;
5013 public const int DebugCrashIfPresolveBreaksHintFieldNumber = 306;
5014 private readonly
static bool DebugCrashIfPresolveBreaksHintDefaultValue =
false;
5016 private bool debugCrashIfPresolveBreaksHint_;
5020 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5021 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5023 get {
if ((_hasBits7 & 8388608) != 0) {
return debugCrashIfPresolveBreaksHint_; }
else {
return DebugCrashIfPresolveBreaksHintDefaultValue; } }
5025 _hasBits7 |= 8388608;
5026 debugCrashIfPresolveBreaksHint_ = value;
5030 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5031 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5032 public bool HasDebugCrashIfPresolveBreaksHint {
5033 get {
return (_hasBits7 & 8388608) != 0; }
5036 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5037 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5039 _hasBits7 &= ~8388608;
5043 public const int DebugCrashIfLratCheckFailsFieldNumber = 339;
5044 private readonly
static bool DebugCrashIfLratCheckFailsDefaultValue =
false;
5046 private bool debugCrashIfLratCheckFails_;
5050 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5051 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5053 get {
if ((_hasBits8 & 2097152) != 0) {
return debugCrashIfLratCheckFails_; }
else {
return DebugCrashIfLratCheckFailsDefaultValue; } }
5055 _hasBits8 |= 2097152;
5056 debugCrashIfLratCheckFails_ = value;
5060 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5061 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5062 public bool HasDebugCrashIfLratCheckFails {
5063 get {
return (_hasBits8 & 2097152) != 0; }
5066 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5067 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5069 _hasBits8 &= ~2097152;
5073 public const int UseOptimizationHintsFieldNumber = 35;
5074 private readonly
static bool UseOptimizationHintsDefaultValue =
true;
5076 private bool useOptimizationHints_;
5083 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5084 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5086 get {
if ((_hasBits0 & 65536) != 0) {
return useOptimizationHints_; }
else {
return UseOptimizationHintsDefaultValue; } }
5089 useOptimizationHints_ = value;
5093 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5094 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5095 public bool HasUseOptimizationHints {
5096 get {
return (_hasBits0 & 65536) != 0; }
5099 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5100 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5102 _hasBits0 &= ~65536;
5107 private readonly
static int CoreMinimizationLevelDefaultValue = 2;
5109 private int coreMinimizationLevel_;
5116 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5117 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5119 get {
if ((_hasBits0 & 268435456) != 0) {
return coreMinimizationLevel_; }
else {
return CoreMinimizationLevelDefaultValue; } }
5121 _hasBits0 |= 268435456;
5122 coreMinimizationLevel_ = value;
5126 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5127 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5128 public bool HasCoreMinimizationLevel {
5129 get {
return (_hasBits0 & 268435456) != 0; }
5132 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5133 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5135 _hasBits0 &= ~268435456;
5140 private readonly
static bool FindMultipleCoresDefaultValue =
true;
5142 private bool findMultipleCores_;
5147 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5148 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5150 get {
if ((_hasBits1 & 67108864) != 0) {
return findMultipleCores_; }
else {
return FindMultipleCoresDefaultValue; } }
5152 _hasBits1 |= 67108864;
5153 findMultipleCores_ = value;
5157 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5158 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5159 public bool HasFindMultipleCores {
5160 get {
return (_hasBits1 & 67108864) != 0; }
5163 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5164 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5166 _hasBits1 &= ~67108864;
5171 private readonly
static bool CoverOptimizationDefaultValue =
true;
5173 private bool coverOptimization_;
5179 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5180 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5182 get {
if ((_hasBits1 & -2147483648) != 0) {
return coverOptimization_; }
else {
return CoverOptimizationDefaultValue; } }
5184 _hasBits1 |= -2147483648;
5185 coverOptimization_ = value;
5189 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5190 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5191 public bool HasCoverOptimization {
5192 get {
return (_hasBits1 & -2147483648) != 0; }
5195 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5196 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5198 _hasBits1 &= ~-2147483648;
5203 private readonly
static global::Google.OrTools.Sat.SatParameters.Types.MaxSatAssumptionOrder MaxSatAssumptionOrderDefaultValue = global::Google.OrTools.Sat.SatParameters.Types.MaxSatAssumptionOrder.DefaultAssumptionOrder;
5205 private global::Google.OrTools.Sat.SatParameters.Types.MaxSatAssumptionOrder maxSatAssumptionOrder_;
5206 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5207 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5209 get {
if ((_hasBits0 & 536870912) != 0) {
return maxSatAssumptionOrder_; }
else {
return MaxSatAssumptionOrderDefaultValue; } }
5211 _hasBits0 |= 536870912;
5212 maxSatAssumptionOrder_ = value;
5216 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5217 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5219 get {
return (_hasBits0 & 536870912) != 0; }
5222 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5223 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5224 public void ClearMaxSatAssumptionOrder() {
5225 _hasBits0 &= ~536870912;
5230 private readonly
static bool MaxSatReverseAssumptionOrderDefaultValue =
false;
5232 private bool maxSatReverseAssumptionOrder_;
5237 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5238 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5240 get {
if ((_hasBits0 & 1073741824) != 0) {
return maxSatReverseAssumptionOrder_; }
else {
return MaxSatReverseAssumptionOrderDefaultValue; } }
5242 _hasBits0 |= 1073741824;
5243 maxSatReverseAssumptionOrder_ = value;
5247 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5248 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5249 public bool HasMaxSatReverseAssumptionOrder {
5250 get {
return (_hasBits0 & 1073741824) != 0; }
5253 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5254 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5256 _hasBits0 &= ~1073741824;
5261 private readonly
static global::Google.OrTools.Sat.SatParameters.Types.MaxSatStratificationAlgorithm MaxSatStratificationDefaultValue = global::Google.OrTools.Sat.SatParameters.Types.MaxSatStratificationAlgorithm.StratificationDescent;
5263 private global::Google.OrTools.Sat.SatParameters.Types.MaxSatStratificationAlgorithm maxSatStratification_;
5264 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5265 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5266 public global::Google.OrTools.Sat.SatParameters.Types.MaxSatStratificationAlgorithm
MaxSatStratification {
5267 get {
if ((_hasBits0 & -2147483648) != 0) {
return maxSatStratification_; }
else {
return MaxSatStratificationDefaultValue; } }
5269 _hasBits0 |= -2147483648;
5270 maxSatStratification_ = value;
5274 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5275 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5277 get {
return (_hasBits0 & -2147483648) != 0; }
5280 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5281 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5282 public void ClearMaxSatStratification() {
5283 _hasBits0 &= ~-2147483648;
5288 private readonly
static double PropagationLoopDetectionFactorDefaultValue = 10D;
5290 private double propagationLoopDetectionFactor_;
5302 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5303 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5305 get {
if ((_hasBits5 & 2048) != 0) {
return propagationLoopDetectionFactor_; }
else {
return PropagationLoopDetectionFactorDefaultValue; } }
5308 propagationLoopDetectionFactor_ = value;
5312 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5313 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5315 get {
return (_hasBits5 & 2048) != 0; }
5318 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5319 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5326 private readonly
static bool UsePrecedencesInDisjunctiveConstraintDefaultValue =
true;
5328 private bool usePrecedencesInDisjunctiveConstraint_;
5340 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5341 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5343 get {
if ((_hasBits1 & 131072) != 0) {
return usePrecedencesInDisjunctiveConstraint_; }
else {
return UsePrecedencesInDisjunctiveConstraintDefaultValue; } }
5345 _hasBits1 |= 131072;
5346 usePrecedencesInDisjunctiveConstraint_ = value;
5350 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5351 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5353 get {
return (_hasBits1 & 131072) != 0; }
5356 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5357 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5359 _hasBits1 &= ~131072;
5364 private readonly
static int TransitivePrecedencesWorkLimitDefaultValue = 1000000;
5366 private int transitivePrecedencesWorkLimit_;
5372 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5373 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5375 get {
if ((_hasBits8 & 2048) != 0) {
return transitivePrecedencesWorkLimit_; }
else {
return TransitivePrecedencesWorkLimitDefaultValue; } }
5378 transitivePrecedencesWorkLimit_ = value;
5382 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5383 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5384 public bool HasTransitivePrecedencesWorkLimit {
5385 get {
return (_hasBits8 & 2048) != 0; }
5388 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5389 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5395 public const int MaxSizeToCreatePrecedenceLiteralsInDisjunctiveFieldNumber = 229;
5396 private readonly
static int MaxSizeToCreatePrecedenceLiteralsInDisjunctiveDefaultValue = 60;
5398 private int maxSizeToCreatePrecedenceLiteralsInDisjunctive_;
5406 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5407 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5409 get {
if ((_hasBits5 & 524288) != 0) {
return maxSizeToCreatePrecedenceLiteralsInDisjunctive_; }
else {
return MaxSizeToCreatePrecedenceLiteralsInDisjunctiveDefaultValue; } }
5411 _hasBits5 |= 524288;
5412 maxSizeToCreatePrecedenceLiteralsInDisjunctive_ = value;
5416 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5417 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5418 public bool HasMaxSizeToCreatePrecedenceLiteralsInDisjunctive {
5419 get {
return (_hasBits5 & 524288) != 0; }
5422 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5423 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5425 _hasBits5 &= ~524288;
5430 private readonly
static bool UseStrongPropagationInDisjunctiveDefaultValue =
false;
5432 private bool useStrongPropagationInDisjunctive_;
5436 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5437 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5439 get {
if ((_hasBits5 & 1048576) != 0) {
return useStrongPropagationInDisjunctive_; }
else {
return UseStrongPropagationInDisjunctiveDefaultValue; } }
5441 _hasBits5 |= 1048576;
5442 useStrongPropagationInDisjunctive_ = value;
5446 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5447 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5449 get {
return (_hasBits5 & 1048576) != 0; }
5452 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5453 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5454 public void ClearUseStrongPropagationInDisjunctive() {
5455 _hasBits5 &= ~1048576;
5459 public const int UseDynamicPrecedenceInDisjunctiveFieldNumber = 263;
5460 private readonly
static bool UseDynamicPrecedenceInDisjunctiveDefaultValue =
false;
5462 private bool useDynamicPrecedenceInDisjunctive_;
5471 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5472 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5474 get {
if ((_hasBits6 & 8192) != 0) {
return useDynamicPrecedenceInDisjunctive_; }
else {
return UseDynamicPrecedenceInDisjunctiveDefaultValue; } }
5477 useDynamicPrecedenceInDisjunctive_ = value;
5481 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5482 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5483 public bool HasUseDynamicPrecedenceInDisjunctive {
5484 get {
return (_hasBits6 & 8192) != 0; }
5487 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5488 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5495 private readonly
static bool UseDynamicPrecedenceInCumulativeDefaultValue =
false;
5497 private bool useDynamicPrecedenceInCumulative_;
5498 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5499 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5501 get {
if ((_hasBits6 & 262144) != 0) {
return useDynamicPrecedenceInCumulative_; }
else {
return UseDynamicPrecedenceInCumulativeDefaultValue; } }
5503 _hasBits6 |= 262144;
5504 useDynamicPrecedenceInCumulative_ = value;
5508 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5509 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5510 public bool HasUseDynamicPrecedenceInCumulative {
5511 get {
return (_hasBits6 & 262144) != 0; }
5514 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5515 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5516 public void ClearUseDynamicPrecedenceInCumulative() {
5517 _hasBits6 &= ~262144;
5521 public const int UseOverloadCheckerInCumulativeFieldNumber = 78;
5522 private readonly
static bool UseOverloadCheckerInCumulativeDefaultValue =
false;
5524 private bool useOverloadCheckerInCumulative_;
5534 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5535 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5537 get {
if ((_hasBits1 & 2097152) != 0) {
return useOverloadCheckerInCumulative_; }
else {
return UseOverloadCheckerInCumulativeDefaultValue; } }
5539 _hasBits1 |= 2097152;
5540 useOverloadCheckerInCumulative_ = value;
5544 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5545 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5546 public bool HasUseOverloadCheckerInCumulative {
5547 get {
return (_hasBits1 & 2097152) != 0; }
5550 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5551 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5553 _hasBits1 &= ~2097152;
5558 private readonly
static bool UseConservativeScaleOverloadCheckerDefaultValue =
false;
5560 private bool useConservativeScaleOverloadChecker_;
5570 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5571 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5573 get {
if ((_hasBits7 & 16) != 0) {
return useConservativeScaleOverloadChecker_; }
else {
return UseConservativeScaleOverloadCheckerDefaultValue; } }
5576 useConservativeScaleOverloadChecker_ = value;
5580 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5581 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5582 public bool HasUseConservativeScaleOverloadChecker {
5583 get {
return (_hasBits7 & 16) != 0; }
5586 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5587 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5594 private readonly
static bool UseTimetableEdgeFindingInCumulativeDefaultValue =
false;
5596 private bool useTimetableEdgeFindingInCumulative_;
5606 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5607 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5609 get {
if ((_hasBits1 & 4194304) != 0) {
return useTimetableEdgeFindingInCumulative_; }
else {
return UseTimetableEdgeFindingInCumulativeDefaultValue; } }
5611 _hasBits1 |= 4194304;
5612 useTimetableEdgeFindingInCumulative_ = value;
5616 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5617 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5618 public bool HasUseTimetableEdgeFindingInCumulative {
5619 get {
return (_hasBits1 & 4194304) != 0; }
5622 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5623 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5625 _hasBits1 &= ~4194304;
5630 private readonly
static int MaxNumIntervalsForTimetableEdgeFindingDefaultValue = 100;
5632 private int maxNumIntervalsForTimetableEdgeFinding_;
5637 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5638 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5640 get {
if ((_hasBits6 & 1024) != 0) {
return maxNumIntervalsForTimetableEdgeFinding_; }
else {
return MaxNumIntervalsForTimetableEdgeFindingDefaultValue; } }
5643 maxNumIntervalsForTimetableEdgeFinding_ = value;
5647 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5648 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5649 public bool HasMaxNumIntervalsForTimetableEdgeFinding {
5650 get {
return (_hasBits6 & 1024) != 0; }
5653 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5654 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5655 public void ClearMaxNumIntervalsForTimetableEdgeFinding() {
5661 private readonly
static bool UseHardPrecedencesInCumulativeDefaultValue =
false;
5663 private bool useHardPrecedencesInCumulative_;
5672 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5673 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5675 get {
if ((_hasBits5 & 128) != 0) {
return useHardPrecedencesInCumulative_; }
else {
return UseHardPrecedencesInCumulativeDefaultValue; } }
5678 useHardPrecedencesInCumulative_ = value;
5682 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5683 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5685 get {
return (_hasBits5 & 128) != 0; }
5688 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5689 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5690 public void ClearUseHardPrecedencesInCumulative() {
5695 public const int ExploitAllPrecedencesFieldNumber = 220;
5696 private readonly
static bool ExploitAllPrecedencesDefaultValue =
false;
5698 private bool exploitAllPrecedences_;
5699 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5700 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5702 get {
if ((_hasBits5 & 1024) != 0) {
return exploitAllPrecedences_; }
else {
return ExploitAllPrecedencesDefaultValue; } }
5705 exploitAllPrecedences_ = value;
5709 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5710 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5711 public bool HasExploitAllPrecedences {
5712 get {
return (_hasBits5 & 1024) != 0; }
5715 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5716 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5722 public const int UseDisjunctiveConstraintInCumulativeFieldNumber = 80;
5723 private readonly
static bool UseDisjunctiveConstraintInCumulativeDefaultValue =
true;
5725 private bool useDisjunctiveConstraintInCumulative_;
5738 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5739 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5741 get {
if ((_hasBits1 & 8388608) != 0) {
return useDisjunctiveConstraintInCumulative_; }
else {
return UseDisjunctiveConstraintInCumulativeDefaultValue; } }
5743 _hasBits1 |= 8388608;
5744 useDisjunctiveConstraintInCumulative_ = value;
5748 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5749 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5750 public bool HasUseDisjunctiveConstraintInCumulative {
5751 get {
return (_hasBits1 & 8388608) != 0; }
5754 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5755 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5757 _hasBits1 &= ~8388608;
5762 private readonly
static int NoOverlap2DBooleanRelationsLimitDefaultValue = 10;
5764 private int noOverlap2DBooleanRelationsLimit_;
5780 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5781 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5783 get {
if ((_hasBits8 & 32) != 0) {
return noOverlap2DBooleanRelationsLimit_; }
else {
return NoOverlap2DBooleanRelationsLimitDefaultValue; } }
5786 noOverlap2DBooleanRelationsLimit_ = value;
5790 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5791 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5792 public bool HasNoOverlap2DBooleanRelationsLimit {
5793 get {
return (_hasBits8 & 32) != 0; }
5796 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5797 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5804 private readonly
static bool UseTimetablingInNoOverlap2DDefaultValue =
false;
5806 private bool useTimetablingInNoOverlap2D_;
5814 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5815 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5817 get {
if ((_hasBits4 & 1073741824) != 0) {
return useTimetablingInNoOverlap2D_; }
else {
return UseTimetablingInNoOverlap2DDefaultValue; } }
5819 _hasBits4 |= 1073741824;
5820 useTimetablingInNoOverlap2D_ = value;
5824 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5825 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5826 public bool HasUseTimetablingInNoOverlap2D {
5827 get {
return (_hasBits4 & 1073741824) != 0; }
5830 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5831 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5833 _hasBits4 &= ~1073741824;
5837 public const int UseEnergeticReasoningInNoOverlap2DFieldNumber = 213;
5838 private readonly
static bool UseEnergeticReasoningInNoOverlap2DDefaultValue =
false;
5840 private bool useEnergeticReasoningInNoOverlap2D_;
5846 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5847 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5849 get {
if ((_hasBits5 & 32) != 0) {
return useEnergeticReasoningInNoOverlap2D_; }
else {
return UseEnergeticReasoningInNoOverlap2DDefaultValue; } }
5852 useEnergeticReasoningInNoOverlap2D_ = value;
5856 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5857 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5858 public bool HasUseEnergeticReasoningInNoOverlap2D {
5859 get {
return (_hasBits5 & 32) != 0; }
5862 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5863 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5869 public const int UseAreaEnergeticReasoningInNoOverlap2DFieldNumber = 271;
5870 private readonly
static bool UseAreaEnergeticReasoningInNoOverlap2DDefaultValue =
false;
5872 private bool useAreaEnergeticReasoningInNoOverlap2D_;
5878 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5879 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5881 get {
if ((_hasBits6 & 2097152) != 0) {
return useAreaEnergeticReasoningInNoOverlap2D_; }
else {
return UseAreaEnergeticReasoningInNoOverlap2DDefaultValue; } }
5883 _hasBits6 |= 2097152;
5884 useAreaEnergeticReasoningInNoOverlap2D_ = value;
5888 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5889 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5890 public bool HasUseAreaEnergeticReasoningInNoOverlap2D {
5891 get {
return (_hasBits6 & 2097152) != 0; }
5894 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5895 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5897 _hasBits6 &= ~2097152;
5901 public const int UseTryEdgeReasoningInNoOverlap2DFieldNumber = 299;
5902 private readonly
static bool UseTryEdgeReasoningInNoOverlap2DDefaultValue =
false;
5904 private bool useTryEdgeReasoningInNoOverlap2D_;
5905 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5906 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5908 get {
if ((_hasBits7 & 65536) != 0) {
return useTryEdgeReasoningInNoOverlap2D_; }
else {
return UseTryEdgeReasoningInNoOverlap2DDefaultValue; } }
5911 useTryEdgeReasoningInNoOverlap2D_ = value;
5915 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5916 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5918 get {
return (_hasBits7 & 65536) != 0; }
5921 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5922 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5923 public void ClearUseTryEdgeReasoningInNoOverlap2D() {
5924 _hasBits7 &= ~65536;
5929 private readonly
static int MaxPairsPairwiseReasoningInNoOverlap2DDefaultValue = 1250;
5931 private int maxPairsPairwiseReasoningInNoOverlap2D_;
5937 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5938 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5940 get {
if ((_hasBits6 & 67108864) != 0) {
return maxPairsPairwiseReasoningInNoOverlap2D_; }
else {
return MaxPairsPairwiseReasoningInNoOverlap2DDefaultValue; } }
5942 _hasBits6 |= 67108864;
5943 maxPairsPairwiseReasoningInNoOverlap2D_ = value;
5947 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5948 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5950 get {
return (_hasBits6 & 67108864) != 0; }
5953 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5954 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5956 _hasBits6 &= ~67108864;
5960 public const int MaximumRegionsToSplitInDisconnectedNoOverlap2DFieldNumber = 315;
5961 private readonly
static int MaximumRegionsToSplitInDisconnectedNoOverlap2DDefaultValue = 0;
5963 private int maximumRegionsToSplitInDisconnectedNoOverlap2D_;
5976 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5977 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5979 get {
if ((_hasBits8 & 1) != 0) {
return maximumRegionsToSplitInDisconnectedNoOverlap2D_; }
else {
return MaximumRegionsToSplitInDisconnectedNoOverlap2DDefaultValue; } }
5982 maximumRegionsToSplitInDisconnectedNoOverlap2D_ = value;
5986 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5987 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5989 get {
return (_hasBits8 & 1) != 0; }
5992 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5993 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5994 public void ClearMaximumRegionsToSplitInDisconnectedNoOverlap2D() {
5999 public const int UseLinear3ForNoOverlap2DPrecedencesFieldNumber = 323;
6000 private readonly
static bool UseLinear3ForNoOverlap2DPrecedencesDefaultValue =
true;
6002 private bool useLinear3ForNoOverlap2DPrecedences_;
6011 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6012 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6014 get {
if ((_hasBits8 & 128) != 0) {
return useLinear3ForNoOverlap2DPrecedences_; }
else {
return UseLinear3ForNoOverlap2DPrecedencesDefaultValue; } }
6017 useLinear3ForNoOverlap2DPrecedences_ = value;
6021 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6022 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6023 public bool HasUseLinear3ForNoOverlap2DPrecedences {
6024 get {
return (_hasBits8 & 128) != 0; }
6027 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6028 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6029 public void ClearUseLinear3ForNoOverlap2DPrecedences() {
6034 public const int UseDualSchedulingHeuristicsFieldNumber = 214;
6035 private readonly
static bool UseDualSchedulingHeuristicsDefaultValue =
true;
6037 private bool useDualSchedulingHeuristics_;
6043 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6044 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6046 get {
if ((_hasBits5 & 64) != 0) {
return useDualSchedulingHeuristics_; }
else {
return UseDualSchedulingHeuristicsDefaultValue; } }
6049 useDualSchedulingHeuristics_ = value;
6053 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6054 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6055 public bool HasUseDualSchedulingHeuristics {
6056 get {
return (_hasBits5 & 64) != 0; }
6059 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6060 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6066 public const int UseAllDifferentForCircuitFieldNumber = 311;
6067 private readonly
static bool UseAllDifferentForCircuitDefaultValue =
false;
6069 private bool useAllDifferentForCircuit_;
6074 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6075 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6077 get {
if ((_hasBits7 & 268435456) != 0) {
return useAllDifferentForCircuit_; }
else {
return UseAllDifferentForCircuitDefaultValue; } }
6079 _hasBits7 |= 268435456;
6080 useAllDifferentForCircuit_ = value;
6084 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6085 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6086 public bool HasUseAllDifferentForCircuit {
6087 get {
return (_hasBits7 & 268435456) != 0; }
6090 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6091 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6093 _hasBits7 &= ~268435456;
6097 public const int RoutingCutSubsetSizeForBinaryRelationBoundFieldNumber = 312;
6098 private readonly
static int RoutingCutSubsetSizeForBinaryRelationBoundDefaultValue = 0;
6100 private int routingCutSubsetSizeForBinaryRelationBound_;
6111 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6112 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6114 get {
if ((_hasBits7 & 536870912) != 0) {
return routingCutSubsetSizeForBinaryRelationBound_; }
else {
return RoutingCutSubsetSizeForBinaryRelationBoundDefaultValue; } }
6116 _hasBits7 |= 536870912;
6117 routingCutSubsetSizeForBinaryRelationBound_ = value;
6121 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6122 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6124 get {
return (_hasBits7 & 536870912) != 0; }
6127 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6128 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6129 public void ClearRoutingCutSubsetSizeForBinaryRelationBound() {
6130 _hasBits7 &= ~536870912;
6135 private readonly
static int RoutingCutSubsetSizeForTightBinaryRelationBoundDefaultValue = 0;
6137 private int routingCutSubsetSizeForTightBinaryRelationBound_;
6143 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6144 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6146 get {
if ((_hasBits7 & 1073741824) != 0) {
return routingCutSubsetSizeForTightBinaryRelationBound_; }
else {
return RoutingCutSubsetSizeForTightBinaryRelationBoundDefaultValue; } }
6148 _hasBits7 |= 1073741824;
6149 routingCutSubsetSizeForTightBinaryRelationBound_ = value;
6153 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6154 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6155 public bool HasRoutingCutSubsetSizeForTightBinaryRelationBound {
6156 get {
return (_hasBits7 & 1073741824) != 0; }
6159 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6160 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6162 _hasBits7 &= ~1073741824;
6166 public const int RoutingCutSubsetSizeForExactBinaryRelationBoundFieldNumber = 316;
6167 private readonly
static int RoutingCutSubsetSizeForExactBinaryRelationBoundDefaultValue = 8;
6169 private int routingCutSubsetSizeForExactBinaryRelationBound_;
6175 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6176 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6178 get {
if ((_hasBits8 & 2) != 0) {
return routingCutSubsetSizeForExactBinaryRelationBound_; }
else {
return RoutingCutSubsetSizeForExactBinaryRelationBoundDefaultValue; } }
6181 routingCutSubsetSizeForExactBinaryRelationBound_ = value;
6185 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6186 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6187 public bool HasRoutingCutSubsetSizeForExactBinaryRelationBound {
6188 get {
return (_hasBits8 & 2) != 0; }
6191 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6192 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6198 public const int RoutingCutSubsetSizeForShortestPathsBoundFieldNumber = 318;
6199 private readonly
static int RoutingCutSubsetSizeForShortestPathsBoundDefaultValue = 8;
6201 private int routingCutSubsetSizeForShortestPathsBound_;
6208 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6209 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6211 get {
if ((_hasBits8 & 8) != 0) {
return routingCutSubsetSizeForShortestPathsBound_; }
else {
return RoutingCutSubsetSizeForShortestPathsBoundDefaultValue; } }
6214 routingCutSubsetSizeForShortestPathsBound_ = value;
6218 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6219 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6220 public bool HasRoutingCutSubsetSizeForShortestPathsBound {
6221 get {
return (_hasBits8 & 8) != 0; }
6224 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6225 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6231 public const int RoutingCutDpEffortFieldNumber = 314;
6232 private readonly
static double RoutingCutDpEffortDefaultValue = 1e+07D;
6234 private double routingCutDpEffort_;
6241 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6242 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6244 get {
if ((_hasBits7 & -2147483648) != 0) {
return routingCutDpEffort_; }
else {
return RoutingCutDpEffortDefaultValue; } }
6246 _hasBits7 |= -2147483648;
6247 routingCutDpEffort_ = value;
6251 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6252 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6253 public bool HasRoutingCutDpEffort {
6254 get {
return (_hasBits7 & -2147483648) != 0; }
6257 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6258 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6260 _hasBits7 &= ~-2147483648;
6264 public const int RoutingCutMaxInfeasiblePathLengthFieldNumber = 317;
6265 private readonly
static int RoutingCutMaxInfeasiblePathLengthDefaultValue = 6;
6267 private int routingCutMaxInfeasiblePathLength_;
6272 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6273 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6275 get {
if ((_hasBits8 & 4) != 0) {
return routingCutMaxInfeasiblePathLength_; }
else {
return RoutingCutMaxInfeasiblePathLengthDefaultValue; } }
6278 routingCutMaxInfeasiblePathLength_ = value;
6282 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6283 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6284 public bool HasRoutingCutMaxInfeasiblePathLength {
6285 get {
return (_hasBits8 & 4) != 0; }
6288 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6289 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6295 public const int SearchBranchingFieldNumber = 82;
6296 private readonly
static global::Google.OrTools.Sat.SatParameters.Types.SearchBranching SearchBranchingDefaultValue = global::Google.OrTools.Sat.SatParameters.Types.SearchBranching.AutomaticSearch;
6298 private global::Google.OrTools.Sat.SatParameters.Types.SearchBranching searchBranching_;
6299 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6300 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6301 public global::Google.OrTools.Sat.SatParameters.Types.SearchBranching
SearchBranching {
6302 get {
if ((_hasBits1 & 16777216) != 0) {
return searchBranching_; }
else {
return SearchBranchingDefaultValue; } }
6304 _hasBits1 |= 16777216;
6305 searchBranching_ = value;
6309 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6310 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6312 get {
return (_hasBits1 & 16777216) != 0; }
6315 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6316 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6317 public void ClearSearchBranching() {
6318 _hasBits1 &= ~16777216;
6323 private readonly
static int HintConflictLimitDefaultValue = 10;
6325 private int hintConflictLimit_;
6329 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6330 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6332 get {
if ((_hasBits3 & 524288) != 0) {
return hintConflictLimit_; }
else {
return HintConflictLimitDefaultValue; } }
6334 _hasBits3 |= 524288;
6335 hintConflictLimit_ = value;
6339 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6340 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6341 public bool HasHintConflictLimit {
6342 get {
return (_hasBits3 & 524288) != 0; }
6345 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6346 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6347 public void ClearHintConflictLimit() {
6348 _hasBits3 &= ~524288;
6352 public const int RepairHintFieldNumber = 167;
6353 private readonly
static bool RepairHintDefaultValue =
false;
6355 private bool repairHint_;
6362 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6363 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6365 get {
if ((_hasBits4 & 1) != 0) {
return repairHint_; }
else {
return RepairHintDefaultValue; } }
6368 repairHint_ = value;
6372 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6373 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6374 public bool HasRepairHint {
6375 get {
return (_hasBits4 & 1) != 0; }
6378 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6379 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6385 public const int FixVariablesToTheirHintedValueFieldNumber = 192;
6386 private readonly
static bool FixVariablesToTheirHintedValueDefaultValue =
false;
6388 private bool fixVariablesToTheirHintedValue_;
6393 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6394 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6396 get {
if ((_hasBits4 & 4194304) != 0) {
return fixVariablesToTheirHintedValue_; }
else {
return FixVariablesToTheirHintedValueDefaultValue; } }
6398 _hasBits4 |= 4194304;
6399 fixVariablesToTheirHintedValue_ = value;
6403 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6404 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6405 public bool HasFixVariablesToTheirHintedValue {
6406 get {
return (_hasBits4 & 4194304) != 0; }
6409 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6410 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6412 _hasBits4 &= ~4194304;
6416 public const int UseProbingSearchFieldNumber = 176;
6417 private readonly
static bool UseProbingSearchDefaultValue =
false;
6419 private bool useProbingSearch_;
6425 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6426 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6428 get {
if ((_hasBits4 & 256) != 0) {
return useProbingSearch_; }
else {
return UseProbingSearchDefaultValue; } }
6431 useProbingSearch_ = value;
6435 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6436 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6437 public bool HasUseProbingSearch {
6438 get {
return (_hasBits4 & 256) != 0; }
6441 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6442 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6448 public const int UseExtendedProbingFieldNumber = 269;
6449 private readonly
static bool UseExtendedProbingDefaultValue =
true;
6451 private bool useExtendedProbing_;
6455 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6456 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6458 get {
if ((_hasBits6 & 524288) != 0) {
return useExtendedProbing_; }
else {
return UseExtendedProbingDefaultValue; } }
6460 _hasBits6 |= 524288;
6461 useExtendedProbing_ = value;
6465 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6466 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6467 public bool HasUseExtendedProbing {
6468 get {
return (_hasBits6 & 524288) != 0; }
6471 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6472 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6473 public void ClearUseExtendedProbing() {
6474 _hasBits6 &= ~524288;
6478 public const int ProbingNumCombinationsLimitFieldNumber = 272;
6479 private readonly
static int ProbingNumCombinationsLimitDefaultValue = 20000;
6481 private int probingNumCombinationsLimit_;
6485 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6486 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6488 get {
if ((_hasBits6 & 4194304) != 0) {
return probingNumCombinationsLimit_; }
else {
return ProbingNumCombinationsLimitDefaultValue; } }
6490 _hasBits6 |= 4194304;
6491 probingNumCombinationsLimit_ = value;
6495 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6496 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6498 get {
return (_hasBits6 & 4194304) != 0; }
6501 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6502 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6503 public void ClearProbingNumCombinationsLimit() {
6504 _hasBits6 &= ~4194304;
6508 public const int ShavingDeterministicTimeInProbingSearchFieldNumber = 204;
6509 private readonly
static double ShavingDeterministicTimeInProbingSearchDefaultValue = 0.001D;
6511 private double shavingDeterministicTimeInProbingSearch_;
6517 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6518 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6520 get {
if ((_hasBits5 & 4) != 0) {
return shavingDeterministicTimeInProbingSearch_; }
else {
return ShavingDeterministicTimeInProbingSearchDefaultValue; } }
6523 shavingDeterministicTimeInProbingSearch_ = value;
6527 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6528 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6529 public bool HasShavingDeterministicTimeInProbingSearch {
6530 get {
return (_hasBits5 & 4) != 0; }
6533 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6534 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6540 public const int ShavingSearchDeterministicTimeFieldNumber = 205;
6541 private readonly
static double ShavingSearchDeterministicTimeDefaultValue = 0.1D;
6543 private double shavingSearchDeterministicTime_;
6548 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6549 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6551 get {
if ((_hasBits5 & 8) != 0) {
return shavingSearchDeterministicTime_; }
else {
return ShavingSearchDeterministicTimeDefaultValue; } }
6554 shavingSearchDeterministicTime_ = value;
6558 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6559 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6560 public bool HasShavingSearchDeterministicTime {
6561 get {
return (_hasBits5 & 8) != 0; }
6564 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6565 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6571 public const int ShavingSearchThresholdFieldNumber = 290;
6572 private readonly
static long ShavingSearchThresholdDefaultValue = 64L;
6574 private long shavingSearchThreshold_;
6581 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6582 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6584 get {
if ((_hasBits7 & 256) != 0) {
return shavingSearchThreshold_; }
else {
return ShavingSearchThresholdDefaultValue; } }
6587 shavingSearchThreshold_ = value;
6591 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6592 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6593 public bool HasShavingSearchThreshold {
6594 get {
return (_hasBits7 & 256) != 0; }
6597 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6598 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6604 public const int UseObjectiveLbSearchFieldNumber = 228;
6605 private readonly
static bool UseObjectiveLbSearchDefaultValue =
false;
6607 private bool useObjectiveLbSearch_;
6612 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6613 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6615 get {
if ((_hasBits5 & 262144) != 0) {
return useObjectiveLbSearch_; }
else {
return UseObjectiveLbSearchDefaultValue; } }
6617 _hasBits5 |= 262144;
6618 useObjectiveLbSearch_ = value;
6622 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6623 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6624 public bool HasUseObjectiveLbSearch {
6625 get {
return (_hasBits5 & 262144) != 0; }
6628 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6629 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6631 _hasBits5 &= ~262144;
6635 public const int UseObjectiveShavingSearchFieldNumber = 253;
6636 private readonly
static bool UseObjectiveShavingSearchDefaultValue =
false;
6638 private bool useObjectiveShavingSearch_;
6644 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6645 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6647 get {
if ((_hasBits6 & 16) != 0) {
return useObjectiveShavingSearch_; }
else {
return UseObjectiveShavingSearchDefaultValue; } }
6650 useObjectiveShavingSearch_ = value;
6654 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6655 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6656 public bool HasUseObjectiveShavingSearch {
6657 get {
return (_hasBits6 & 16) != 0; }
6660 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6661 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6667 public const int VariablesShavingLevelFieldNumber = 289;
6668 private readonly
static int VariablesShavingLevelDefaultValue = -1;
6670 private int variablesShavingLevel_;
6676 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6677 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6679 get {
if ((_hasBits7 & 128) != 0) {
return variablesShavingLevel_; }
else {
return VariablesShavingLevelDefaultValue; } }
6682 variablesShavingLevel_ = value;
6686 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6687 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6688 public bool HasVariablesShavingLevel {
6689 get {
return (_hasBits7 & 128) != 0; }
6692 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6693 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6699 public const int PseudoCostReliabilityThresholdFieldNumber = 123;
6700 private readonly
static long PseudoCostReliabilityThresholdDefaultValue = 100L;
6702 private long pseudoCostReliabilityThreshold_;
6707 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6708 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6710 get {
if ((_hasBits2 & 134217728) != 0) {
return pseudoCostReliabilityThreshold_; }
else {
return PseudoCostReliabilityThresholdDefaultValue; } }
6712 _hasBits2 |= 134217728;
6713 pseudoCostReliabilityThreshold_ = value;
6717 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6718 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6719 public bool HasPseudoCostReliabilityThreshold {
6720 get {
return (_hasBits2 & 134217728) != 0; }
6723 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6724 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6726 _hasBits2 &= ~134217728;
6730 public const int OptimizeWithCoreFieldNumber = 83;
6731 private readonly
static bool OptimizeWithCoreDefaultValue =
false;
6733 private bool optimizeWithCore_;
6740 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6741 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6743 get {
if ((_hasBits1 & 33554432) != 0) {
return optimizeWithCore_; }
else {
return OptimizeWithCoreDefaultValue; } }
6745 _hasBits1 |= 33554432;
6746 optimizeWithCore_ = value;
6750 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6751 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6752 public bool HasOptimizeWithCore {
6753 get {
return (_hasBits1 & 33554432) != 0; }
6756 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6757 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6759 _hasBits1 &= ~33554432;
6763 public const int OptimizeWithLbTreeSearchFieldNumber = 188;
6764 private readonly
static bool OptimizeWithLbTreeSearchDefaultValue =
false;
6766 private bool optimizeWithLbTreeSearch_;
6774 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6775 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6777 get {
if ((_hasBits4 & 262144) != 0) {
return optimizeWithLbTreeSearch_; }
else {
return OptimizeWithLbTreeSearchDefaultValue; } }
6779 _hasBits4 |= 262144;
6780 optimizeWithLbTreeSearch_ = value;
6784 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6785 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6786 public bool HasOptimizeWithLbTreeSearch {
6787 get {
return (_hasBits4 & 262144) != 0; }
6790 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6791 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6793 _hasBits4 &= ~262144;
6797 public const int SaveLpBasisInLbTreeSearchFieldNumber = 284;
6798 private readonly
static bool SaveLpBasisInLbTreeSearchDefaultValue =
false;
6800 private bool saveLpBasisInLbTreeSearch_;
6809 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6810 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6812 get {
if ((_hasBits7 & 4) != 0) {
return saveLpBasisInLbTreeSearch_; }
else {
return SaveLpBasisInLbTreeSearchDefaultValue; } }
6815 saveLpBasisInLbTreeSearch_ = value;
6819 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6820 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6821 public bool HasSaveLpBasisInLbTreeSearch {
6822 get {
return (_hasBits7 & 4) != 0; }
6825 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6826 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6827 public void ClearSaveLpBasisInLbTreeSearch() {
6832 public const int BinarySearchNumConflictsFieldNumber = 99;
6833 private readonly
static int BinarySearchNumConflictsDefaultValue = -1;
6835 private int binarySearchNumConflicts_;
6842 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6843 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6845 get {
if ((_hasBits2 & 128) != 0) {
return binarySearchNumConflicts_; }
else {
return BinarySearchNumConflictsDefaultValue; } }
6848 binarySearchNumConflicts_ = value;
6852 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6853 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6854 public bool HasBinarySearchNumConflicts {
6855 get {
return (_hasBits2 & 128) != 0; }
6858 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6859 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6865 public const int OptimizeWithMaxHsFieldNumber = 85;
6866 private readonly
static bool OptimizeWithMaxHsDefaultValue =
false;
6868 private bool optimizeWithMaxHs_;
6877 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6878 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6880 get {
if ((_hasBits1 & 134217728) != 0) {
return optimizeWithMaxHs_; }
else {
return OptimizeWithMaxHsDefaultValue; } }
6882 _hasBits1 |= 134217728;
6883 optimizeWithMaxHs_ = value;
6887 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6888 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6889 public bool HasOptimizeWithMaxHs {
6890 get {
return (_hasBits1 & 134217728) != 0; }
6893 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6894 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6896 _hasBits1 &= ~134217728;
6900 public const int UseFeasibilityJumpFieldNumber = 265;
6901 private readonly
static bool UseFeasibilityJumpDefaultValue =
true;
6903 private bool useFeasibilityJump_;
6909 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6910 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6912 get {
if ((_hasBits6 & 32768) != 0) {
return useFeasibilityJump_; }
else {
return UseFeasibilityJumpDefaultValue; } }
6915 useFeasibilityJump_ = value;
6919 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6920 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6921 public bool HasUseFeasibilityJump {
6922 get {
return (_hasBits6 & 32768) != 0; }
6925 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6926 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6928 _hasBits6 &= ~32768;
6932 public const int UseLsOnlyFieldNumber = 240;
6933 private readonly
static bool UseLsOnlyDefaultValue =
false;
6935 private bool useLsOnly_;
6940 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6941 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6943 get {
if ((_hasBits5 & 268435456) != 0) {
return useLsOnly_; }
else {
return UseLsOnlyDefaultValue; } }
6945 _hasBits5 |= 268435456;
6950 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6951 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6952 public bool HasUseLsOnly {
6953 get {
return (_hasBits5 & 268435456) != 0; }
6956 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6957 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6958 public void ClearUseLsOnly() {
6959 _hasBits5 &= ~268435456;
6963 public const int FeasibilityJumpDecayFieldNumber = 242;
6964 private readonly
static double FeasibilityJumpDecayDefaultValue = 0.95D;
6966 private double feasibilityJumpDecay_;
6971 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6972 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6974 get {
if ((_hasBits5 & 536870912) != 0) {
return feasibilityJumpDecay_; }
else {
return FeasibilityJumpDecayDefaultValue; } }
6976 _hasBits5 |= 536870912;
6977 feasibilityJumpDecay_ = value;
6981 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6982 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6984 get {
return (_hasBits5 & 536870912) != 0; }
6987 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6988 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6989 public void ClearFeasibilityJumpDecay() {
6990 _hasBits5 &= ~536870912;
6994 public const int FeasibilityJumpLinearizationLevelFieldNumber = 257;
6995 private readonly
static int FeasibilityJumpLinearizationLevelDefaultValue = 2;
6997 private int feasibilityJumpLinearizationLevel_;
7001 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7002 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7004 get {
if ((_hasBits6 & 128) != 0) {
return feasibilityJumpLinearizationLevel_; }
else {
return FeasibilityJumpLinearizationLevelDefaultValue; } }
7007 feasibilityJumpLinearizationLevel_ = value;
7011 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7012 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7014 get {
return (_hasBits6 & 128) != 0; }
7017 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7018 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7019 public void ClearFeasibilityJumpLinearizationLevel() {
7024 public const int FeasibilityJumpRestartFactorFieldNumber = 258;
7025 private readonly
static int FeasibilityJumpRestartFactorDefaultValue = 1;
7027 private int feasibilityJumpRestartFactor_;
7032 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7033 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7035 get {
if ((_hasBits6 & 256) != 0) {
return feasibilityJumpRestartFactor_; }
else {
return FeasibilityJumpRestartFactorDefaultValue; } }
7038 feasibilityJumpRestartFactor_ = value;
7042 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7043 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7045 get {
return (_hasBits6 & 256) != 0; }
7048 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7049 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7050 public void ClearFeasibilityJumpRestartFactor() {
7055 public const int FeasibilityJumpBatchDtimeFieldNumber = 292;
7056 private readonly
static double FeasibilityJumpBatchDtimeDefaultValue = 0.1D;
7058 private double feasibilityJumpBatchDtime_;
7062 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7063 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7065 get {
if ((_hasBits7 & 1024) != 0) {
return feasibilityJumpBatchDtime_; }
else {
return FeasibilityJumpBatchDtimeDefaultValue; } }
7068 feasibilityJumpBatchDtime_ = value;
7072 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7073 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7075 get {
return (_hasBits7 & 1024) != 0; }
7078 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7079 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7080 public void ClearFeasibilityJumpBatchDtime() {
7085 public const int FeasibilityJumpVarRandomizationProbabilityFieldNumber = 247;
7086 private readonly
static double FeasibilityJumpVarRandomizationProbabilityDefaultValue = 0.05D;
7088 private double feasibilityJumpVarRandomizationProbability_;
7093 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7094 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7096 get {
if ((_hasBits5 & -2147483648) != 0) {
return feasibilityJumpVarRandomizationProbability_; }
else {
return FeasibilityJumpVarRandomizationProbabilityDefaultValue; } }
7098 _hasBits5 |= -2147483648;
7099 feasibilityJumpVarRandomizationProbability_ = value;
7103 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7104 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7106 get {
return (_hasBits5 & -2147483648) != 0; }
7109 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7110 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7111 public void ClearFeasibilityJumpVarRandomizationProbability() {
7112 _hasBits5 &= ~-2147483648;
7116 public const int FeasibilityJumpVarPerburbationRangeRatioFieldNumber = 248;
7117 private readonly
static double FeasibilityJumpVarPerburbationRangeRatioDefaultValue = 0.2D;
7119 private double feasibilityJumpVarPerburbationRangeRatio_;
7124 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7125 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7127 get {
if ((_hasBits6 & 1) != 0) {
return feasibilityJumpVarPerburbationRangeRatio_; }
else {
return FeasibilityJumpVarPerburbationRangeRatioDefaultValue; } }
7130 feasibilityJumpVarPerburbationRangeRatio_ = value;
7134 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7135 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7137 get {
return (_hasBits6 & 1) != 0; }
7140 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7141 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7142 public void ClearFeasibilityJumpVarPerburbationRangeRatio() {
7147 public const int FeasibilityJumpEnableRestartsFieldNumber = 250;
7148 private readonly
static bool FeasibilityJumpEnableRestartsDefaultValue =
true;
7150 private bool feasibilityJumpEnableRestarts_;
7156 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7157 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7159 get {
if ((_hasBits6 & 4) != 0) {
return feasibilityJumpEnableRestarts_; }
else {
return FeasibilityJumpEnableRestartsDefaultValue; } }
7162 feasibilityJumpEnableRestarts_ = value;
7166 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7167 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7168 public bool HasFeasibilityJumpEnableRestarts {
7169 get {
return (_hasBits6 & 4) != 0; }
7172 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7173 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7179 public const int FeasibilityJumpMaxExpandedConstraintSizeFieldNumber = 264;
7180 private readonly
static int FeasibilityJumpMaxExpandedConstraintSizeDefaultValue = 500;
7182 private int feasibilityJumpMaxExpandedConstraintSize_;
7189 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7190 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7192 get {
if ((_hasBits6 & 16384) != 0) {
return feasibilityJumpMaxExpandedConstraintSize_; }
else {
return FeasibilityJumpMaxExpandedConstraintSizeDefaultValue; } }
7195 feasibilityJumpMaxExpandedConstraintSize_ = value;
7199 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7200 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7201 public bool HasFeasibilityJumpMaxExpandedConstraintSize {
7202 get {
return (_hasBits6 & 16384) != 0; }
7205 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7206 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7208 _hasBits6 &= ~16384;
7212 public const int NumViolationLsFieldNumber = 244;
7213 private readonly
static int NumViolationLsDefaultValue = 0;
7215 private int numViolationLs_;
7221 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7222 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7224 get {
if ((_hasBits5 & 1073741824) != 0) {
return numViolationLs_; }
else {
return NumViolationLsDefaultValue; } }
7226 _hasBits5 |= 1073741824;
7227 numViolationLs_ = value;
7231 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7232 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7233 public bool HasNumViolationLs {
7234 get {
return (_hasBits5 & 1073741824) != 0; }
7237 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7238 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7240 _hasBits5 &= ~1073741824;
7244 public const int ViolationLsPerturbationPeriodFieldNumber = 249;
7245 private readonly
static int ViolationLsPerturbationPeriodDefaultValue = 100;
7247 private int violationLsPerturbationPeriod_;
7251 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7252 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7254 get {
if ((_hasBits6 & 2) != 0) {
return violationLsPerturbationPeriod_; }
else {
return ViolationLsPerturbationPeriodDefaultValue; } }
7257 violationLsPerturbationPeriod_ = value;
7261 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7262 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7264 get {
return (_hasBits6 & 2) != 0; }
7267 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7268 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7269 public void ClearViolationLsPerturbationPeriod() {
7274 public const int ViolationLsCompoundMoveProbabilityFieldNumber = 259;
7275 private readonly
static double ViolationLsCompoundMoveProbabilityDefaultValue = 0.5D;
7277 private double violationLsCompoundMoveProbability_;
7282 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7283 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7285 get {
if ((_hasBits6 & 512) != 0) {
return violationLsCompoundMoveProbability_; }
else {
return ViolationLsCompoundMoveProbabilityDefaultValue; } }
7288 violationLsCompoundMoveProbability_ = value;
7292 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7293 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7295 get {
return (_hasBits6 & 512) != 0; }
7298 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7299 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7300 public void ClearViolationLsCompoundMoveProbability() {
7305 public const int SharedTreeNumWorkersFieldNumber = 235;
7306 private readonly
static int SharedTreeNumWorkersDefaultValue = -1;
7308 private int sharedTreeNumWorkers_;
7318 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7319 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7321 get {
if ((_hasBits5 & 16777216) != 0) {
return sharedTreeNumWorkers_; }
else {
return SharedTreeNumWorkersDefaultValue; } }
7323 _hasBits5 |= 16777216;
7324 sharedTreeNumWorkers_ = value;
7328 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7329 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7330 public bool HasSharedTreeNumWorkers {
7331 get {
return (_hasBits5 & 16777216) != 0; }
7334 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7335 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7336 public void ClearSharedTreeNumWorkers() {
7337 _hasBits5 &= ~16777216;
7341 public const int UseSharedTreeSearchFieldNumber = 236;
7342 private readonly
static bool UseSharedTreeSearchDefaultValue =
false;
7344 private bool useSharedTreeSearch_;
7348 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7349 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7351 get {
if ((_hasBits5 & 33554432) != 0) {
return useSharedTreeSearch_; }
else {
return UseSharedTreeSearchDefaultValue; } }
7353 _hasBits5 |= 33554432;
7354 useSharedTreeSearch_ = value;
7358 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7359 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7360 public bool HasUseSharedTreeSearch {
7361 get {
return (_hasBits5 & 33554432) != 0; }
7364 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7365 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7366 public void ClearUseSharedTreeSearch() {
7367 _hasBits5 &= ~33554432;
7371 public const int SharedTreeWorkerMinRestartsPerSubtreeFieldNumber = 282;
7372 private readonly
static int SharedTreeWorkerMinRestartsPerSubtreeDefaultValue = 1;
7374 private int sharedTreeWorkerMinRestartsPerSubtree_;
7379 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7380 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7382 get {
if ((_hasBits7 & 1) != 0) {
return sharedTreeWorkerMinRestartsPerSubtree_; }
else {
return SharedTreeWorkerMinRestartsPerSubtreeDefaultValue; } }
7385 sharedTreeWorkerMinRestartsPerSubtree_ = value;
7389 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7390 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7392 get {
return (_hasBits7 & 1) != 0; }
7395 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7396 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7397 public void ClearSharedTreeWorkerMinRestartsPerSubtree() {
7402 public const int SharedTreeWorkerEnableTrailSharingFieldNumber = 295;
7403 private readonly
static bool SharedTreeWorkerEnableTrailSharingDefaultValue =
true;
7405 private bool sharedTreeWorkerEnableTrailSharing_;
7410 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7411 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7413 get {
if ((_hasBits7 & 4096) != 0) {
return sharedTreeWorkerEnableTrailSharing_; }
else {
return SharedTreeWorkerEnableTrailSharingDefaultValue; } }
7416 sharedTreeWorkerEnableTrailSharing_ = value;
7420 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7421 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7423 get {
return (_hasBits7 & 4096) != 0; }
7426 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7427 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7428 public void ClearSharedTreeWorkerEnableTrailSharing() {
7433 public const int SharedTreeWorkerEnablePhaseSharingFieldNumber = 304;
7434 private readonly
static bool SharedTreeWorkerEnablePhaseSharingDefaultValue =
true;
7436 private bool sharedTreeWorkerEnablePhaseSharing_;
7441 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7442 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7444 get {
if ((_hasBits7 & 2097152) != 0) {
return sharedTreeWorkerEnablePhaseSharing_; }
else {
return SharedTreeWorkerEnablePhaseSharingDefaultValue; } }
7446 _hasBits7 |= 2097152;
7447 sharedTreeWorkerEnablePhaseSharing_ = value;
7451 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7452 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7454 get {
return (_hasBits7 & 2097152) != 0; }
7457 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7458 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7459 public void ClearSharedTreeWorkerEnablePhaseSharing() {
7460 _hasBits7 &= ~2097152;
7464 public const int SharedTreeOpenLeavesPerWorkerFieldNumber = 281;
7465 private readonly
static double SharedTreeOpenLeavesPerWorkerDefaultValue = 2D;
7467 private double sharedTreeOpenLeavesPerWorker_;
7471 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7472 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7474 get {
if ((_hasBits6 & -2147483648) != 0) {
return sharedTreeOpenLeavesPerWorker_; }
else {
return SharedTreeOpenLeavesPerWorkerDefaultValue; } }
7476 _hasBits6 |= -2147483648;
7477 sharedTreeOpenLeavesPerWorker_ = value;
7481 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7482 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7484 get {
return (_hasBits6 & -2147483648) != 0; }
7487 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7488 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7489 public void ClearSharedTreeOpenLeavesPerWorker() {
7490 _hasBits6 &= ~-2147483648;
7494 public const int SharedTreeMaxNodesPerWorkerFieldNumber = 238;
7495 private readonly
static int SharedTreeMaxNodesPerWorkerDefaultValue = 10000;
7497 private int sharedTreeMaxNodesPerWorker_;
7504 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7505 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7507 get {
if ((_hasBits5 & 67108864) != 0) {
return sharedTreeMaxNodesPerWorker_; }
else {
return SharedTreeMaxNodesPerWorkerDefaultValue; } }
7509 _hasBits5 |= 67108864;
7510 sharedTreeMaxNodesPerWorker_ = value;
7514 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7515 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7516 public bool HasSharedTreeMaxNodesPerWorker {
7517 get {
return (_hasBits5 & 67108864) != 0; }
7520 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7521 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7523 _hasBits5 &= ~67108864;
7527 public const int SharedTreeSplitStrategyFieldNumber = 239;
7528 private readonly
static global::Google.OrTools.Sat.SatParameters.Types.SharedTreeSplitStrategy SharedTreeSplitStrategyDefaultValue = global::Google.OrTools.Sat.SatParameters.Types.SharedTreeSplitStrategy.SplitStrategyAuto;
7530 private global::Google.OrTools.Sat.SatParameters.Types.SharedTreeSplitStrategy sharedTreeSplitStrategy_;
7531 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7532 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7534 get {
if ((_hasBits5 & 134217728) != 0) {
return sharedTreeSplitStrategy_; }
else {
return SharedTreeSplitStrategyDefaultValue; } }
7536 _hasBits5 |= 134217728;
7537 sharedTreeSplitStrategy_ = value;
7541 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7542 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7544 get {
return (_hasBits5 & 134217728) != 0; }
7547 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7548 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7549 public void ClearSharedTreeSplitStrategy() {
7550 _hasBits5 &= ~134217728;
7555 private readonly
static int SharedTreeBalanceToleranceDefaultValue = 1;
7557 private int sharedTreeBalanceTolerance_;
7567 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7568 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7570 get {
if ((_hasBits7 & 4194304) != 0) {
return sharedTreeBalanceTolerance_; }
else {
return SharedTreeBalanceToleranceDefaultValue; } }
7572 _hasBits7 |= 4194304;
7573 sharedTreeBalanceTolerance_ = value;
7577 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7578 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7579 public bool HasSharedTreeBalanceTolerance {
7580 get {
return (_hasBits7 & 4194304) != 0; }
7583 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7584 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7585 public void ClearSharedTreeBalanceTolerance() {
7586 _hasBits7 &= ~4194304;
7590 public const int SharedTreeSplitMinDtimeFieldNumber = 328;
7591 private readonly
static double SharedTreeSplitMinDtimeDefaultValue = 0.1D;
7593 private double sharedTreeSplitMinDtime_;
7599 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7600 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7602 get {
if ((_hasBits8 & 4096) != 0) {
return sharedTreeSplitMinDtime_; }
else {
return SharedTreeSplitMinDtimeDefaultValue; } }
7605 sharedTreeSplitMinDtime_ = value;
7609 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7610 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7611 public bool HasSharedTreeSplitMinDtime {
7612 get {
return (_hasBits8 & 4096) != 0; }
7615 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7616 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7622 public const int EnumerateAllSolutionsFieldNumber = 87;
7623 private readonly
static bool EnumerateAllSolutionsDefaultValue =
false;
7625 private bool enumerateAllSolutions_;
7637 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7638 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7640 get {
if ((_hasBits1 & 536870912) != 0) {
return enumerateAllSolutions_; }
else {
return EnumerateAllSolutionsDefaultValue; } }
7642 _hasBits1 |= 536870912;
7643 enumerateAllSolutions_ = value;
7647 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7648 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7650 get {
return (_hasBits1 & 536870912) != 0; }
7653 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7654 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7655 public void ClearEnumerateAllSolutions() {
7656 _hasBits1 &= ~536870912;
7661 private readonly
static bool KeepAllFeasibleSolutionsInPresolveDefaultValue =
false;
7663 private bool keepAllFeasibleSolutionsInPresolve_;
7674 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7675 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7677 get {
if ((_hasBits4 & 32) != 0) {
return keepAllFeasibleSolutionsInPresolve_; }
else {
return KeepAllFeasibleSolutionsInPresolveDefaultValue; } }
7680 keepAllFeasibleSolutionsInPresolve_ = value;
7684 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7685 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7686 public bool HasKeepAllFeasibleSolutionsInPresolve {
7687 get {
return (_hasBits4 & 32) != 0; }
7690 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7691 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7692 public void ClearKeepAllFeasibleSolutionsInPresolve() {
7697 public const int FillTightenedDomainsInResponseFieldNumber = 132;
7698 private readonly
static bool FillTightenedDomainsInResponseDefaultValue =
false;
7700 private bool fillTightenedDomainsInResponse_;
7708 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7709 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7711 get {
if ((_hasBits3 & 16) != 0) {
return fillTightenedDomainsInResponse_; }
else {
return FillTightenedDomainsInResponseDefaultValue; } }
7714 fillTightenedDomainsInResponse_ = value;
7718 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7719 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7720 public bool HasFillTightenedDomainsInResponse {
7721 get {
return (_hasBits3 & 16) != 0; }
7724 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7725 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7731 public const int FillAdditionalSolutionsInResponseFieldNumber = 194;
7732 private readonly
static bool FillAdditionalSolutionsInResponseDefaultValue =
false;
7734 private bool fillAdditionalSolutionsInResponse_;
7747 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7748 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7750 get {
if ((_hasBits4 & 16777216) != 0) {
return fillAdditionalSolutionsInResponse_; }
else {
return FillAdditionalSolutionsInResponseDefaultValue; } }
7752 _hasBits4 |= 16777216;
7753 fillAdditionalSolutionsInResponse_ = value;
7757 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7758 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7759 public bool HasFillAdditionalSolutionsInResponse {
7760 get {
return (_hasBits4 & 16777216) != 0; }
7763 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7764 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7765 public void ClearFillAdditionalSolutionsInResponse() {
7766 _hasBits4 &= ~16777216;
7771 private readonly
static bool InstantiateAllVariablesDefaultValue =
true;
7773 private bool instantiateAllVariables_;
7780 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7781 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7783 get {
if ((_hasBits2 & 4096) != 0) {
return instantiateAllVariables_; }
else {
return InstantiateAllVariablesDefaultValue; } }
7786 instantiateAllVariables_ = value;
7790 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7791 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7792 public bool HasInstantiateAllVariables {
7793 get {
return (_hasBits2 & 4096) != 0; }
7796 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7797 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7798 public void ClearInstantiateAllVariables() {
7804 private readonly
static bool AutoDetectGreaterThanAtLeastOneOfDefaultValue =
true;
7806 private bool autoDetectGreaterThanAtLeastOneOf_;
7813 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7814 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7816 get {
if ((_hasBits2 & 32) != 0) {
return autoDetectGreaterThanAtLeastOneOf_; }
else {
return AutoDetectGreaterThanAtLeastOneOfDefaultValue; } }
7819 autoDetectGreaterThanAtLeastOneOf_ = value;
7823 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7824 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7826 get {
return (_hasBits2 & 32) != 0; }
7829 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7830 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7831 public void ClearAutoDetectGreaterThanAtLeastOneOf() {
7837 private readonly
static bool StopAfterFirstSolutionDefaultValue =
false;
7839 private bool stopAfterFirstSolution_;
7843 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7844 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7846 get {
if ((_hasBits2 & 64) != 0) {
return stopAfterFirstSolution_; }
else {
return StopAfterFirstSolutionDefaultValue; } }
7849 stopAfterFirstSolution_ = value;
7853 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7854 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7856 get {
return (_hasBits2 & 64) != 0; }
7859 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7860 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7861 public void ClearStopAfterFirstSolution() {
7866 public const int StopAfterPresolveFieldNumber = 149;
7867 private readonly
static bool StopAfterPresolveDefaultValue =
false;
7869 private bool stopAfterPresolve_;
7874 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7875 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7877 get {
if ((_hasBits3 & 65536) != 0) {
return stopAfterPresolve_; }
else {
return StopAfterPresolveDefaultValue; } }
7880 stopAfterPresolve_ = value;
7884 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7885 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7887 get {
return (_hasBits3 & 65536) != 0; }
7890 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7891 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7892 public void ClearStopAfterPresolve() {
7893 _hasBits3 &= ~65536;
7898 private readonly
static bool StopAfterRootPropagationDefaultValue =
false;
7900 private bool stopAfterRootPropagation_;
7901 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7902 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7904 get {
if ((_hasBits6 & 8) != 0) {
return stopAfterRootPropagation_; }
else {
return StopAfterRootPropagationDefaultValue; } }
7907 stopAfterRootPropagation_ = value;
7911 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7912 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7914 get {
return (_hasBits6 & 8) != 0; }
7917 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7918 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7924 public const int LnsInitialDifficultyFieldNumber = 307;
7925 private readonly
static double LnsInitialDifficultyDefaultValue = 0.5D;
7927 private double lnsInitialDifficulty_;
7931 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7932 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7934 get {
if ((_hasBits7 & 16777216) != 0) {
return lnsInitialDifficulty_; }
else {
return LnsInitialDifficultyDefaultValue; } }
7936 _hasBits7 |= 16777216;
7937 lnsInitialDifficulty_ = value;
7941 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7942 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7943 public bool HasLnsInitialDifficulty {
7944 get {
return (_hasBits7 & 16777216) != 0; }
7947 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7948 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7950 _hasBits7 &= ~16777216;
7954 public const int LnsInitialDeterministicLimitFieldNumber = 308;
7955 private readonly
static double LnsInitialDeterministicLimitDefaultValue = 0.1D;
7957 private double lnsInitialDeterministicLimit_;
7958 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7959 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7961 get {
if ((_hasBits7 & 33554432) != 0) {
return lnsInitialDeterministicLimit_; }
else {
return LnsInitialDeterministicLimitDefaultValue; } }
7963 _hasBits7 |= 33554432;
7964 lnsInitialDeterministicLimit_ = value;
7968 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7969 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7970 public bool HasLnsInitialDeterministicLimit {
7971 get {
return (_hasBits7 & 33554432) != 0; }
7974 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7975 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7977 _hasBits7 &= ~33554432;
7981 public const int UseLnsFieldNumber = 283;
7982 private readonly
static bool UseLnsDefaultValue =
true;
7984 private bool useLns_;
7988 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7989 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7991 get {
if ((_hasBits7 & 2) != 0) {
return useLns_; }
else {
return UseLnsDefaultValue; } }
7998 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7999 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8000 public bool HasUseLns {
8001 get {
return (_hasBits7 & 2) != 0; }
8004 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8005 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8011 public const int UseLnsOnlyFieldNumber = 101;
8012 private readonly
static bool UseLnsOnlyDefaultValue =
false;
8014 private bool useLnsOnly_;
8018 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8019 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8021 get {
if ((_hasBits2 & 512) != 0) {
return useLnsOnly_; }
else {
return UseLnsOnlyDefaultValue; } }
8024 useLnsOnly_ = value;
8028 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8029 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8031 get {
return (_hasBits2 & 512) != 0; }
8034 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8035 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8041 public const int SolutionPoolSizeFieldNumber = 193;
8042 private readonly
static int SolutionPoolSizeDefaultValue = 3;
8044 private int solutionPoolSize_;
8050 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8051 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8053 get {
if ((_hasBits4 & 8388608) != 0) {
return solutionPoolSize_; }
else {
return SolutionPoolSizeDefaultValue; } }
8055 _hasBits4 |= 8388608;
8056 solutionPoolSize_ = value;
8060 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8061 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8062 public bool HasSolutionPoolSize {
8063 get {
return (_hasBits4 & 8388608) != 0; }
8066 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8067 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8068 public void ClearSolutionPoolSize() {
8069 _hasBits4 &= ~8388608;
8074 private readonly
static int SolutionPoolDiversityLimitDefaultValue = 10;
8076 private int solutionPoolDiversityLimit_;
8083 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8084 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8086 get {
if ((_hasBits8 & 8192) != 0) {
return solutionPoolDiversityLimit_; }
else {
return SolutionPoolDiversityLimitDefaultValue; } }
8089 solutionPoolDiversityLimit_ = value;
8093 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8094 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8096 get {
return (_hasBits8 & 8192) != 0; }
8099 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8100 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8101 public void ClearSolutionPoolDiversityLimit() {
8107 private readonly
static int AlternativePoolSizeDefaultValue = 1;
8109 private int alternativePoolSize_;
8115 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8116 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8118 get {
if ((_hasBits8 & 512) != 0) {
return alternativePoolSize_; }
else {
return AlternativePoolSizeDefaultValue; } }
8121 alternativePoolSize_ = value;
8125 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8126 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8128 get {
return (_hasBits8 & 512) != 0; }
8131 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8132 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8133 public void ClearAlternativePoolSize() {
8139 private readonly
static bool UseRinsLnsDefaultValue =
true;
8141 private bool useRinsLns_;
8145 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8146 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8148 get {
if ((_hasBits3 & 2) != 0) {
return useRinsLns_; }
else {
return UseRinsLnsDefaultValue; } }
8151 useRinsLns_ = value;
8155 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8156 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8157 public bool HasUseRinsLns {
8158 get {
return (_hasBits3 & 2) != 0; }
8161 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8162 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8163 public void ClearUseRinsLns() {
8168 public const int UseFeasibilityPumpFieldNumber = 164;
8169 private readonly
static bool UseFeasibilityPumpDefaultValue =
true;
8171 private bool useFeasibilityPump_;
8175 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8176 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8178 get {
if ((_hasBits3 & 536870912) != 0) {
return useFeasibilityPump_; }
else {
return UseFeasibilityPumpDefaultValue; } }
8180 _hasBits3 |= 536870912;
8181 useFeasibilityPump_ = value;
8185 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8186 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8188 get {
return (_hasBits3 & 536870912) != 0; }
8191 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8192 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8194 _hasBits3 &= ~536870912;
8198 public const int UseLbRelaxLnsFieldNumber = 255;
8199 private readonly
static bool UseLbRelaxLnsDefaultValue =
true;
8201 private bool useLbRelaxLns_;
8207 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8208 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8210 get {
if ((_hasBits6 & 32) != 0) {
return useLbRelaxLns_; }
else {
return UseLbRelaxLnsDefaultValue; } }
8213 useLbRelaxLns_ = value;
8217 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8218 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8219 public bool HasUseLbRelaxLns {
8220 get {
return (_hasBits6 & 32) != 0; }
8223 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8224 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8225 public void ClearUseLbRelaxLns() {
8231 private readonly
static int LbRelaxNumWorkersThresholdDefaultValue = 16;
8233 private int lbRelaxNumWorkersThreshold_;
8237 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8238 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8240 get {
if ((_hasBits7 & 8192) != 0) {
return lbRelaxNumWorkersThreshold_; }
else {
return LbRelaxNumWorkersThresholdDefaultValue; } }
8243 lbRelaxNumWorkersThreshold_ = value;
8247 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8248 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8249 public bool HasLbRelaxNumWorkersThreshold {
8250 get {
return (_hasBits7 & 8192) != 0; }
8253 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8254 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8255 public void ClearLbRelaxNumWorkersThreshold() {
8260 public const int FpRoundingFieldNumber = 165;
8261 private readonly
static global::Google.OrTools.Sat.SatParameters.Types.FPRoundingMethod FpRoundingDefaultValue = global::Google.OrTools.Sat.SatParameters.Types.FPRoundingMethod.PropagationAssisted;
8263 private global::Google.OrTools.Sat.SatParameters.Types.FPRoundingMethod fpRounding_;
8264 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8265 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8266 public global::Google.OrTools.Sat.SatParameters.Types.FPRoundingMethod
FpRounding {
8267 get {
if ((_hasBits3 & 1073741824) != 0) {
return fpRounding_; }
else {
return FpRoundingDefaultValue; } }
8269 _hasBits3 |= 1073741824;
8270 fpRounding_ = value;
8274 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8275 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8276 public bool HasFpRounding {
8277 get {
return (_hasBits3 & 1073741824) != 0; }
8280 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8281 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8283 _hasBits3 &= ~1073741824;
8287 public const int DiversifyLnsParamsFieldNumber = 137;
8288 private readonly
static bool DiversifyLnsParamsDefaultValue =
false;
8290 private bool diversifyLnsParams_;
8294 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8295 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8297 get {
if ((_hasBits3 & 512) != 0) {
return diversifyLnsParams_; }
else {
return DiversifyLnsParamsDefaultValue; } }
8300 diversifyLnsParams_ = value;
8304 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8305 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8306 public bool HasDiversifyLnsParams {
8307 get {
return (_hasBits3 & 512) != 0; }
8310 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8311 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8317 public const int RandomizeSearchFieldNumber = 103;
8318 private readonly
static bool RandomizeSearchDefaultValue =
false;
8320 private bool randomizeSearch_;
8324 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8325 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8327 get {
if ((_hasBits2 & 1024) != 0) {
return randomizeSearch_; }
else {
return RandomizeSearchDefaultValue; } }
8330 randomizeSearch_ = value;
8334 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8335 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8337 get {
return (_hasBits2 & 1024) != 0; }
8340 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8341 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8347 public const int SearchRandomVariablePoolSizeFieldNumber = 104;
8348 private readonly
static long SearchRandomVariablePoolSizeDefaultValue = 0L;
8350 private long searchRandomVariablePoolSize_;
8356 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8357 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8359 get {
if ((_hasBits2 & 2048) != 0) {
return searchRandomVariablePoolSize_; }
else {
return SearchRandomVariablePoolSizeDefaultValue; } }
8362 searchRandomVariablePoolSize_ = value;
8366 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8367 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8368 public bool HasSearchRandomVariablePoolSize {
8369 get {
return (_hasBits2 & 2048) != 0; }
8372 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8373 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8374 public void ClearSearchRandomVariablePoolSize() {
8380 private readonly
static bool PushAllTasksTowardStartDefaultValue =
false;
8382 private bool pushAllTasksTowardStart_;
8387 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8388 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8390 get {
if ((_hasBits6 & 4096) != 0) {
return pushAllTasksTowardStart_; }
else {
return PushAllTasksTowardStartDefaultValue; } }
8393 pushAllTasksTowardStart_ = value;
8397 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8398 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8400 get {
return (_hasBits6 & 4096) != 0; }
8403 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8404 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8405 public void ClearPushAllTasksTowardStart() {
8411 private readonly
static bool UseOptionalVariablesDefaultValue =
false;
8413 private bool useOptionalVariables_;
8422 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8423 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8425 get {
if ((_hasBits2 & 16384) != 0) {
return useOptionalVariables_; }
else {
return UseOptionalVariablesDefaultValue; } }
8428 useOptionalVariables_ = value;
8432 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8433 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8435 get {
return (_hasBits2 & 16384) != 0; }
8438 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8439 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8440 public void ClearUseOptionalVariables() {
8441 _hasBits2 &= ~16384;
8445 public const int UseExactLpReasonFieldNumber = 109;
8446 private readonly
static bool UseExactLpReasonDefaultValue =
true;
8448 private bool useExactLpReason_;
8455 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8456 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8458 get {
if ((_hasBits2 & 32768) != 0) {
return useExactLpReason_; }
else {
return UseExactLpReasonDefaultValue; } }
8461 useExactLpReason_ = value;
8465 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8466 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8467 public bool HasUseExactLpReason {
8468 get {
return (_hasBits2 & 32768) != 0; }
8471 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8472 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8473 public void ClearUseExactLpReason() {
8474 _hasBits2 &= ~32768;
8479 private readonly
static bool UseCombinedNoOverlapDefaultValue =
false;
8481 private bool useCombinedNoOverlap_;
8487 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8488 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8490 get {
if ((_hasBits3 & 32) != 0) {
return useCombinedNoOverlap_; }
else {
return UseCombinedNoOverlapDefaultValue; } }
8493 useCombinedNoOverlap_ = value;
8497 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8498 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8500 get {
return (_hasBits3 & 32) != 0; }
8503 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8504 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8505 public void ClearUseCombinedNoOverlap() {
8511 private readonly
static int AtMostOneMaxExpansionSizeDefaultValue = 3;
8513 private int atMostOneMaxExpansionSize_;
8518 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8519 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8521 get {
if ((_hasBits6 & 1048576) != 0) {
return atMostOneMaxExpansionSize_; }
else {
return AtMostOneMaxExpansionSizeDefaultValue; } }
8523 _hasBits6 |= 1048576;
8524 atMostOneMaxExpansionSize_ = value;
8528 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8529 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8530 public bool HasAtMostOneMaxExpansionSize {
8531 get {
return (_hasBits6 & 1048576) != 0; }
8534 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8535 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8536 public void ClearAtMostOneMaxExpansionSize() {
8537 _hasBits6 &= ~1048576;
8541 public const int CatchSigintSignalFieldNumber = 135;
8542 private readonly
static bool CatchSigintSignalDefaultValue =
true;
8544 private bool catchSigintSignal_;
8550 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8551 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8553 get {
if ((_hasBits3 & 128) != 0) {
return catchSigintSignal_; }
else {
return CatchSigintSignalDefaultValue; } }
8556 catchSigintSignal_ = value;
8560 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8561 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8562 public bool HasCatchSigintSignal {
8563 get {
return (_hasBits3 & 128) != 0; }
8566 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8567 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8568 public void ClearCatchSigintSignal() {
8574 private readonly
static bool UseImpliedBoundsDefaultValue =
true;
8576 private bool useImpliedBounds_;
8582 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8583 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8585 get {
if ((_hasBits3 & 2048) != 0) {
return useImpliedBounds_; }
else {
return UseImpliedBoundsDefaultValue; } }
8588 useImpliedBounds_ = value;
8592 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8593 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8595 get {
return (_hasBits3 & 2048) != 0; }
8598 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8599 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8600 public void ClearUseImpliedBounds() {
8606 private readonly
static bool PolishLpSolutionDefaultValue =
false;
8608 private bool polishLpSolution_;
8615 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8616 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8618 get {
if ((_hasBits4 & 128) != 0) {
return polishLpSolution_; }
else {
return PolishLpSolutionDefaultValue; } }
8621 polishLpSolution_ = value;
8625 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8626 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8628 get {
return (_hasBits4 & 128) != 0; }
8631 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8632 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8633 public void ClearPolishLpSolution() {
8639 private readonly
static double LpPrimalToleranceDefaultValue = 1e-07D;
8641 private double lpPrimalTolerance_;
8649 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8650 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8652 get {
if ((_hasBits6 & 65536) != 0) {
return lpPrimalTolerance_; }
else {
return LpPrimalToleranceDefaultValue; } }
8655 lpPrimalTolerance_ = value;
8659 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8660 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8662 get {
return (_hasBits6 & 65536) != 0; }
8665 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8666 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8667 public void ClearLpPrimalTolerance() {
8668 _hasBits6 &= ~65536;
8673 private readonly
static double LpDualToleranceDefaultValue = 1e-07D;
8675 private double lpDualTolerance_;
8676 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8677 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8679 get {
if ((_hasBits6 & 131072) != 0) {
return lpDualTolerance_; }
else {
return LpDualToleranceDefaultValue; } }
8681 _hasBits6 |= 131072;
8682 lpDualTolerance_ = value;
8686 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8687 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8689 get {
return (_hasBits6 & 131072) != 0; }
8692 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8693 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8695 _hasBits6 &= ~131072;
8699 public const int ConvertIntervalsFieldNumber = 177;
8700 private readonly
static bool ConvertIntervalsDefaultValue =
true;
8702 private bool convertIntervals_;
8708 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8709 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8711 get {
if ((_hasBits4 & 512) != 0) {
return convertIntervals_; }
else {
return ConvertIntervalsDefaultValue; } }
8714 convertIntervals_ = value;
8718 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8719 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8721 get {
return (_hasBits4 & 512) != 0; }
8724 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8725 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8732 private readonly
static int SymmetryLevelDefaultValue = 2;
8734 private int symmetryLevel_;
8743 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8744 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8746 get {
if ((_hasBits4 & 32768) != 0) {
return symmetryLevel_; }
else {
return SymmetryLevelDefaultValue; } }
8749 symmetryLevel_ = value;
8753 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8754 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8756 get {
return (_hasBits4 & 32768) != 0; }
8759 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8760 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8761 public void ClearSymmetryLevel() {
8762 _hasBits4 &= ~32768;
8766 public const int UseSymmetryInLpFieldNumber = 301;
8767 private readonly
static bool UseSymmetryInLpDefaultValue =
false;
8769 private bool useSymmetryInLp_;
8777 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8778 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8780 get {
if ((_hasBits7 & 262144) != 0) {
return useSymmetryInLp_; }
else {
return UseSymmetryInLpDefaultValue; } }
8782 _hasBits7 |= 262144;
8783 useSymmetryInLp_ = value;
8787 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8788 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8789 public bool HasUseSymmetryInLp {
8790 get {
return (_hasBits7 & 262144) != 0; }
8793 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8794 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8795 public void ClearUseSymmetryInLp() {
8796 _hasBits7 &= ~262144;
8801 private readonly
static bool KeepSymmetryInPresolveDefaultValue =
false;
8803 private bool keepSymmetryInPresolve_;
8810 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8811 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8813 get {
if ((_hasBits7 & 1048576) != 0) {
return keepSymmetryInPresolve_; }
else {
return KeepSymmetryInPresolveDefaultValue; } }
8815 _hasBits7 |= 1048576;
8816 keepSymmetryInPresolve_ = value;
8820 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8821 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8823 get {
return (_hasBits7 & 1048576) != 0; }
8826 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8827 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8828 public void ClearKeepSymmetryInPresolve() {
8829 _hasBits7 &= ~1048576;
8834 private readonly
static double SymmetryDetectionDeterministicTimeLimitDefaultValue = 1D;
8836 private double symmetryDetectionDeterministicTimeLimit_;
8840 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8841 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8843 get {
if ((_hasBits7 & 524288) != 0) {
return symmetryDetectionDeterministicTimeLimit_; }
else {
return SymmetryDetectionDeterministicTimeLimitDefaultValue; } }
8845 _hasBits7 |= 524288;
8846 symmetryDetectionDeterministicTimeLimit_ = value;
8850 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8851 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8852 public bool HasSymmetryDetectionDeterministicTimeLimit {
8853 get {
return (_hasBits7 & 524288) != 0; }
8856 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8857 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8858 public void ClearSymmetryDetectionDeterministicTimeLimit() {
8859 _hasBits7 &= ~524288;
8863 public const int NewLinearPropagationFieldNumber = 224;
8864 private readonly
static bool NewLinearPropagationDefaultValue =
true;
8866 private bool newLinearPropagation_;
8872 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8873 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8875 get {
if ((_hasBits5 & 16384) != 0) {
return newLinearPropagation_; }
else {
return NewLinearPropagationDefaultValue; } }
8878 newLinearPropagation_ = value;
8882 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8883 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8885 get {
return (_hasBits5 & 16384) != 0; }
8888 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8889 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8890 public void ClearNewLinearPropagation() {
8891 _hasBits5 &= ~16384;
8896 private readonly
static int LinearSplitSizeDefaultValue = 100;
8898 private int linearSplitSize_;
8904 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8905 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8907 get {
if ((_hasBits6 & 64) != 0) {
return linearSplitSize_; }
else {
return LinearSplitSizeDefaultValue; } }
8910 linearSplitSize_ = value;
8914 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8915 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8917 get {
return (_hasBits6 & 64) != 0; }
8920 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8921 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8922 public void ClearLinearSplitSize() {
8928 private readonly
static int LinearizationLevelDefaultValue = 1;
8930 private int linearizationLevel_;
8937 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8938 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8940 get {
if ((_hasBits2 & 1) != 0) {
return linearizationLevel_; }
else {
return LinearizationLevelDefaultValue; } }
8943 linearizationLevel_ = value;
8947 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8948 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8950 get {
return (_hasBits2 & 1) != 0; }
8953 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8954 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8955 public void ClearLinearizationLevel() {
8961 private readonly
static int BooleanEncodingLevelDefaultValue = 1;
8963 private int booleanEncodingLevel_;
8968 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8969 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8971 get {
if ((_hasBits2 & 8192) != 0) {
return booleanEncodingLevel_; }
else {
return BooleanEncodingLevelDefaultValue; } }
8974 booleanEncodingLevel_ = value;
8978 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8979 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8981 get {
return (_hasBits2 & 8192) != 0; }
8984 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8985 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8986 public void ClearBooleanEncodingLevel() {
8991 public const int MaxDomainSizeWhenEncodingEqNeqConstraintsFieldNumber = 191;
8992 private readonly
static int MaxDomainSizeWhenEncodingEqNeqConstraintsDefaultValue = 16;
8994 private int maxDomainSizeWhenEncodingEqNeqConstraints_;
9001 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
9002 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
9004 get {
if ((_hasBits4 & 2097152) != 0) {
return maxDomainSizeWhenEncodingEqNeqConstraints_; }
else {
return MaxDomainSizeWhenEncodingEqNeqConstraintsDefaultValue; } }
9006 _hasBits4 |= 2097152;
9007 maxDomainSizeWhenEncodingEqNeqConstraints_ = value;
9011 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
9012 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
9014 get {
return (_hasBits4 & 2097152) != 0; }
9017 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
9018 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
9019 public void ClearMaxDomainSizeWhenEncodingEqNeqConstraints() {
9020 _hasBits4 &= ~2097152;
9025 private readonly
static int MaxNumCutsDefaultValue = 10000;
9027 private int maxNumCuts_;
9035 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
9036 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
9038 get {
if ((_hasBits2 & 2) != 0) {
return maxNumCuts_; }
else {
return MaxNumCutsDefaultValue; } }
9041 maxNumCuts_ = value;
9045 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
9046 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
9048 get {
return (_hasBits2 & 2) != 0; }
9051 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
9052 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
9053 public void ClearMaxNumCuts() {
9059 private readonly
static int CutLevelDefaultValue = 1;
9061 private int cutLevel_;
9067 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
9068 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
9070 get {
if ((_hasBits4 & 67108864) != 0) {
return cutLevel_; }
else {
return CutLevelDefaultValue; } }
9072 _hasBits4 |= 67108864;
9077 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
9078 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
9080 get {
return (_hasBits4 & 67108864) != 0; }
9083 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
9084 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
9085 public void ClearCutLevel() {
9086 _hasBits4 &= ~67108864;
9090 public const int OnlyAddCutsAtLevelZeroFieldNumber = 92;
9091 private readonly
static bool OnlyAddCutsAtLevelZeroDefaultValue =
false;
9093 private bool onlyAddCutsAtLevelZero_;
9098 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
9099 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
9101 get {
if ((_hasBits2 & 4) != 0) {
return onlyAddCutsAtLevelZero_; }
else {
return OnlyAddCutsAtLevelZeroDefaultValue; } }
9104 onlyAddCutsAtLevelZero_ = value;
9108 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
9109 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
9111 get {
return (_hasBits2 & 4) != 0; }
9114 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
9115 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
9116 public void ClearOnlyAddCutsAtLevelZero() {
9121 public const int AddObjectiveCutFieldNumber = 197;
9122 private readonly
static bool AddObjectiveCutDefaultValue =
false;
9124 private bool addObjectiveCut_;
9132 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
9133 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
9135 get {
if ((_hasBits4 & 134217728) != 0) {
return addObjectiveCut_; }
else {
return AddObjectiveCutDefaultValue; } }
9137 _hasBits4 |= 134217728;
9138 addObjectiveCut_ = value;
9142 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
9143 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
9145 get {
return (_hasBits4 & 134217728) != 0; }
9148 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
9149 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
9150 public void ClearAddObjectiveCut() {
9151 _hasBits4 &= ~134217728;
9156 private readonly
static bool AddCgCutsDefaultValue =
true;
9158 private bool addCgCuts_;
9163 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
9164 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
9166 get {
if ((_hasBits2 & 4194304) != 0) {
return addCgCuts_; }
else {
return AddCgCutsDefaultValue; } }
9168 _hasBits2 |= 4194304;
9173 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
9174 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
9176 get {
return (_hasBits2 & 4194304) != 0; }
9179 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
9180 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
9181 public void ClearAddCgCuts() {
9182 _hasBits2 &= ~4194304;
9186 public const int AddMirCutsFieldNumber = 120;
9187 private readonly
static bool AddMirCutsDefaultValue =
true;
9189 private bool addMirCuts_;
9194 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
9195 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
9197 get {
if ((_hasBits2 & 16777216) != 0) {
return addMirCuts_; }
else {
return AddMirCutsDefaultValue; } }
9199 _hasBits2 |= 16777216;
9200 addMirCuts_ = value;
9204 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
9205 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
9207 get {
return (_hasBits2 & 16777216) != 0; }
9210 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
9211 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
9213 _hasBits2 &= ~16777216;
9217 public const int AddZeroHalfCutsFieldNumber = 169;
9218 private readonly
static bool AddZeroHalfCutsDefaultValue =
true;
9220 private bool addZeroHalfCuts_;
9225 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
9226 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
9228 get {
if ((_hasBits4 & 4) != 0) {
return addZeroHalfCuts_; }
else {
return AddZeroHalfCutsDefaultValue; } }
9231 addZeroHalfCuts_ = value;
9235 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
9236 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
9238 get {
return (_hasBits4 & 4) != 0; }
9241 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
9242 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
9248 public const int AddCliqueCutsFieldNumber = 172;
9249 private readonly
static bool AddCliqueCutsDefaultValue =
true;
9251 private bool addCliqueCuts_;
9257 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
9258 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
9260 get {
if ((_hasBits4 & 16) != 0) {
return addCliqueCuts_; }
else {
return AddCliqueCutsDefaultValue; } }
9263 addCliqueCuts_ = value;
9267 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
9268 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
9270 get {
return (_hasBits4 & 16) != 0; }
9273 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
9274 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
9275 public void ClearAddCliqueCuts() {
9280 public const int AddRltCutsFieldNumber = 279;
9281 private readonly
static bool AddRltCutsDefaultValue =
true;
9283 private bool addRltCuts_;
9288 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
9289 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
9291 get {
if ((_hasBits6 & 536870912) != 0) {
return addRltCuts_; }
else {
return AddRltCutsDefaultValue; } }
9293 _hasBits6 |= 536870912;
9294 addRltCuts_ = value;
9298 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
9299 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
9301 get {
return (_hasBits6 & 536870912) != 0; }
9304 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
9305 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
9306 public void ClearAddRltCuts() {
9307 _hasBits6 &= ~536870912;
9311 public const int MaxAllDiffCutSizeFieldNumber = 148;
9312 private readonly
static int MaxAllDiffCutSizeDefaultValue = 64;
9314 private int maxAllDiffCutSize_;
9320 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
9321 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
9323 get {
if ((_hasBits3 & 32768) != 0) {
return maxAllDiffCutSize_; }
else {
return MaxAllDiffCutSizeDefaultValue; } }
9326 maxAllDiffCutSize_ = value;
9330 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
9331 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
9333 get {
return (_hasBits3 & 32768) != 0; }
9336 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
9337 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
9338 public void ClearMaxAllDiffCutSize() {
9339 _hasBits3 &= ~32768;
9343 public const int AddLinMaxCutsFieldNumber = 152;
9344 private readonly
static bool AddLinMaxCutsDefaultValue =
true;
9346 private bool addLinMaxCuts_;
9352 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
9353 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
9355 get {
if ((_hasBits3 & 262144) != 0) {
return addLinMaxCuts_; }
else {
return AddLinMaxCutsDefaultValue; } }
9357 _hasBits3 |= 262144;
9358 addLinMaxCuts_ = value;
9362 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
9363 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
9364 public bool HasAddLinMaxCuts {
9365 get {
return (_hasBits3 & 262144) != 0; }
9368 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
9369 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
9370 public void ClearAddLinMaxCuts() {
9371 _hasBits3 &= ~262144;
9375 public const int MaxIntegerRoundingScalingFieldNumber = 119;
9376 private readonly
static int MaxIntegerRoundingScalingDefaultValue = 600;
9378 private int maxIntegerRoundingScaling_;
9389 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
9390 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
9392 get {
if ((_hasBits2 & 8388608) != 0) {
return maxIntegerRoundingScaling_; }
else {
return MaxIntegerRoundingScalingDefaultValue; } }
9394 _hasBits2 |= 8388608;
9395 maxIntegerRoundingScaling_ = value;
9399 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
9400 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
9401 public bool HasMaxIntegerRoundingScaling {
9402 get {
return (_hasBits2 & 8388608) != 0; }
9405 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
9406 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
9407 public void ClearMaxIntegerRoundingScaling() {
9408 _hasBits2 &= ~8388608;
9412 public const int AddLpConstraintsLazilyFieldNumber = 112;
9413 private readonly
static bool AddLpConstraintsLazilyDefaultValue =
true;
9415 private bool addLpConstraintsLazily_;
9422 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
9423 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
9425 get {
if ((_hasBits2 & 131072) != 0) {
return addLpConstraintsLazily_; }
else {
return AddLpConstraintsLazilyDefaultValue; } }
9427 _hasBits2 |= 131072;
9428 addLpConstraintsLazily_ = value;
9432 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
9433 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
9434 public bool HasAddLpConstraintsLazily {
9435 get {
return (_hasBits2 & 131072) != 0; }
9438 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
9439 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
9440 public void ClearAddLpConstraintsLazily() {
9441 _hasBits2 &= ~131072;
9445 public const int RootLpIterationsFieldNumber = 227;
9446 private readonly
static int RootLpIterationsDefaultValue = 2000;
9448 private int rootLpIterations_;
9455 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
9456 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
9458 get {
if ((_hasBits5 & 131072) != 0) {
return rootLpIterations_; }
else {
return RootLpIterationsDefaultValue; } }
9460 _hasBits5 |= 131072;
9461 rootLpIterations_ = value;
9465 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
9466 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
9468 get {
return (_hasBits5 & 131072) != 0; }
9471 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
9472 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
9473 public void ClearRootLpIterations() {
9474 _hasBits5 &= ~131072;
9478 public const int MinOrthogonalityForLpConstraintsFieldNumber = 115;
9479 private readonly
static double MinOrthogonalityForLpConstraintsDefaultValue = 0.05D;
9481 private double minOrthogonalityForLpConstraints_;
9489 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
9490 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
9492 get {
if ((_hasBits2 & 1048576) != 0) {
return minOrthogonalityForLpConstraints_; }
else {
return MinOrthogonalityForLpConstraintsDefaultValue; } }
9494 _hasBits2 |= 1048576;
9495 minOrthogonalityForLpConstraints_ = value;
9499 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
9500 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
9502 get {
return (_hasBits2 & 1048576) != 0; }
9505 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
9506 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
9507 public void ClearMinOrthogonalityForLpConstraints() {
9508 _hasBits2 &= ~1048576;
9513 private readonly
static int MaxCutRoundsAtLevelZeroDefaultValue = 1;
9515 private int maxCutRoundsAtLevelZero_;
9519 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
9520 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
9522 get {
if ((_hasBits3 & 1048576) != 0) {
return maxCutRoundsAtLevelZero_; }
else {
return MaxCutRoundsAtLevelZeroDefaultValue; } }
9524 _hasBits3 |= 1048576;
9525 maxCutRoundsAtLevelZero_ = value;
9529 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
9530 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
9532 get {
return (_hasBits3 & 1048576) != 0; }
9535 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
9536 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
9537 public void ClearMaxCutRoundsAtLevelZero() {
9538 _hasBits3 &= ~1048576;
9542 public const int MaxConsecutiveInactiveCountFieldNumber = 121;
9543 private readonly
static int MaxConsecutiveInactiveCountDefaultValue = 100;
9545 private int maxConsecutiveInactiveCount_;
9551 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
9552 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
9554 get {
if ((_hasBits2 & 33554432) != 0) {
return maxConsecutiveInactiveCount_; }
else {
return MaxConsecutiveInactiveCountDefaultValue; } }
9556 _hasBits2 |= 33554432;
9557 maxConsecutiveInactiveCount_ = value;
9561 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
9562 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
9564 get {
return (_hasBits2 & 33554432) != 0; }
9567 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
9568 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
9570 _hasBits2 &= ~33554432;
9574 public const int CutMaxActiveCountValueFieldNumber = 155;
9575 private readonly
static double CutMaxActiveCountValueDefaultValue = 1e+10D;
9577 private double cutMaxActiveCountValue_;
9583 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
9584 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
9586 get {
if ((_hasBits3 & 2097152) != 0) {
return cutMaxActiveCountValue_; }
else {
return CutMaxActiveCountValueDefaultValue; } }
9588 _hasBits3 |= 2097152;
9589 cutMaxActiveCountValue_ = value;
9593 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
9594 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
9596 get {
return (_hasBits3 & 2097152) != 0; }
9599 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
9600 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
9601 public void ClearCutMaxActiveCountValue() {
9602 _hasBits3 &= ~2097152;
9606 public const int CutActiveCountDecayFieldNumber = 156;
9607 private readonly
static double CutActiveCountDecayDefaultValue = 0.8D;
9609 private double cutActiveCountDecay_;
9610 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
9611 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
9613 get {
if ((_hasBits3 & 4194304) != 0) {
return cutActiveCountDecay_; }
else {
return CutActiveCountDecayDefaultValue; } }
9615 _hasBits3 |= 4194304;
9616 cutActiveCountDecay_ = value;
9620 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
9621 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
9622 public bool HasCutActiveCountDecay {
9623 get {
return (_hasBits3 & 4194304) != 0; }
9626 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
9627 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
9628 public void ClearCutActiveCountDecay() {
9629 _hasBits3 &= ~4194304;
9633 public const int CutCleanupTargetFieldNumber = 157;
9634 private readonly
static int CutCleanupTargetDefaultValue = 1000;
9636 private int cutCleanupTarget_;
9640 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
9641 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
9643 get {
if ((_hasBits3 & 8388608) != 0) {
return cutCleanupTarget_; }
else {
return CutCleanupTargetDefaultValue; } }
9645 _hasBits3 |= 8388608;
9646 cutCleanupTarget_ = value;
9650 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
9651 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
9653 get {
return (_hasBits3 & 8388608) != 0; }
9656 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
9657 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
9659 _hasBits3 &= ~8388608;
9664 private readonly
static int NewConstraintsBatchSizeDefaultValue = 50;
9666 private int newConstraintsBatchSize_;
9671 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
9672 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
9674 get {
if ((_hasBits2 & 67108864) != 0) {
return newConstraintsBatchSize_; }
else {
return NewConstraintsBatchSizeDefaultValue; } }
9676 _hasBits2 |= 67108864;
9677 newConstraintsBatchSize_ = value;
9681 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
9682 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
9684 get {
return (_hasBits2 & 67108864) != 0; }
9687 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
9688 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
9690 _hasBits2 &= ~67108864;
9694 public const int ExploitIntegerLpSolutionFieldNumber = 94;
9695 private readonly
static bool ExploitIntegerLpSolutionDefaultValue =
true;
9697 private bool exploitIntegerLpSolution_;
9704 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
9705 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
9707 get {
if ((_hasBits2 & 16) != 0) {
return exploitIntegerLpSolution_; }
else {
return ExploitIntegerLpSolutionDefaultValue; } }
9710 exploitIntegerLpSolution_ = value;
9714 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
9715 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
9717 get {
return (_hasBits2 & 16) != 0; }
9720 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
9721 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
9722 public void ClearExploitIntegerLpSolution() {
9727 public const int ExploitAllLpSolutionFieldNumber = 116;
9728 private readonly
static bool ExploitAllLpSolutionDefaultValue =
true;
9730 private bool exploitAllLpSolution_;
9736 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
9737 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
9739 get {
if ((_hasBits2 & 2097152) != 0) {
return exploitAllLpSolution_; }
else {
return ExploitAllLpSolutionDefaultValue; } }
9741 _hasBits2 |= 2097152;
9742 exploitAllLpSolution_ = value;
9746 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
9747 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
9748 public bool HasExploitAllLpSolution {
9749 get {
return (_hasBits2 & 2097152) != 0; }
9752 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
9753 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
9754 public void ClearExploitAllLpSolution() {
9755 _hasBits2 &= ~2097152;
9759 public const int ExploitBestSolutionFieldNumber = 130;
9760 private readonly
static bool ExploitBestSolutionDefaultValue =
false;
9762 private bool exploitBestSolution_;
9766 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
9767 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
9769 get {
if ((_hasBits3 & 4) != 0) {
return exploitBestSolution_; }
else {
return ExploitBestSolutionDefaultValue; } }
9772 exploitBestSolution_ = value;
9776 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
9777 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
9779 get {
return (_hasBits3 & 4) != 0; }
9782 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
9783 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
9789 public const int ExploitRelaxationSolutionFieldNumber = 161;
9790 private readonly
static bool ExploitRelaxationSolutionDefaultValue =
false;
9792 private bool exploitRelaxationSolution_;
9798 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
9799 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
9801 get {
if ((_hasBits3 & 67108864) != 0) {
return exploitRelaxationSolution_; }
else {
return ExploitRelaxationSolutionDefaultValue; } }
9803 _hasBits3 |= 67108864;
9804 exploitRelaxationSolution_ = value;
9808 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
9809 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
9811 get {
return (_hasBits3 & 67108864) != 0; }
9814 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
9815 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
9817 _hasBits3 &= ~67108864;
9821 public const int ExploitObjectiveFieldNumber = 131;
9822 private readonly
static bool ExploitObjectiveDefaultValue =
true;
9824 private bool exploitObjective_;
9829 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
9830 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
9832 get {
if ((_hasBits3 & 8) != 0) {
return exploitObjective_; }
else {
return ExploitObjectiveDefaultValue; } }
9835 exploitObjective_ = value;
9839 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
9840 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
9842 get {
return (_hasBits3 & 8) != 0; }
9845 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
9846 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
9852 public const int DetectLinearizedProductFieldNumber = 277;
9853 private readonly
static bool DetectLinearizedProductDefaultValue =
false;
9855 private bool detectLinearizedProduct_;
9861 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
9862 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
9864 get {
if ((_hasBits6 & 134217728) != 0) {
return detectLinearizedProduct_; }
else {
return DetectLinearizedProductDefaultValue; } }
9866 _hasBits6 |= 134217728;
9867 detectLinearizedProduct_ = value;
9871 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
9872 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
9874 get {
return (_hasBits6 & 134217728) != 0; }
9877 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
9878 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
9880 _hasBits6 &= ~134217728;
9884 public const int UseNewIntegerConflictResolutionFieldNumber = 336;
9885 private readonly
static bool UseNewIntegerConflictResolutionDefaultValue =
false;
9887 private bool useNewIntegerConflictResolution_;
9892 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
9893 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
9895 get {
if ((_hasBits8 & 524288) != 0) {
return useNewIntegerConflictResolution_; }
else {
return UseNewIntegerConflictResolutionDefaultValue; } }
9897 _hasBits8 |= 524288;
9898 useNewIntegerConflictResolution_ = value;
9902 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
9903 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
9905 get {
return (_hasBits8 & 524288) != 0; }
9908 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
9909 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
9911 _hasBits8 &= ~524288;
9915 public const int Create1UipBooleanDuringIcrFieldNumber = 341;
9916 private readonly
static bool Create1UipBooleanDuringIcrDefaultValue =
true;
9918 private bool create1UipBooleanDuringIcr_;
9923 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
9924 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
9926 get {
if ((_hasBits8 & 8388608) != 0) {
return create1UipBooleanDuringIcr_; }
else {
return Create1UipBooleanDuringIcrDefaultValue; } }
9928 _hasBits8 |= 8388608;
9929 create1UipBooleanDuringIcr_ = value;
9933 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
9934 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
9936 get {
return (_hasBits8 & 8388608) != 0; }
9939 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
9940 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
9942 _hasBits8 &= ~8388608;
9946 public const int MipMaxBoundFieldNumber = 124;
9947 private readonly
static double MipMaxBoundDefaultValue = 1e+07D;
9949 private double mipMaxBound_;
9955 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
9956 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
9958 get {
if ((_hasBits2 & 268435456) != 0) {
return mipMaxBound_; }
else {
return MipMaxBoundDefaultValue; } }
9960 _hasBits2 |= 268435456;
9961 mipMaxBound_ = value;
9965 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
9966 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
9968 get {
return (_hasBits2 & 268435456) != 0; }
9971 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
9972 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
9974 _hasBits2 &= ~268435456;
9978 public const int MipVarScalingFieldNumber = 125;
9979 private readonly
static double MipVarScalingDefaultValue = 1D;
9981 private double mipVarScaling_;
9987 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
9988 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
9990 get {
if ((_hasBits2 & 536870912) != 0) {
return mipVarScaling_; }
else {
return MipVarScalingDefaultValue; } }
9992 _hasBits2 |= 536870912;
9993 mipVarScaling_ = value;
9997 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
9998 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
10000 get {
return (_hasBits2 & 536870912) != 0; }
10003 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
10004 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
10005 public void ClearMipVarScaling() {
10006 _hasBits2 &= ~536870912;
10010 public const int MipScaleLargeDomainFieldNumber = 225;
10011 private readonly
static bool MipScaleLargeDomainDefaultValue =
false;
10013 private bool mipScaleLargeDomain_;
10019 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
10020 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
10022 get {
if ((_hasBits5 & 32768) != 0) {
return mipScaleLargeDomain_; }
else {
return MipScaleLargeDomainDefaultValue; } }
10024 _hasBits5 |= 32768;
10025 mipScaleLargeDomain_ = value;
10029 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
10030 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
10032 get {
return (_hasBits5 & 32768) != 0; }
10035 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
10036 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
10037 public void ClearMipScaleLargeDomain() {
10038 _hasBits5 &= ~32768;
10042 public const int MipAutomaticallyScaleVariablesFieldNumber = 166;
10043 private readonly
static bool MipAutomaticallyScaleVariablesDefaultValue =
true;
10045 private bool mipAutomaticallyScaleVariables_;
10053 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
10054 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
10056 get {
if ((_hasBits3 & -2147483648) != 0) {
return mipAutomaticallyScaleVariables_; }
else {
return MipAutomaticallyScaleVariablesDefaultValue; } }
10058 _hasBits3 |= -2147483648;
10059 mipAutomaticallyScaleVariables_ = value;
10063 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
10064 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
10066 get {
return (_hasBits3 & -2147483648) != 0; }
10069 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
10070 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
10071 public void ClearMipAutomaticallyScaleVariables() {
10072 _hasBits3 &= ~-2147483648;
10077 private readonly
static bool OnlySolveIpDefaultValue =
false;
10079 private bool onlySolveIp_;
10094 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
10095 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
10097 get {
if ((_hasBits5 & 4096) != 0) {
return onlySolveIp_; }
else {
return OnlySolveIpDefaultValue; } }
10100 onlySolveIp_ = value;
10104 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
10105 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
10106 public bool HasOnlySolveIp {
10107 get {
return (_hasBits5 & 4096) != 0; }
10110 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
10111 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
10113 _hasBits5 &= ~4096;
10117 public const int MipWantedPrecisionFieldNumber = 126;
10118 private readonly
static double MipWantedPrecisionDefaultValue = 1e-06D;
10120 private double mipWantedPrecision_;
10140 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
10141 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
10143 get {
if ((_hasBits2 & 1073741824) != 0) {
return mipWantedPrecision_; }
else {
return MipWantedPrecisionDefaultValue; } }
10145 _hasBits2 |= 1073741824;
10146 mipWantedPrecision_ = value;
10150 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
10151 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
10152 public bool HasMipWantedPrecision {
10153 get {
return (_hasBits2 & 1073741824) != 0; }
10156 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
10157 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
10158 public void ClearMipWantedPrecision() {
10159 _hasBits2 &= ~1073741824;
10164 private readonly
static int MipMaxActivityExponentDefaultValue = 53;
10166 private int mipMaxActivityExponent_;
10177 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
10178 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
10180 get {
if ((_hasBits2 & -2147483648) != 0) {
return mipMaxActivityExponent_; }
else {
return MipMaxActivityExponentDefaultValue; } }
10182 _hasBits2 |= -2147483648;
10183 mipMaxActivityExponent_ = value;
10187 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
10188 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
10189 public bool HasMipMaxActivityExponent {
10190 get {
return (_hasBits2 & -2147483648) != 0; }
10193 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
10194 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
10195 public void ClearMipMaxActivityExponent() {
10196 _hasBits2 &= ~-2147483648;
10200 public const int MipCheckPrecisionFieldNumber = 128;
10201 private readonly
static double MipCheckPrecisionDefaultValue = 0.0001D;
10203 private double mipCheckPrecision_;
10209 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
10210 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
10212 get {
if ((_hasBits3 & 1) != 0) {
return mipCheckPrecision_; }
else {
return MipCheckPrecisionDefaultValue; } }
10215 mipCheckPrecision_ = value;
10219 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
10220 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
10222 get {
return (_hasBits3 & 1) != 0; }
10225 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
10226 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
10227 public void ClearMipCheckPrecision() {
10232 public const int MipComputeTrueObjectiveBoundFieldNumber = 198;
10233 private readonly
static bool MipComputeTrueObjectiveBoundDefaultValue =
true;
10235 private bool mipComputeTrueObjectiveBound_;
10243 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
10244 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
10246 get {
if ((_hasBits4 & 268435456) != 0) {
return mipComputeTrueObjectiveBound_; }
else {
return MipComputeTrueObjectiveBoundDefaultValue; } }
10248 _hasBits4 |= 268435456;
10249 mipComputeTrueObjectiveBound_ = value;
10253 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
10254 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
10255 public bool HasMipComputeTrueObjectiveBound {
10256 get {
return (_hasBits4 & 268435456) != 0; }
10259 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
10260 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
10262 _hasBits4 &= ~268435456;
10266 public const int MipMaxValidMagnitudeFieldNumber = 199;
10267 private readonly
static double MipMaxValidMagnitudeDefaultValue = 1e+20D;
10269 private double mipMaxValidMagnitude_;
10277 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
10278 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
10280 get {
if ((_hasBits4 & 536870912) != 0) {
return mipMaxValidMagnitude_; }
else {
return MipMaxValidMagnitudeDefaultValue; } }
10282 _hasBits4 |= 536870912;
10283 mipMaxValidMagnitude_ = value;
10287 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
10288 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
10290 get {
return (_hasBits4 & 536870912) != 0; }
10293 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
10294 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
10296 _hasBits4 &= ~536870912;
10300 public const int MipTreatHighMagnitudeBoundsAsInfinityFieldNumber = 278;
10301 private readonly
static bool MipTreatHighMagnitudeBoundsAsInfinityDefaultValue =
false;
10303 private bool mipTreatHighMagnitudeBoundsAsInfinity_;
10312 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
10313 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
10315 get {
if ((_hasBits6 & 268435456) != 0) {
return mipTreatHighMagnitudeBoundsAsInfinity_; }
else {
return MipTreatHighMagnitudeBoundsAsInfinityDefaultValue; } }
10317 _hasBits6 |= 268435456;
10318 mipTreatHighMagnitudeBoundsAsInfinity_ = value;
10322 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
10323 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
10325 get {
return (_hasBits6 & 268435456) != 0; }
10328 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
10329 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
10331 _hasBits6 &= ~268435456;
10335 public const int MipDropToleranceFieldNumber = 232;
10336 private readonly
static double MipDropToleranceDefaultValue = 1e-16D;
10338 private double mipDropTolerance_;
10343 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
10344 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
10346 get {
if ((_hasBits5 & 2097152) != 0) {
return mipDropTolerance_; }
else {
return MipDropToleranceDefaultValue; } }
10348 _hasBits5 |= 2097152;
10349 mipDropTolerance_ = value;
10353 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
10354 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
10355 public bool HasMipDropTolerance {
10356 get {
return (_hasBits5 & 2097152) != 0; }
10359 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
10360 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
10362 _hasBits5 &= ~2097152;
10366 public const int MipPresolveLevelFieldNumber = 261;
10367 private readonly
static int MipPresolveLevelDefaultValue = 2;
10369 private int mipPresolveLevel_;
10376 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
10377 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
10379 get {
if ((_hasBits6 & 2048) != 0) {
return mipPresolveLevel_; }
else {
return MipPresolveLevelDefaultValue; } }
10382 mipPresolveLevel_ = value;
10386 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
10387 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
10389 get {
return (_hasBits6 & 2048) != 0; }
10392 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
10393 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
10395 _hasBits6 &= ~2048;
10398 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
10399 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
10400 public override bool Equals(
object other) {
10404 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
10405 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
10407 if (ReferenceEquals(other,
null)) {
10410 if (ReferenceEquals(other,
this)) {
10413 if (Name != other.
Name)
return false;
10451 if(!restartAlgorithms_.Equals(other.restartAlgorithms_))
return false;
10526 if(!subsolvers_.Equals(other.subsolvers_))
return false;
10527 if(!extraSubsolvers_.Equals(other.extraSubsolvers_))
return false;
10528 if(!ignoreSubsolvers_.Equals(other.ignoreSubsolvers_))
return false;
10529 if(!filterSubsolvers_.Equals(other.filterSubsolvers_))
return false;
10530 if(!subsolverParams_.Equals(other.subsolverParams_))
return false;
10703 if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(
MipMaxBound, other.
MipMaxBound))
return false;
10716 return Equals(_unknownFields, other._unknownFields);
10719 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
10720 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
10721 public override int GetHashCode() {
10723 if (HasName) hash ^= Name.GetHashCode();
10724 if (HasPreferredVariableOrder) hash ^= PreferredVariableOrder.GetHashCode();
10725 if (HasInitialPolarity) hash ^= InitialPolarity.GetHashCode();
10726 if (HasUsePhaseSaving) hash ^= UsePhaseSaving.GetHashCode();
10727 if (HasPolarityRephaseIncrement) hash ^= PolarityRephaseIncrement.GetHashCode();
10728 if (HasPolarityExploitLsHints) hash ^= PolarityExploitLsHints.GetHashCode();
10729 if (HasRandomPolarityRatio) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(RandomPolarityRatio);
10730 if (HasRandomBranchesRatio) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(RandomBranchesRatio);
10731 if (HasUseErwaHeuristic) hash ^= UseErwaHeuristic.GetHashCode();
10732 if (HasInitialVariablesActivity) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(InitialVariablesActivity);
10733 if (HasAlsoBumpVariablesInConflictReasons) hash ^= AlsoBumpVariablesInConflictReasons.GetHashCode();
10734 if (HasMinimizationAlgorithm) hash ^= MinimizationAlgorithm.GetHashCode();
10735 if (HasBinaryMinimizationAlgorithm) hash ^= BinaryMinimizationAlgorithm.GetHashCode();
10736 if (HasSubsumptionDuringConflictAnalysis) hash ^= SubsumptionDuringConflictAnalysis.GetHashCode();
10737 if (HasExtraSubsumptionDuringConflictAnalysis) hash ^= ExtraSubsumptionDuringConflictAnalysis.GetHashCode();
10738 if (HasDecisionSubsumptionDuringConflictAnalysis) hash ^= DecisionSubsumptionDuringConflictAnalysis.GetHashCode();
10739 if (HasEagerlySubsumeLastNConflicts) hash ^= EagerlySubsumeLastNConflicts.GetHashCode();
10740 if (HasSubsumeDuringVivification) hash ^= SubsumeDuringVivification.GetHashCode();
10741 if (HasUseChronologicalBacktracking) hash ^= UseChronologicalBacktracking.GetHashCode();
10742 if (HasMaxBackjumpLevels) hash ^= MaxBackjumpLevels.GetHashCode();
10743 if (HasChronologicalBacktrackMinConflicts) hash ^= ChronologicalBacktrackMinConflicts.GetHashCode();
10744 if (HasClauseCleanupPeriod) hash ^= ClauseCleanupPeriod.GetHashCode();
10745 if (HasClauseCleanupPeriodIncrement) hash ^= ClauseCleanupPeriodIncrement.GetHashCode();
10746 if (HasClauseCleanupTarget) hash ^= ClauseCleanupTarget.GetHashCode();
10747 if (HasClauseCleanupRatio) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(ClauseCleanupRatio);
10748 if (HasClauseCleanupLbdBound) hash ^= ClauseCleanupLbdBound.GetHashCode();
10749 if (HasClauseCleanupLbdTier1) hash ^= ClauseCleanupLbdTier1.GetHashCode();
10750 if (HasClauseCleanupLbdTier2) hash ^= ClauseCleanupLbdTier2.GetHashCode();
10751 if (HasClauseCleanupOrdering) hash ^= ClauseCleanupOrdering.GetHashCode();
10752 if (HasPbCleanupIncrement) hash ^= PbCleanupIncrement.GetHashCode();
10753 if (HasPbCleanupRatio) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(PbCleanupRatio);
10754 if (HasVariableActivityDecay) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(VariableActivityDecay);
10755 if (HasMaxVariableActivityValue) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(MaxVariableActivityValue);
10756 if (HasGlucoseMaxDecay) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(GlucoseMaxDecay);
10757 if (HasGlucoseDecayIncrement) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(GlucoseDecayIncrement);
10758 if (HasGlucoseDecayIncrementPeriod) hash ^= GlucoseDecayIncrementPeriod.GetHashCode();
10759 if (HasClauseActivityDecay) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(ClauseActivityDecay);
10760 if (HasMaxClauseActivityValue) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(MaxClauseActivityValue);
10761 hash ^= restartAlgorithms_.GetHashCode();
10762 if (HasDefaultRestartAlgorithms) hash ^= DefaultRestartAlgorithms.GetHashCode();
10763 if (HasRestartPeriod) hash ^= RestartPeriod.GetHashCode();
10764 if (HasRestartRunningWindowSize) hash ^= RestartRunningWindowSize.GetHashCode();
10765 if (HasRestartDlAverageRatio) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(RestartDlAverageRatio);
10766 if (HasRestartLbdAverageRatio) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(RestartLbdAverageRatio);
10767 if (HasUseBlockingRestart) hash ^= UseBlockingRestart.GetHashCode();
10768 if (HasBlockingRestartWindowSize) hash ^= BlockingRestartWindowSize.GetHashCode();
10769 if (HasBlockingRestartMultiplier) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(BlockingRestartMultiplier);
10770 if (HasNumConflictsBeforeStrategyChanges) hash ^= NumConflictsBeforeStrategyChanges.GetHashCode();
10771 if (HasStrategyChangeIncreaseRatio) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(StrategyChangeIncreaseRatio);
10772 if (HasMaxTimeInSeconds) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(MaxTimeInSeconds);
10773 if (HasMaxDeterministicTime) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(MaxDeterministicTime);
10774 if (HasMaxNumDeterministicBatches) hash ^= MaxNumDeterministicBatches.GetHashCode();
10775 if (HasMaxNumberOfConflicts) hash ^= MaxNumberOfConflicts.GetHashCode();
10776 if (HasMaxMemoryInMb) hash ^= MaxMemoryInMb.GetHashCode();
10777 if (HasAbsoluteGapLimit) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(AbsoluteGapLimit);
10778 if (HasRelativeGapLimit) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(RelativeGapLimit);
10779 if (HasRandomSeed) hash ^= RandomSeed.GetHashCode();
10780 if (HasPermuteVariableRandomly) hash ^= PermuteVariableRandomly.GetHashCode();
10781 if (HasPermutePresolveConstraintOrder) hash ^= PermutePresolveConstraintOrder.GetHashCode();
10782 if (HasUseAbslRandom) hash ^= UseAbslRandom.GetHashCode();
10836 hash ^= subsolvers_.GetHashCode();
10837 hash ^= extraSubsolvers_.GetHashCode();
10838 hash ^= ignoreSubsolvers_.GetHashCode();
10839 hash ^= filterSubsolvers_.GetHashCode();
10840 hash ^= subsolverParams_.GetHashCode();
11026 if (_unknownFields !=
null) {
11027 hash ^= _unknownFields.GetHashCode();
11032 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
11033 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
11034 public override string ToString() {
11035 return pb::JsonFormatter.ToDiagnosticString(
this);
11038 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
11039 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
11040 public void WriteTo(pb::CodedOutputStream output) {
11041 #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
11042 output.WriteRawMessage(
this);
11044 if (HasPreferredVariableOrder) {
11045 output.WriteRawTag(8);
11046 output.WriteEnum((
int) PreferredVariableOrder);
11048 if (HasInitialPolarity) {
11049 output.WriteRawTag(16);
11050 output.WriteEnum((
int) InitialPolarity);
11052 if (HasMinimizationAlgorithm) {
11053 output.WriteRawTag(32);
11054 output.WriteEnum((
int) MinimizationAlgorithm);
11056 if (HasClauseCleanupPeriod) {
11057 output.WriteRawTag(88);
11058 output.WriteInt32(ClauseCleanupPeriod);
11060 if (HasClauseCleanupTarget) {
11061 output.WriteRawTag(104);
11062 output.WriteInt32(ClauseCleanupTarget);
11064 if (HasVariableActivityDecay) {
11065 output.WriteRawTag(121);
11066 output.WriteDouble(VariableActivityDecay);
11068 if (HasMaxVariableActivityValue) {
11069 output.WriteRawTag(129, 1);
11070 output.WriteDouble(MaxVariableActivityValue);
11072 if (HasClauseActivityDecay) {
11073 output.WriteRawTag(137, 1);
11074 output.WriteDouble(ClauseActivityDecay);
11076 if (HasMaxClauseActivityValue) {
11077 output.WriteRawTag(145, 1);
11078 output.WriteDouble(MaxClauseActivityValue);
11080 if (HasGlucoseMaxDecay) {
11081 output.WriteRawTag(177, 1);
11082 output.WriteDouble(GlucoseMaxDecay);
11084 if (HasGlucoseDecayIncrement) {
11085 output.WriteRawTag(185, 1);
11086 output.WriteDouble(GlucoseDecayIncrement);
11088 if (HasGlucoseDecayIncrementPeriod) {
11089 output.WriteRawTag(192, 1);
11090 output.WriteInt32(GlucoseDecayIncrementPeriod);
11092 if (HasRestartPeriod) {
11093 output.WriteRawTag(240, 1);
11094 output.WriteInt32(RestartPeriod);
11097 output.WriteRawTag(248, 1);
11100 if (HasRandomBranchesRatio) {
11101 output.WriteRawTag(129, 2);
11104 if (HasBinaryMinimizationAlgorithm) {
11105 output.WriteRawTag(144, 2);
11106 output.WriteEnum((
int) BinaryMinimizationAlgorithm);
11108 if (HasUseOptimizationHints) {
11109 output.WriteRawTag(152, 2);
11110 output.WriteBool(UseOptimizationHints);
11112 if (HasMaxTimeInSeconds) {
11113 output.WriteRawTag(161, 2);
11114 output.WriteDouble(MaxTimeInSeconds);
11116 if (HasMaxNumberOfConflicts) {
11117 output.WriteRawTag(168, 2);
11118 output.WriteInt64(MaxNumberOfConflicts);
11120 if (HasMaxMemoryInMb) {
11121 output.WriteRawTag(192, 2);
11122 output.WriteInt64(MaxMemoryInMb);
11124 if (HasLogSearchProgress) {
11125 output.WriteRawTag(200, 2);
11126 output.WriteBool(LogSearchProgress);
11128 if (HasUsePbResolution) {
11129 output.WriteRawTag(216, 2);
11130 output.WriteBool(UsePbResolution);
11132 if (HasUsePhaseSaving) {
11133 output.WriteRawTag(224, 2);
11134 output.WriteBool(UsePhaseSaving);
11136 if (HasRandomPolarityRatio) {
11137 output.WriteRawTag(233, 2);
11138 output.WriteDouble(RandomPolarityRatio);
11140 if (HasPbCleanupIncrement) {
11141 output.WriteRawTag(240, 2);
11142 output.WriteInt32(PbCleanupIncrement);
11144 if (HasPbCleanupRatio) {
11145 output.WriteRawTag(249, 2);
11146 output.WriteDouble(PbCleanupRatio);
11148 if (HasMinimizeReductionDuringPbResolution) {
11149 output.WriteRawTag(128, 3);
11150 output.WriteBool(MinimizeReductionDuringPbResolution);
11152 if (HasCountAssumptionLevelsInLbd) {
11153 output.WriteRawTag(136, 3);
11154 output.WriteBool(CountAssumptionLevelsInLbd);
11156 if (HasCoreMinimizationLevel) {
11157 output.WriteRawTag(144, 3);
11158 output.WriteInt32(CoreMinimizationLevel);
11160 if (HasMaxSatAssumptionOrder) {
11161 output.WriteRawTag(152, 3);
11162 output.WriteEnum((
int) MaxSatAssumptionOrder);
11164 if (HasMaxSatReverseAssumptionOrder) {
11165 output.WriteRawTag(160, 3);
11166 output.WriteBool(MaxSatReverseAssumptionOrder);
11168 if (HasMaxSatStratification) {
11169 output.WriteRawTag(168, 3);
11170 output.WriteEnum((
int) MaxSatStratification);
11172 if (HasPresolveBveThreshold) {
11173 output.WriteRawTag(176, 3);
11174 output.WriteInt32(PresolveBveThreshold);
11176 if (HasPresolveBveClauseWeight) {
11177 output.WriteRawTag(184, 3);
11178 output.WriteInt32(PresolveBveClauseWeight);
11180 if (HasSubsumptionDuringConflictAnalysis) {
11181 output.WriteRawTag(192, 3);
11182 output.WriteBool(SubsumptionDuringConflictAnalysis);
11184 if (HasPresolveProbingDeterministicTimeLimit) {
11185 output.WriteRawTag(201, 3);
11186 output.WriteDouble(PresolveProbingDeterministicTimeLimit);
11188 if (HasClauseCleanupLbdBound) {
11189 output.WriteRawTag(216, 3);
11190 output.WriteInt32(ClauseCleanupLbdBound);
11192 if (HasClauseCleanupOrdering) {
11193 output.WriteRawTag(224, 3);
11194 output.WriteEnum((
int) ClauseCleanupOrdering);
11196 restartAlgorithms_.WriteTo(output, _repeated_restartAlgorithms_codec);
11197 if (HasRestartRunningWindowSize) {
11198 output.WriteRawTag(240, 3);
11199 output.WriteInt32(RestartRunningWindowSize);
11201 if (HasRestartDlAverageRatio) {
11202 output.WriteRawTag(249, 3);
11203 output.WriteDouble(RestartDlAverageRatio);
11205 if (HasUseBlockingRestart) {
11206 output.WriteRawTag(128, 4);
11207 output.WriteBool(UseBlockingRestart);
11209 if (HasBlockingRestartWindowSize) {
11210 output.WriteRawTag(136, 4);
11211 output.WriteInt32(BlockingRestartWindowSize);
11213 if (HasBlockingRestartMultiplier) {
11214 output.WriteRawTag(145, 4);
11215 output.WriteDouble(BlockingRestartMultiplier);
11217 if (HasMaxDeterministicTime) {
11218 output.WriteRawTag(153, 4);
11219 output.WriteDouble(MaxDeterministicTime);
11221 if (HasNumConflictsBeforeStrategyChanges) {
11222 output.WriteRawTag(160, 4);
11223 output.WriteInt32(NumConflictsBeforeStrategyChanges);
11225 if (HasStrategyChangeIncreaseRatio) {
11226 output.WriteRawTag(169, 4);
11227 output.WriteDouble(StrategyChangeIncreaseRatio);
11229 if (HasDefaultRestartAlgorithms) {
11230 output.WriteRawTag(178, 4);
11231 output.WriteString(DefaultRestartAlgorithms);
11233 if (HasRestartLbdAverageRatio) {
11234 output.WriteRawTag(185, 4);
11235 output.WriteDouble(RestartLbdAverageRatio);
11237 if (HasPresolveUseBva) {
11238 output.WriteRawTag(192, 4);
11239 output.WriteBool(PresolveUseBva);
11241 if (HasPresolveBvaThreshold) {
11242 output.WriteRawTag(200, 4);
11243 output.WriteInt32(PresolveBvaThreshold);
11245 if (HasUsePrecedencesInDisjunctiveConstraint) {
11246 output.WriteRawTag(208, 4);
11247 output.WriteBool(UsePrecedencesInDisjunctiveConstraint);
11249 if (HasUseErwaHeuristic) {
11250 output.WriteRawTag(216, 4);
11251 output.WriteBool(UseErwaHeuristic);
11253 if (HasInitialVariablesActivity) {
11254 output.WriteRawTag(225, 4);
11255 output.WriteDouble(InitialVariablesActivity);
11257 if (HasAlsoBumpVariablesInConflictReasons) {
11258 output.WriteRawTag(232, 4);
11259 output.WriteBool(AlsoBumpVariablesInConflictReasons);
11261 if (HasUseOverloadCheckerInCumulative) {
11262 output.WriteRawTag(240, 4);
11263 output.WriteBool(UseOverloadCheckerInCumulative);
11265 if (HasUseTimetableEdgeFindingInCumulative) {
11266 output.WriteRawTag(248, 4);
11267 output.WriteBool(UseTimetableEdgeFindingInCumulative);
11269 if (HasUseDisjunctiveConstraintInCumulative) {
11270 output.WriteRawTag(128, 5);
11271 output.WriteBool(UseDisjunctiveConstraintInCumulative);
11273 if (HasSearchBranching) {
11274 output.WriteRawTag(144, 5);
11275 output.WriteEnum((
int) SearchBranching);
11277 if (HasOptimizeWithCore) {
11278 output.WriteRawTag(152, 5);
11279 output.WriteBool(OptimizeWithCore);
11281 if (HasFindMultipleCores) {
11282 output.WriteRawTag(160, 5);
11283 output.WriteBool(FindMultipleCores);
11285 if (HasOptimizeWithMaxHs) {
11286 output.WriteRawTag(168, 5);
11287 output.WriteBool(OptimizeWithMaxHs);
11289 if (HasCpModelPresolve) {
11290 output.WriteRawTag(176, 5);
11291 output.WriteBool(CpModelPresolve);
11293 if (HasEnumerateAllSolutions) {
11294 output.WriteRawTag(184, 5);
11295 output.WriteBool(EnumerateAllSolutions);
11297 if (HasPresolveBlockedClause) {
11298 output.WriteRawTag(192, 5);
11299 output.WriteBool(PresolveBlockedClause);
11301 if (HasCoverOptimization) {
11302 output.WriteRawTag(200, 5);
11303 output.WriteBool(CoverOptimization);
11305 if (HasLinearizationLevel) {
11306 output.WriteRawTag(208, 5);
11307 output.WriteInt32(LinearizationLevel);
11309 if (HasMaxNumCuts) {
11310 output.WriteRawTag(216, 5);
11311 output.WriteInt32(MaxNumCuts);
11313 if (HasOnlyAddCutsAtLevelZero) {
11314 output.WriteRawTag(224, 5);
11315 output.WriteBool(OnlyAddCutsAtLevelZero);
11317 if (HasCpModelUseSatPresolve) {
11318 output.WriteRawTag(232, 5);
11319 output.WriteBool(CpModelUseSatPresolve);
11321 if (HasExploitIntegerLpSolution) {
11322 output.WriteRawTag(240, 5);
11323 output.WriteBool(ExploitIntegerLpSolution);
11325 if (HasAutoDetectGreaterThanAtLeastOneOf) {
11326 output.WriteRawTag(248, 5);
11327 output.WriteBool(AutoDetectGreaterThanAtLeastOneOf);
11329 if (HasStopAfterFirstSolution) {
11330 output.WriteRawTag(144, 6);
11331 output.WriteBool(StopAfterFirstSolution);
11333 if (HasBinarySearchNumConflicts) {
11334 output.WriteRawTag(152, 6);
11335 output.WriteInt32(BinarySearchNumConflicts);
11337 if (HasNumSearchWorkers) {
11338 output.WriteRawTag(160, 6);
11339 output.WriteInt32(NumSearchWorkers);
11341 if (HasUseLnsOnly) {
11342 output.WriteRawTag(168, 6);
11343 output.WriteBool(UseLnsOnly);
11345 if (HasRandomizeSearch) {
11346 output.WriteRawTag(184, 6);
11347 output.WriteBool(RandomizeSearch);
11349 if (HasSearchRandomVariablePoolSize) {
11350 output.WriteRawTag(192, 6);
11351 output.WriteInt64(SearchRandomVariablePoolSize);
11353 if (HasInstantiateAllVariables) {
11354 output.WriteRawTag(208, 6);
11355 output.WriteBool(InstantiateAllVariables);
11357 if (HasBooleanEncodingLevel) {
11358 output.WriteRawTag(216, 6);
11359 output.WriteInt32(BooleanEncodingLevel);
11361 if (HasUseOptionalVariables) {
11362 output.WriteRawTag(224, 6);
11363 output.WriteBool(UseOptionalVariables);
11365 if (HasUseExactLpReason) {
11366 output.WriteRawTag(232, 6);
11367 output.WriteBool(UseExactLpReason);
11369 if (HasCpModelProbingLevel) {
11370 output.WriteRawTag(240, 6);
11371 output.WriteInt32(CpModelProbingLevel);
11373 if (HasAddLpConstraintsLazily) {
11374 output.WriteRawTag(128, 7);
11375 output.WriteBool(AddLpConstraintsLazily);
11377 if (HasShareObjectiveBounds) {
11378 output.WriteRawTag(136, 7);
11379 output.WriteBool(ShareObjectiveBounds);
11381 if (HasShareLevelZeroBounds) {
11382 output.WriteRawTag(144, 7);
11383 output.WriteBool(ShareLevelZeroBounds);
11385 if (HasMinOrthogonalityForLpConstraints) {
11386 output.WriteRawTag(153, 7);
11387 output.WriteDouble(MinOrthogonalityForLpConstraints);
11389 if (HasExploitAllLpSolution) {
11390 output.WriteRawTag(160, 7);
11391 output.WriteBool(ExploitAllLpSolution);
11393 if (HasAddCgCuts) {
11394 output.WriteRawTag(168, 7);
11395 output.WriteBool(AddCgCuts);
11397 if (HasMaxIntegerRoundingScaling) {
11398 output.WriteRawTag(184, 7);
11399 output.WriteInt32(MaxIntegerRoundingScaling);
11401 if (HasAddMirCuts) {
11402 output.WriteRawTag(192, 7);
11403 output.WriteBool(AddMirCuts);
11405 if (HasMaxConsecutiveInactiveCount) {
11406 output.WriteRawTag(200, 7);
11407 output.WriteInt32(MaxConsecutiveInactiveCount);
11409 if (HasNewConstraintsBatchSize) {
11410 output.WriteRawTag(208, 7);
11411 output.WriteInt32(NewConstraintsBatchSize);
11413 if (HasPseudoCostReliabilityThreshold) {
11414 output.WriteRawTag(216, 7);
11415 output.WriteInt64(PseudoCostReliabilityThreshold);
11417 if (HasMipMaxBound) {
11418 output.WriteRawTag(225, 7);
11419 output.WriteDouble(MipMaxBound);
11421 if (HasMipVarScaling) {
11422 output.WriteRawTag(233, 7);
11423 output.WriteDouble(MipVarScaling);
11425 if (HasMipWantedPrecision) {
11426 output.WriteRawTag(241, 7);
11427 output.WriteDouble(MipWantedPrecision);
11429 if (HasMipMaxActivityExponent) {
11430 output.WriteRawTag(248, 7);
11431 output.WriteInt32(MipMaxActivityExponent);
11433 if (HasMipCheckPrecision) {
11434 output.WriteRawTag(129, 8);
11435 output.WriteDouble(MipCheckPrecision);
11437 if (HasUseRinsLns) {
11438 output.WriteRawTag(136, 8);
11439 output.WriteBool(UseRinsLns);
11441 if (HasExploitBestSolution) {
11442 output.WriteRawTag(144, 8);
11443 output.WriteBool(ExploitBestSolution);
11445 if (HasExploitObjective) {
11446 output.WriteRawTag(152, 8);
11447 output.WriteBool(ExploitObjective);
11449 if (HasFillTightenedDomainsInResponse) {
11450 output.WriteRawTag(160, 8);
11451 output.WriteBool(FillTightenedDomainsInResponse);
11453 if (HasUseCombinedNoOverlap) {
11454 output.WriteRawTag(168, 8);
11455 output.WriteBool(UseCombinedNoOverlap);
11457 if (HasInterleaveBatchSize) {
11458 output.WriteRawTag(176, 8);
11459 output.WriteInt32(InterleaveBatchSize);
11461 if (HasCatchSigintSignal) {
11462 output.WriteRawTag(184, 8);
11463 output.WriteBool(CatchSigintSignal);
11465 if (HasInterleaveSearch) {
11466 output.WriteRawTag(192, 8);
11467 output.WriteBool(InterleaveSearch);
11469 if (HasDiversifyLnsParams) {
11470 output.WriteRawTag(200, 8);
11471 output.WriteBool(DiversifyLnsParams);
11473 if (HasMaxPresolveIterations) {
11474 output.WriteRawTag(208, 8);
11475 output.WriteInt32(MaxPresolveIterations);
11477 if (HasUseImpliedBounds) {
11478 output.WriteRawTag(128, 9);
11479 output.WriteBool(UseImpliedBounds);
11481 if (HasMergeNoOverlapWorkLimit) {
11482 output.WriteRawTag(137, 9);
11483 output.WriteDouble(MergeNoOverlapWorkLimit);
11485 if (HasMergeAtMostOneWorkLimit) {
11486 output.WriteRawTag(145, 9);
11487 output.WriteDouble(MergeAtMostOneWorkLimit);
11489 if (HasPresolveSubstitutionLevel) {
11490 output.WriteRawTag(152, 9);
11491 output.WriteInt32(PresolveSubstitutionLevel);
11493 if (HasMaxAllDiffCutSize) {
11494 output.WriteRawTag(160, 9);
11495 output.WriteInt32(MaxAllDiffCutSize);
11497 if (HasStopAfterPresolve) {
11498 output.WriteRawTag(168, 9);
11499 output.WriteBool(StopAfterPresolve);
11501 if (HasDebugMaxNumPresolveOperations) {
11502 output.WriteRawTag(184, 9);
11503 output.WriteInt32(DebugMaxNumPresolveOperations);
11505 if (HasAddLinMaxCuts) {
11506 output.WriteRawTag(192, 9);
11507 output.WriteBool(AddLinMaxCuts);
11509 if (HasHintConflictLimit) {
11510 output.WriteRawTag(200, 9);
11511 output.WriteInt32(HintConflictLimit);
11513 if (HasMaxCutRoundsAtLevelZero) {
11514 output.WriteRawTag(208, 9);
11515 output.WriteInt32(MaxCutRoundsAtLevelZero);
11517 if (HasCutMaxActiveCountValue) {
11518 output.WriteRawTag(217, 9);
11519 output.WriteDouble(CutMaxActiveCountValue);
11521 if (HasCutActiveCountDecay) {
11522 output.WriteRawTag(225, 9);
11523 output.WriteDouble(CutActiveCountDecay);
11525 if (HasCutCleanupTarget) {
11526 output.WriteRawTag(232, 9);
11527 output.WriteInt32(CutCleanupTarget);
11529 if (HasAbsoluteGapLimit) {
11530 output.WriteRawTag(249, 9);
11531 output.WriteDouble(AbsoluteGapLimit);
11533 if (HasRelativeGapLimit) {
11534 output.WriteRawTag(129, 10);
11535 output.WriteDouble(RelativeGapLimit);
11537 if (HasExploitRelaxationSolution) {
11538 output.WriteRawTag(136, 10);
11539 output.WriteBool(ExploitRelaxationSolution);
11541 if (HasDebugPostsolveWithFullSolver) {
11542 output.WriteRawTag(144, 10);
11543 output.WriteBool(DebugPostsolveWithFullSolver);
11545 if (HasUseSatInprocessing) {
11546 output.WriteRawTag(152, 10);
11547 output.WriteBool(UseSatInprocessing);
11549 if (HasUseFeasibilityPump) {
11550 output.WriteRawTag(160, 10);
11551 output.WriteBool(UseFeasibilityPump);
11553 if (HasFpRounding) {
11554 output.WriteRawTag(168, 10);
11555 output.WriteEnum((
int) FpRounding);
11557 if (HasMipAutomaticallyScaleVariables) {
11558 output.WriteRawTag(176, 10);
11559 output.WriteBool(MipAutomaticallyScaleVariables);
11561 if (HasRepairHint) {
11562 output.WriteRawTag(184, 10);
11563 output.WriteBool(RepairHint);
11565 if (HasPolarityRephaseIncrement) {
11566 output.WriteRawTag(192, 10);
11567 output.WriteInt32(PolarityRephaseIncrement);
11569 if (HasAddZeroHalfCuts) {
11570 output.WriteRawTag(200, 10);
11571 output.WriteBool(AddZeroHalfCuts);
11573 if (HasExpandAlldiffConstraints) {
11574 output.WriteRawTag(208, 10);
11575 output.WriteBool(ExpandAlldiffConstraints);
11578 output.WriteRawTag(218, 10);
11579 output.WriteString(Name);
11581 if (HasAddCliqueCuts) {
11582 output.WriteRawTag(224, 10);
11583 output.WriteBool(AddCliqueCuts);
11585 if (HasKeepAllFeasibleSolutionsInPresolve) {
11586 output.WriteRawTag(232, 10);
11587 output.WriteBool(KeepAllFeasibleSolutionsInPresolve);
11589 if (HasPresolveExtractIntegerEnforcement) {
11590 output.WriteRawTag(240, 10);
11591 output.WriteBool(PresolveExtractIntegerEnforcement);
11593 if (HasPolishLpSolution) {
11594 output.WriteRawTag(248, 10);
11595 output.WriteBool(PolishLpSolution);
11597 if (HasUseProbingSearch) {
11598 output.WriteRawTag(128, 11);
11599 output.WriteBool(UseProbingSearch);
11601 if (HasConvertIntervals) {
11602 output.WriteRawTag(136, 11);
11603 output.WriteBool(ConvertIntervals);
11605 if (HasPermuteVariableRandomly) {
11606 output.WriteRawTag(144, 11);
11607 output.WriteBool(PermuteVariableRandomly);
11609 if (HasPermutePresolveConstraintOrder) {
11610 output.WriteRawTag(152, 11);
11611 output.WriteBool(PermutePresolveConstraintOrder);
11613 if (HasUseAbslRandom) {
11614 output.WriteRawTag(160, 11);
11615 output.WriteBool(UseAbslRandom);
11617 if (HasDisableConstraintExpansion) {
11618 output.WriteRawTag(168, 11);
11619 output.WriteBool(DisableConstraintExpansion);
11621 if (HasExpandReservoirConstraints) {
11622 output.WriteRawTag(176, 11);
11623 output.WriteBool(ExpandReservoirConstraints);
11625 if (HasSymmetryLevel) {
11626 output.WriteRawTag(184, 11);
11627 output.WriteInt32(SymmetryLevel);
11629 if (HasLogPrefix) {
11630 output.WriteRawTag(202, 11);
11631 output.WriteString(LogPrefix);
11633 if (HasLogToStdout) {
11634 output.WriteRawTag(208, 11);
11635 output.WriteBool(LogToStdout);
11637 if (HasLogToResponse) {
11638 output.WriteRawTag(216, 11);
11639 output.WriteBool(LogToResponse);
11641 if (HasOptimizeWithLbTreeSearch) {
11642 output.WriteRawTag(224, 11);
11643 output.WriteBool(OptimizeWithLbTreeSearch);
11645 if (HasLogSubsolverStatistics) {
11646 output.WriteRawTag(232, 11);
11647 output.WriteBool(LogSubsolverStatistics);
11649 if (HasClauseCleanupRatio) {
11650 output.WriteRawTag(241, 11);
11651 output.WriteDouble(ClauseCleanupRatio);
11653 if (HasMaxDomainSizeWhenEncodingEqNeqConstraints) {
11654 output.WriteRawTag(248, 11);
11655 output.WriteInt32(MaxDomainSizeWhenEncodingEqNeqConstraints);
11657 if (HasFixVariablesToTheirHintedValue) {
11658 output.WriteRawTag(128, 12);
11659 output.WriteBool(FixVariablesToTheirHintedValue);
11661 if (HasSolutionPoolSize) {
11662 output.WriteRawTag(136, 12);
11663 output.WriteInt32(SolutionPoolSize);
11665 if (HasFillAdditionalSolutionsInResponse) {
11666 output.WriteRawTag(144, 12);
11667 output.WriteBool(FillAdditionalSolutionsInResponse);
11669 if (HasDebugCrashOnBadHint) {
11670 output.WriteRawTag(152, 12);
11671 output.WriteBool(DebugCrashOnBadHint);
11674 output.WriteRawTag(160, 12);
11675 output.WriteInt32(CutLevel);
11677 if (HasAddObjectiveCut) {
11678 output.WriteRawTag(168, 12);
11679 output.WriteBool(AddObjectiveCut);
11681 if (HasMipComputeTrueObjectiveBound) {
11682 output.WriteRawTag(176, 12);
11683 output.WriteBool(MipComputeTrueObjectiveBound);
11685 if (HasMipMaxValidMagnitude) {
11686 output.WriteRawTag(185, 12);
11687 output.WriteDouble(MipMaxValidMagnitude);
11689 if (HasUseTimetablingInNoOverlap2D) {
11690 output.WriteRawTag(192, 12);
11691 output.WriteBool(UseTimetablingInNoOverlap2D);
11693 if (HasPresolveInclusionWorkLimit) {
11694 output.WriteRawTag(200, 12);
11695 output.WriteInt64(PresolveInclusionWorkLimit);
11697 if (HasIgnoreNames) {
11698 output.WriteRawTag(208, 12);
11699 output.WriteBool(IgnoreNames);
11701 if (HasShareBinaryClauses) {
11702 output.WriteRawTag(216, 12);
11703 output.WriteBool(ShareBinaryClauses);
11705 if (HasShavingDeterministicTimeInProbingSearch) {
11706 output.WriteRawTag(225, 12);
11707 output.WriteDouble(ShavingDeterministicTimeInProbingSearch);
11709 if (HasShavingSearchDeterministicTime) {
11710 output.WriteRawTag(233, 12);
11711 output.WriteDouble(ShavingSearchDeterministicTime);
11713 if (HasNumWorkers) {
11714 output.WriteRawTag(240, 12);
11715 output.WriteInt32(NumWorkers);
11717 subsolvers_.WriteTo(output, _repeated_subsolvers_codec);
11718 ignoreSubsolvers_.WriteTo(output, _repeated_ignoreSubsolvers_codec);
11719 subsolverParams_.WriteTo(output, _repeated_subsolverParams_codec);
11720 if (HasUseEnergeticReasoningInNoOverlap2D) {
11721 output.WriteRawTag(168, 13);
11722 output.WriteBool(UseEnergeticReasoningInNoOverlap2D);
11724 if (HasUseDualSchedulingHeuristics) {
11725 output.WriteRawTag(176, 13);
11726 output.WriteBool(UseDualSchedulingHeuristics);
11728 if (HasUseHardPrecedencesInCumulative) {
11729 output.WriteRawTag(184, 13);
11730 output.WriteBool(UseHardPrecedencesInCumulative);
11732 if (HasDetectTableWithCost) {
11733 output.WriteRawTag(192, 13);
11734 output.WriteBool(DetectTableWithCost);
11736 if (HasTableCompressionLevel) {
11737 output.WriteRawTag(200, 13);
11738 output.WriteInt32(TableCompressionLevel);
11740 extraSubsolvers_.WriteTo(output, _repeated_extraSubsolvers_codec);
11741 if (HasExploitAllPrecedences) {
11742 output.WriteRawTag(224, 13);
11743 output.WriteBool(ExploitAllPrecedences);
11745 if (HasPropagationLoopDetectionFactor) {
11746 output.WriteRawTag(233, 13);
11747 output.WriteDouble(PropagationLoopDetectionFactor);
11749 if (HasOnlySolveIp) {
11750 output.WriteRawTag(240, 13);
11751 output.WriteBool(OnlySolveIp);
11753 if (HasEncodeComplexLinearConstraintWithInteger) {
11754 output.WriteRawTag(248, 13);
11755 output.WriteBool(EncodeComplexLinearConstraintWithInteger);
11757 if (HasNewLinearPropagation) {
11758 output.WriteRawTag(128, 14);
11759 output.WriteBool(NewLinearPropagation);
11761 if (HasMipScaleLargeDomain) {
11762 output.WriteRawTag(136, 14);
11763 output.WriteBool(MipScaleLargeDomain);
11765 if (HasProbingDeterministicTimeLimit) {
11766 output.WriteRawTag(145, 14);
11767 output.WriteDouble(ProbingDeterministicTimeLimit);
11769 if (HasRootLpIterations) {
11770 output.WriteRawTag(152, 14);
11771 output.WriteInt32(RootLpIterations);
11773 if (HasUseObjectiveLbSearch) {
11774 output.WriteRawTag(160, 14);
11775 output.WriteBool(UseObjectiveLbSearch);
11777 if (HasMaxSizeToCreatePrecedenceLiteralsInDisjunctive) {
11778 output.WriteRawTag(168, 14);
11779 output.WriteInt32(MaxSizeToCreatePrecedenceLiteralsInDisjunctive);
11781 if (HasUseStrongPropagationInDisjunctive) {
11782 output.WriteRawTag(176, 14);
11783 output.WriteBool(UseStrongPropagationInDisjunctive);
11785 if (HasMipDropTolerance) {
11786 output.WriteRawTag(193, 14);
11787 output.WriteDouble(MipDropTolerance);
11789 if (HasInferAllDiffs) {
11790 output.WriteRawTag(200, 14);
11791 output.WriteBool(InferAllDiffs);
11793 if (HasFindBigLinearOverlap) {
11794 output.WriteRawTag(208, 14);
11795 output.WriteBool(FindBigLinearOverlap);
11797 if (HasSharedTreeNumWorkers) {
11798 output.WriteRawTag(216, 14);
11799 output.WriteInt32(SharedTreeNumWorkers);
11801 if (HasUseSharedTreeSearch) {
11802 output.WriteRawTag(224, 14);
11803 output.WriteBool(UseSharedTreeSearch);
11805 if (HasSharedTreeMaxNodesPerWorker) {
11806 output.WriteRawTag(240, 14);
11807 output.WriteInt32(SharedTreeMaxNodesPerWorker);
11809 if (HasSharedTreeSplitStrategy) {
11810 output.WriteRawTag(248, 14);
11811 output.WriteEnum((
int) SharedTreeSplitStrategy);
11813 if (HasUseLsOnly) {
11814 output.WriteRawTag(128, 15);
11815 output.WriteBool(UseLsOnly);
11817 if (HasFeasibilityJumpDecay) {
11818 output.WriteRawTag(145, 15);
11819 output.WriteDouble(FeasibilityJumpDecay);
11821 if (HasNumViolationLs) {
11822 output.WriteRawTag(160, 15);
11823 output.WriteInt32(NumViolationLs);
11825 if (HasFeasibilityJumpVarRandomizationProbability) {
11826 output.WriteRawTag(185, 15);
11827 output.WriteDouble(FeasibilityJumpVarRandomizationProbability);
11829 if (HasFeasibilityJumpVarPerburbationRangeRatio) {
11830 output.WriteRawTag(193, 15);
11831 output.WriteDouble(FeasibilityJumpVarPerburbationRangeRatio);
11833 if (HasViolationLsPerturbationPeriod) {
11834 output.WriteRawTag(200, 15);
11835 output.WriteInt32(ViolationLsPerturbationPeriod);
11837 if (HasFeasibilityJumpEnableRestarts) {
11838 output.WriteRawTag(208, 15);
11839 output.WriteBool(FeasibilityJumpEnableRestarts);
11841 if (HasStopAfterRootPropagation) {
11842 output.WriteRawTag(224, 15);
11843 output.WriteBool(StopAfterRootPropagation);
11845 if (HasUseObjectiveShavingSearch) {
11846 output.WriteRawTag(232, 15);
11847 output.WriteBool(UseObjectiveShavingSearch);
11849 if (HasUseLbRelaxLns) {
11850 output.WriteRawTag(248, 15);
11851 output.WriteBool(UseLbRelaxLns);
11853 if (HasLinearSplitSize) {
11854 output.WriteRawTag(128, 16);
11855 output.WriteInt32(LinearSplitSize);
11857 if (HasFeasibilityJumpLinearizationLevel) {
11858 output.WriteRawTag(136, 16);
11859 output.WriteInt32(FeasibilityJumpLinearizationLevel);
11861 if (HasFeasibilityJumpRestartFactor) {
11862 output.WriteRawTag(144, 16);
11863 output.WriteInt32(FeasibilityJumpRestartFactor);
11865 if (HasViolationLsCompoundMoveProbability) {
11866 output.WriteRawTag(153, 16);
11867 output.WriteDouble(ViolationLsCompoundMoveProbability);
11869 if (HasMaxNumIntervalsForTimetableEdgeFinding) {
11870 output.WriteRawTag(160, 16);
11871 output.WriteInt32(MaxNumIntervalsForTimetableEdgeFinding);
11873 if (HasMipPresolveLevel) {
11874 output.WriteRawTag(168, 16);
11875 output.WriteInt32(MipPresolveLevel);
11877 if (HasPushAllTasksTowardStart) {
11878 output.WriteRawTag(176, 16);
11879 output.WriteBool(PushAllTasksTowardStart);
11881 if (HasUseDynamicPrecedenceInDisjunctive) {
11882 output.WriteRawTag(184, 16);
11883 output.WriteBool(UseDynamicPrecedenceInDisjunctive);
11885 if (HasFeasibilityJumpMaxExpandedConstraintSize) {
11886 output.WriteRawTag(192, 16);
11887 output.WriteInt32(FeasibilityJumpMaxExpandedConstraintSize);
11889 if (HasUseFeasibilityJump) {
11890 output.WriteRawTag(200, 16);
11891 output.WriteBool(UseFeasibilityJump);
11893 if (HasLpPrimalTolerance) {
11894 output.WriteRawTag(209, 16);
11895 output.WriteDouble(LpPrimalTolerance);
11897 if (HasLpDualTolerance) {
11898 output.WriteRawTag(217, 16);
11899 output.WriteDouble(LpDualTolerance);
11901 if (HasUseDynamicPrecedenceInCumulative) {
11902 output.WriteRawTag(224, 16);
11903 output.WriteBool(UseDynamicPrecedenceInCumulative);
11905 if (HasUseExtendedProbing) {
11906 output.WriteRawTag(232, 16);
11907 output.WriteBool(UseExtendedProbing);
11909 if (HasAtMostOneMaxExpansionSize) {
11910 output.WriteRawTag(240, 16);
11911 output.WriteInt32(AtMostOneMaxExpansionSize);
11913 if (HasUseAreaEnergeticReasoningInNoOverlap2D) {
11914 output.WriteRawTag(248, 16);
11915 output.WriteBool(UseAreaEnergeticReasoningInNoOverlap2D);
11917 if (HasProbingNumCombinationsLimit) {
11918 output.WriteRawTag(128, 17);
11919 output.WriteInt32(ProbingNumCombinationsLimit);
11921 if (HasInprocessingDtimeRatio) {
11922 output.WriteRawTag(137, 17);
11923 output.WriteDouble(InprocessingDtimeRatio);
11925 if (HasInprocessingProbingDtime) {
11926 output.WriteRawTag(145, 17);
11927 output.WriteDouble(InprocessingProbingDtime);
11929 if (HasInprocessingMinimizationDtime) {
11930 output.WriteRawTag(153, 17);
11931 output.WriteDouble(InprocessingMinimizationDtime);
11933 if (HasMaxPairsPairwiseReasoningInNoOverlap2D) {
11934 output.WriteRawTag(160, 17);
11935 output.WriteInt32(MaxPairsPairwiseReasoningInNoOverlap2D);
11937 if (HasDetectLinearizedProduct) {
11938 output.WriteRawTag(168, 17);
11939 output.WriteBool(DetectLinearizedProduct);
11941 if (HasMipTreatHighMagnitudeBoundsAsInfinity) {
11942 output.WriteRawTag(176, 17);
11943 output.WriteBool(MipTreatHighMagnitudeBoundsAsInfinity);
11945 if (HasAddRltCuts) {
11946 output.WriteRawTag(184, 17);
11947 output.WriteBool(AddRltCuts);
11949 if (HasMaxLinMaxSizeForExpansion) {
11950 output.WriteRawTag(192, 17);
11951 output.WriteInt32(MaxLinMaxSizeForExpansion);
11953 if (HasSharedTreeOpenLeavesPerWorker) {
11954 output.WriteRawTag(201, 17);
11955 output.WriteDouble(SharedTreeOpenLeavesPerWorker);
11957 if (HasSharedTreeWorkerMinRestartsPerSubtree) {
11958 output.WriteRawTag(208, 17);
11959 output.WriteInt32(SharedTreeWorkerMinRestartsPerSubtree);
11962 output.WriteRawTag(216, 17);
11963 output.WriteBool(UseLns);
11965 if (HasSaveLpBasisInLbTreeSearch) {
11966 output.WriteRawTag(224, 17);
11967 output.WriteBool(SaveLpBasisInLbTreeSearch);
11969 if (HasShareGlueClauses) {
11970 output.WriteRawTag(232, 17);
11971 output.WriteBool(ShareGlueClauses);
11973 if (HasUseConservativeScaleOverloadChecker) {
11974 output.WriteRawTag(240, 17);
11975 output.WriteBool(UseConservativeScaleOverloadChecker);
11977 if (HasEncodeCumulativeAsReservoir) {
11978 output.WriteRawTag(248, 17);
11979 output.WriteBool(EncodeCumulativeAsReservoir);
11981 if (HasExpandReservoirUsingCircuit) {
11982 output.WriteRawTag(128, 18);
11983 output.WriteBool(ExpandReservoirUsingCircuit);
11985 if (HasVariablesShavingLevel) {
11986 output.WriteRawTag(136, 18);
11987 output.WriteInt32(VariablesShavingLevel);
11989 if (HasShavingSearchThreshold) {
11990 output.WriteRawTag(144, 18);
11991 output.WriteInt64(ShavingSearchThreshold);
11993 if (HasMaxNumDeterministicBatches) {
11994 output.WriteRawTag(152, 18);
11995 output.WriteInt32(MaxNumDeterministicBatches);
11997 if (HasFeasibilityJumpBatchDtime) {
11998 output.WriteRawTag(161, 18);
11999 output.WriteDouble(FeasibilityJumpBatchDtime);
12001 filterSubsolvers_.WriteTo(output, _repeated_filterSubsolvers_codec);
12002 if (HasNumFullSubsolvers) {
12003 output.WriteRawTag(176, 18);
12004 output.WriteInt32(NumFullSubsolvers);
12006 if (HasSharedTreeWorkerEnableTrailSharing) {
12007 output.WriteRawTag(184, 18);
12008 output.WriteBool(SharedTreeWorkerEnableTrailSharing);
12010 if (HasLbRelaxNumWorkersThreshold) {
12011 output.WriteRawTag(192, 18);
12012 output.WriteInt32(LbRelaxNumWorkersThreshold);
12014 if (HasInprocessingMinimizationUseConflictAnalysis) {
12015 output.WriteRawTag(200, 18);
12016 output.WriteBool(InprocessingMinimizationUseConflictAnalysis);
12018 if (HasInprocessingMinimizationUseAllOrderings) {
12019 output.WriteRawTag(208, 18);
12020 output.WriteBool(InprocessingMinimizationUseAllOrderings);
12022 if (HasUseTryEdgeReasoningInNoOverlap2D) {
12023 output.WriteRawTag(216, 18);
12024 output.WriteBool(UseTryEdgeReasoningInNoOverlap2D);
12026 if (HasMinimizeSharedClauses) {
12027 output.WriteRawTag(224, 18);
12028 output.WriteBool(MinimizeSharedClauses);
12030 if (HasUseSymmetryInLp) {
12031 output.WriteRawTag(232, 18);
12032 output.WriteBool(UseSymmetryInLp);
12034 if (HasSymmetryDetectionDeterministicTimeLimit) {
12035 output.WriteRawTag(241, 18);
12036 output.WriteDouble(SymmetryDetectionDeterministicTimeLimit);
12038 if (HasKeepSymmetryInPresolve) {
12039 output.WriteRawTag(248, 18);
12040 output.WriteBool(KeepSymmetryInPresolve);
12042 if (HasSharedTreeWorkerEnablePhaseSharing) {
12043 output.WriteRawTag(128, 19);
12044 output.WriteBool(SharedTreeWorkerEnablePhaseSharing);
12046 if (HasSharedTreeBalanceTolerance) {
12047 output.WriteRawTag(136, 19);
12048 output.WriteInt32(SharedTreeBalanceTolerance);
12050 if (HasDebugCrashIfPresolveBreaksHint) {
12051 output.WriteRawTag(144, 19);
12052 output.WriteBool(DebugCrashIfPresolveBreaksHint);
12054 if (HasLnsInitialDifficulty) {
12055 output.WriteRawTag(153, 19);
12056 output.WriteDouble(LnsInitialDifficulty);
12058 if (HasLnsInitialDeterministicLimit) {
12059 output.WriteRawTag(161, 19);
12060 output.WriteDouble(LnsInitialDeterministicLimit);
12062 if (HasPolarityExploitLsHints) {
12063 output.WriteRawTag(168, 19);
12064 output.WriteBool(PolarityExploitLsHints);
12066 if (HasRemoveFixedVariablesEarly) {
12067 output.WriteRawTag(176, 19);
12068 output.WriteBool(RemoveFixedVariablesEarly);
12070 if (HasUseAllDifferentForCircuit) {
12071 output.WriteRawTag(184, 19);
12072 output.WriteBool(UseAllDifferentForCircuit);
12074 if (HasRoutingCutSubsetSizeForBinaryRelationBound) {
12075 output.WriteRawTag(192, 19);
12076 output.WriteInt32(RoutingCutSubsetSizeForBinaryRelationBound);
12078 if (HasRoutingCutSubsetSizeForTightBinaryRelationBound) {
12079 output.WriteRawTag(200, 19);
12080 output.WriteInt32(RoutingCutSubsetSizeForTightBinaryRelationBound);
12082 if (HasRoutingCutDpEffort) {
12083 output.WriteRawTag(209, 19);
12084 output.WriteDouble(RoutingCutDpEffort);
12086 if (HasMaximumRegionsToSplitInDisconnectedNoOverlap2D) {
12087 output.WriteRawTag(216, 19);
12088 output.WriteInt32(MaximumRegionsToSplitInDisconnectedNoOverlap2D);
12090 if (HasRoutingCutSubsetSizeForExactBinaryRelationBound) {
12091 output.WriteRawTag(224, 19);
12092 output.WriteInt32(RoutingCutSubsetSizeForExactBinaryRelationBound);
12094 if (HasRoutingCutMaxInfeasiblePathLength) {
12095 output.WriteRawTag(232, 19);
12096 output.WriteInt32(RoutingCutMaxInfeasiblePathLength);
12098 if (HasRoutingCutSubsetSizeForShortestPathsBound) {
12099 output.WriteRawTag(240, 19);
12100 output.WriteInt32(RoutingCutSubsetSizeForShortestPathsBound);
12102 if (HasMaxAlldiffDomainSize) {
12103 output.WriteRawTag(128, 20);
12104 output.WriteInt32(MaxAlldiffDomainSize);
12106 if (HasNoOverlap2DBooleanRelationsLimit) {
12107 output.WriteRawTag(136, 20);
12108 output.WriteInt32(NoOverlap2DBooleanRelationsLimit);
12110 if (HasShareGlueClausesDtime) {
12111 output.WriteRawTag(145, 20);
12112 output.WriteDouble(ShareGlueClausesDtime);
12114 if (HasUseLinear3ForNoOverlap2DPrecedences) {
12115 output.WriteRawTag(152, 20);
12116 output.WriteBool(UseLinear3ForNoOverlap2DPrecedences);
12118 if (HasFilterSatPostsolveClauses) {
12119 output.WriteRawTag(160, 20);
12120 output.WriteBool(FilterSatPostsolveClauses);
12122 if (HasAlternativePoolSize) {
12123 output.WriteRawTag(168, 20);
12124 output.WriteInt32(AlternativePoolSize);
12126 if (HasShareLinear2Bounds) {
12127 output.WriteRawTag(176, 20);
12128 output.WriteBool(ShareLinear2Bounds);
12130 if (HasTransitivePrecedencesWorkLimit) {
12131 output.WriteRawTag(184, 20);
12132 output.WriteInt32(TransitivePrecedencesWorkLimit);
12134 if (HasSharedTreeSplitMinDtime) {
12135 output.WriteRawTag(193, 20);
12136 output.WriteDouble(SharedTreeSplitMinDtime);
12138 if (HasSolutionPoolDiversityLimit) {
12139 output.WriteRawTag(200, 20);
12140 output.WriteInt32(SolutionPoolDiversityLimit);
12142 if (HasUseChronologicalBacktracking) {
12143 output.WriteRawTag(208, 20);
12144 output.WriteBool(UseChronologicalBacktracking);
12146 if (HasMaxBackjumpLevels) {
12147 output.WriteRawTag(216, 20);
12148 output.WriteInt32(MaxBackjumpLevels);
12150 if (HasChronologicalBacktrackMinConflicts) {
12151 output.WriteRawTag(224, 20);
12152 output.WriteInt32(ChronologicalBacktrackMinConflicts);
12154 if (HasFindClausesThatAreExactlyOne) {
12155 output.WriteRawTag(232, 20);
12156 output.WriteBool(FindClausesThatAreExactlyOne);
12158 if (HasLoadAtMostOnesInSatPresolve) {
12159 output.WriteRawTag(248, 20);
12160 output.WriteBool(LoadAtMostOnesInSatPresolve);
12162 if (HasUseNewIntegerConflictResolution) {
12163 output.WriteRawTag(128, 21);
12164 output.WriteBool(UseNewIntegerConflictResolution);
12166 if (HasClauseCleanupPeriodIncrement) {
12167 output.WriteRawTag(136, 21);
12168 output.WriteInt32(ClauseCleanupPeriodIncrement);
12170 if (HasDebugCrashIfLratCheckFails) {
12171 output.WriteRawTag(152, 21);
12172 output.WriteBool(DebugCrashIfLratCheckFails);
12174 if (HasMaxDomainSizeForLinear2Expansion) {
12175 output.WriteRawTag(160, 21);
12176 output.WriteInt32(MaxDomainSizeForLinear2Expansion);
12178 if (HasCreate1UipBooleanDuringIcr) {
12179 output.WriteRawTag(168, 21);
12180 output.WriteBool(Create1UipBooleanDuringIcr);
12182 if (HasInprocessingUseCongruenceClosure) {
12183 output.WriteRawTag(176, 21);
12184 output.WriteBool(InprocessingUseCongruenceClosure);
12186 if (HasEagerlySubsumeLastNConflicts) {
12187 output.WriteRawTag(184, 21);
12188 output.WriteInt32(EagerlySubsumeLastNConflicts);
12190 if (HasCheckLratProof) {
12191 output.WriteRawTag(192, 21);
12192 output.WriteBool(CheckLratProof);
12194 if (HasOutputLratProof) {
12195 output.WriteRawTag(200, 21);
12196 output.WriteBool(OutputLratProof);
12198 if (HasCheckDratProof) {
12199 output.WriteRawTag(208, 21);
12200 output.WriteBool(CheckDratProof);
12202 if (HasOutputDratProof) {
12203 output.WriteRawTag(216, 21);
12204 output.WriteBool(OutputDratProof);
12206 if (HasMaxDratTimeInSeconds) {
12207 output.WriteRawTag(225, 21);
12208 output.WriteDouble(MaxDratTimeInSeconds);
12210 if (HasClauseCleanupLbdTier1) {
12211 output.WriteRawTag(232, 21);
12212 output.WriteInt32(ClauseCleanupLbdTier1);
12214 if (HasClauseCleanupLbdTier2) {
12215 output.WriteRawTag(240, 21);
12216 output.WriteInt32(ClauseCleanupLbdTier2);
12218 if (HasExtraSubsumptionDuringConflictAnalysis) {
12219 output.WriteRawTag(248, 21);
12220 output.WriteBool(ExtraSubsumptionDuringConflictAnalysis);
12222 if (HasCheckMergedLratProof) {
12223 output.WriteRawTag(128, 22);
12224 output.WriteBool(CheckMergedLratProof);
12226 if (HasDecisionSubsumptionDuringConflictAnalysis) {
12227 output.WriteRawTag(136, 22);
12228 output.WriteBool(DecisionSubsumptionDuringConflictAnalysis);
12230 if (HasInprocessingUseSatSweeping) {
12231 output.WriteRawTag(144, 22);
12232 output.WriteBool(InprocessingUseSatSweeping);
12234 if (HasSubsumeDuringVivification) {
12235 output.WriteRawTag(152, 22);
12236 output.WriteBool(SubsumeDuringVivification);
12238 if (_unknownFields !=
null) {
12239 _unknownFields.WriteTo(output);
12244 #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
12245 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
12246 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
12247 void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
12248 if (HasPreferredVariableOrder) {
12249 output.WriteRawTag(8);
12250 output.WriteEnum((
int) PreferredVariableOrder);
12252 if (HasInitialPolarity) {
12253 output.WriteRawTag(16);
12254 output.WriteEnum((
int) InitialPolarity);
12256 if (HasMinimizationAlgorithm) {
12257 output.WriteRawTag(32);
12258 output.WriteEnum((
int) MinimizationAlgorithm);
12260 if (HasClauseCleanupPeriod) {
12261 output.WriteRawTag(88);
12262 output.WriteInt32(ClauseCleanupPeriod);
12264 if (HasClauseCleanupTarget) {
12265 output.WriteRawTag(104);
12266 output.WriteInt32(ClauseCleanupTarget);
12268 if (HasVariableActivityDecay) {
12269 output.WriteRawTag(121);
12270 output.WriteDouble(VariableActivityDecay);
12272 if (HasMaxVariableActivityValue) {
12273 output.WriteRawTag(129, 1);
12274 output.WriteDouble(MaxVariableActivityValue);
12276 if (HasClauseActivityDecay) {
12277 output.WriteRawTag(137, 1);
12278 output.WriteDouble(ClauseActivityDecay);
12280 if (HasMaxClauseActivityValue) {
12281 output.WriteRawTag(145, 1);
12282 output.WriteDouble(MaxClauseActivityValue);
12284 if (HasGlucoseMaxDecay) {
12285 output.WriteRawTag(177, 1);
12286 output.WriteDouble(GlucoseMaxDecay);
12288 if (HasGlucoseDecayIncrement) {
12289 output.WriteRawTag(185, 1);
12290 output.WriteDouble(GlucoseDecayIncrement);
12292 if (HasGlucoseDecayIncrementPeriod) {
12293 output.WriteRawTag(192, 1);
12294 output.WriteInt32(GlucoseDecayIncrementPeriod);
12296 if (HasRestartPeriod) {
12297 output.WriteRawTag(240, 1);
12298 output.WriteInt32(RestartPeriod);
12300 if (HasRandomSeed) {
12301 output.WriteRawTag(248, 1);
12302 output.WriteInt32(RandomSeed);
12304 if (HasRandomBranchesRatio) {
12305 output.WriteRawTag(129, 2);
12306 output.WriteDouble(RandomBranchesRatio);
12308 if (HasBinaryMinimizationAlgorithm) {
12309 output.WriteRawTag(144, 2);
12310 output.WriteEnum((
int) BinaryMinimizationAlgorithm);
12312 if (HasUseOptimizationHints) {
12313 output.WriteRawTag(152, 2);
12314 output.WriteBool(UseOptimizationHints);
12316 if (HasMaxTimeInSeconds) {
12317 output.WriteRawTag(161, 2);
12318 output.WriteDouble(MaxTimeInSeconds);
12320 if (HasMaxNumberOfConflicts) {
12321 output.WriteRawTag(168, 2);
12322 output.WriteInt64(MaxNumberOfConflicts);
12324 if (HasMaxMemoryInMb) {
12325 output.WriteRawTag(192, 2);
12326 output.WriteInt64(MaxMemoryInMb);
12328 if (HasLogSearchProgress) {
12329 output.WriteRawTag(200, 2);
12330 output.WriteBool(LogSearchProgress);
12332 if (HasUsePbResolution) {
12333 output.WriteRawTag(216, 2);
12334 output.WriteBool(UsePbResolution);
12336 if (HasUsePhaseSaving) {
12337 output.WriteRawTag(224, 2);
12338 output.WriteBool(UsePhaseSaving);
12340 if (HasRandomPolarityRatio) {
12341 output.WriteRawTag(233, 2);
12342 output.WriteDouble(RandomPolarityRatio);
12344 if (HasPbCleanupIncrement) {
12345 output.WriteRawTag(240, 2);
12346 output.WriteInt32(PbCleanupIncrement);
12348 if (HasPbCleanupRatio) {
12349 output.WriteRawTag(249, 2);
12350 output.WriteDouble(PbCleanupRatio);
12352 if (HasMinimizeReductionDuringPbResolution) {
12353 output.WriteRawTag(128, 3);
12354 output.WriteBool(MinimizeReductionDuringPbResolution);
12356 if (HasCountAssumptionLevelsInLbd) {
12357 output.WriteRawTag(136, 3);
12358 output.WriteBool(CountAssumptionLevelsInLbd);
12360 if (HasCoreMinimizationLevel) {
12361 output.WriteRawTag(144, 3);
12362 output.WriteInt32(CoreMinimizationLevel);
12364 if (HasMaxSatAssumptionOrder) {
12365 output.WriteRawTag(152, 3);
12366 output.WriteEnum((
int) MaxSatAssumptionOrder);
12368 if (HasMaxSatReverseAssumptionOrder) {
12369 output.WriteRawTag(160, 3);
12370 output.WriteBool(MaxSatReverseAssumptionOrder);
12372 if (HasMaxSatStratification) {
12373 output.WriteRawTag(168, 3);
12374 output.WriteEnum((
int) MaxSatStratification);
12376 if (HasPresolveBveThreshold) {
12377 output.WriteRawTag(176, 3);
12378 output.WriteInt32(PresolveBveThreshold);
12380 if (HasPresolveBveClauseWeight) {
12381 output.WriteRawTag(184, 3);
12382 output.WriteInt32(PresolveBveClauseWeight);
12384 if (HasSubsumptionDuringConflictAnalysis) {
12385 output.WriteRawTag(192, 3);
12386 output.WriteBool(SubsumptionDuringConflictAnalysis);
12388 if (HasPresolveProbingDeterministicTimeLimit) {
12389 output.WriteRawTag(201, 3);
12390 output.WriteDouble(PresolveProbingDeterministicTimeLimit);
12392 if (HasClauseCleanupLbdBound) {
12393 output.WriteRawTag(216, 3);
12394 output.WriteInt32(ClauseCleanupLbdBound);
12396 if (HasClauseCleanupOrdering) {
12397 output.WriteRawTag(224, 3);
12398 output.WriteEnum((
int) ClauseCleanupOrdering);
12400 restartAlgorithms_.WriteTo(ref output, _repeated_restartAlgorithms_codec);
12401 if (HasRestartRunningWindowSize) {
12402 output.WriteRawTag(240, 3);
12403 output.WriteInt32(RestartRunningWindowSize);
12405 if (HasRestartDlAverageRatio) {
12406 output.WriteRawTag(249, 3);
12407 output.WriteDouble(RestartDlAverageRatio);
12409 if (HasUseBlockingRestart) {
12410 output.WriteRawTag(128, 4);
12411 output.WriteBool(UseBlockingRestart);
12413 if (HasBlockingRestartWindowSize) {
12414 output.WriteRawTag(136, 4);
12415 output.WriteInt32(BlockingRestartWindowSize);
12417 if (HasBlockingRestartMultiplier) {
12418 output.WriteRawTag(145, 4);
12419 output.WriteDouble(BlockingRestartMultiplier);
12421 if (HasMaxDeterministicTime) {
12422 output.WriteRawTag(153, 4);
12423 output.WriteDouble(MaxDeterministicTime);
12425 if (HasNumConflictsBeforeStrategyChanges) {
12426 output.WriteRawTag(160, 4);
12427 output.WriteInt32(NumConflictsBeforeStrategyChanges);
12429 if (HasStrategyChangeIncreaseRatio) {
12430 output.WriteRawTag(169, 4);
12431 output.WriteDouble(StrategyChangeIncreaseRatio);
12433 if (HasDefaultRestartAlgorithms) {
12434 output.WriteRawTag(178, 4);
12435 output.WriteString(DefaultRestartAlgorithms);
12437 if (HasRestartLbdAverageRatio) {
12438 output.WriteRawTag(185, 4);
12439 output.WriteDouble(RestartLbdAverageRatio);
12441 if (HasPresolveUseBva) {
12442 output.WriteRawTag(192, 4);
12443 output.WriteBool(PresolveUseBva);
12445 if (HasPresolveBvaThreshold) {
12446 output.WriteRawTag(200, 4);
12447 output.WriteInt32(PresolveBvaThreshold);
12449 if (HasUsePrecedencesInDisjunctiveConstraint) {
12450 output.WriteRawTag(208, 4);
12451 output.WriteBool(UsePrecedencesInDisjunctiveConstraint);
12453 if (HasUseErwaHeuristic) {
12454 output.WriteRawTag(216, 4);
12455 output.WriteBool(UseErwaHeuristic);
12457 if (HasInitialVariablesActivity) {
12458 output.WriteRawTag(225, 4);
12459 output.WriteDouble(InitialVariablesActivity);
12461 if (HasAlsoBumpVariablesInConflictReasons) {
12462 output.WriteRawTag(232, 4);
12463 output.WriteBool(AlsoBumpVariablesInConflictReasons);
12465 if (HasUseOverloadCheckerInCumulative) {
12466 output.WriteRawTag(240, 4);
12467 output.WriteBool(UseOverloadCheckerInCumulative);
12469 if (HasUseTimetableEdgeFindingInCumulative) {
12470 output.WriteRawTag(248, 4);
12471 output.WriteBool(UseTimetableEdgeFindingInCumulative);
12473 if (HasUseDisjunctiveConstraintInCumulative) {
12474 output.WriteRawTag(128, 5);
12475 output.WriteBool(UseDisjunctiveConstraintInCumulative);
12477 if (HasSearchBranching) {
12478 output.WriteRawTag(144, 5);
12479 output.WriteEnum((
int) SearchBranching);
12481 if (HasOptimizeWithCore) {
12482 output.WriteRawTag(152, 5);
12483 output.WriteBool(OptimizeWithCore);
12485 if (HasFindMultipleCores) {
12486 output.WriteRawTag(160, 5);
12487 output.WriteBool(FindMultipleCores);
12489 if (HasOptimizeWithMaxHs) {
12490 output.WriteRawTag(168, 5);
12491 output.WriteBool(OptimizeWithMaxHs);
12493 if (HasCpModelPresolve) {
12494 output.WriteRawTag(176, 5);
12495 output.WriteBool(CpModelPresolve);
12497 if (HasEnumerateAllSolutions) {
12498 output.WriteRawTag(184, 5);
12499 output.WriteBool(EnumerateAllSolutions);
12501 if (HasPresolveBlockedClause) {
12502 output.WriteRawTag(192, 5);
12503 output.WriteBool(PresolveBlockedClause);
12505 if (HasCoverOptimization) {
12506 output.WriteRawTag(200, 5);
12507 output.WriteBool(CoverOptimization);
12509 if (HasLinearizationLevel) {
12510 output.WriteRawTag(208, 5);
12511 output.WriteInt32(LinearizationLevel);
12513 if (HasMaxNumCuts) {
12514 output.WriteRawTag(216, 5);
12515 output.WriteInt32(MaxNumCuts);
12517 if (HasOnlyAddCutsAtLevelZero) {
12518 output.WriteRawTag(224, 5);
12519 output.WriteBool(OnlyAddCutsAtLevelZero);
12521 if (HasCpModelUseSatPresolve) {
12522 output.WriteRawTag(232, 5);
12523 output.WriteBool(CpModelUseSatPresolve);
12525 if (HasExploitIntegerLpSolution) {
12526 output.WriteRawTag(240, 5);
12527 output.WriteBool(ExploitIntegerLpSolution);
12529 if (HasAutoDetectGreaterThanAtLeastOneOf) {
12530 output.WriteRawTag(248, 5);
12531 output.WriteBool(AutoDetectGreaterThanAtLeastOneOf);
12533 if (HasStopAfterFirstSolution) {
12534 output.WriteRawTag(144, 6);
12535 output.WriteBool(StopAfterFirstSolution);
12537 if (HasBinarySearchNumConflicts) {
12538 output.WriteRawTag(152, 6);
12539 output.WriteInt32(BinarySearchNumConflicts);
12541 if (HasNumSearchWorkers) {
12542 output.WriteRawTag(160, 6);
12543 output.WriteInt32(NumSearchWorkers);
12545 if (HasUseLnsOnly) {
12546 output.WriteRawTag(168, 6);
12547 output.WriteBool(UseLnsOnly);
12549 if (HasRandomizeSearch) {
12550 output.WriteRawTag(184, 6);
12551 output.WriteBool(RandomizeSearch);
12553 if (HasSearchRandomVariablePoolSize) {
12554 output.WriteRawTag(192, 6);
12555 output.WriteInt64(SearchRandomVariablePoolSize);
12557 if (HasInstantiateAllVariables) {
12558 output.WriteRawTag(208, 6);
12559 output.WriteBool(InstantiateAllVariables);
12561 if (HasBooleanEncodingLevel) {
12562 output.WriteRawTag(216, 6);
12563 output.WriteInt32(BooleanEncodingLevel);
12565 if (HasUseOptionalVariables) {
12566 output.WriteRawTag(224, 6);
12567 output.WriteBool(UseOptionalVariables);
12569 if (HasUseExactLpReason) {
12570 output.WriteRawTag(232, 6);
12571 output.WriteBool(UseExactLpReason);
12573 if (HasCpModelProbingLevel) {
12574 output.WriteRawTag(240, 6);
12575 output.WriteInt32(CpModelProbingLevel);
12577 if (HasAddLpConstraintsLazily) {
12578 output.WriteRawTag(128, 7);
12579 output.WriteBool(AddLpConstraintsLazily);
12581 if (HasShareObjectiveBounds) {
12582 output.WriteRawTag(136, 7);
12583 output.WriteBool(ShareObjectiveBounds);
12585 if (HasShareLevelZeroBounds) {
12586 output.WriteRawTag(144, 7);
12587 output.WriteBool(ShareLevelZeroBounds);
12589 if (HasMinOrthogonalityForLpConstraints) {
12590 output.WriteRawTag(153, 7);
12591 output.WriteDouble(MinOrthogonalityForLpConstraints);
12593 if (HasExploitAllLpSolution) {
12594 output.WriteRawTag(160, 7);
12595 output.WriteBool(ExploitAllLpSolution);
12597 if (HasAddCgCuts) {
12598 output.WriteRawTag(168, 7);
12599 output.WriteBool(AddCgCuts);
12601 if (HasMaxIntegerRoundingScaling) {
12602 output.WriteRawTag(184, 7);
12603 output.WriteInt32(MaxIntegerRoundingScaling);
12605 if (HasAddMirCuts) {
12606 output.WriteRawTag(192, 7);
12607 output.WriteBool(AddMirCuts);
12609 if (HasMaxConsecutiveInactiveCount) {
12610 output.WriteRawTag(200, 7);
12611 output.WriteInt32(MaxConsecutiveInactiveCount);
12613 if (HasNewConstraintsBatchSize) {
12614 output.WriteRawTag(208, 7);
12615 output.WriteInt32(NewConstraintsBatchSize);
12617 if (HasPseudoCostReliabilityThreshold) {
12618 output.WriteRawTag(216, 7);
12619 output.WriteInt64(PseudoCostReliabilityThreshold);
12621 if (HasMipMaxBound) {
12622 output.WriteRawTag(225, 7);
12623 output.WriteDouble(MipMaxBound);
12625 if (HasMipVarScaling) {
12626 output.WriteRawTag(233, 7);
12627 output.WriteDouble(MipVarScaling);
12629 if (HasMipWantedPrecision) {
12630 output.WriteRawTag(241, 7);
12631 output.WriteDouble(MipWantedPrecision);
12633 if (HasMipMaxActivityExponent) {
12634 output.WriteRawTag(248, 7);
12635 output.WriteInt32(MipMaxActivityExponent);
12637 if (HasMipCheckPrecision) {
12638 output.WriteRawTag(129, 8);
12639 output.WriteDouble(MipCheckPrecision);
12641 if (HasUseRinsLns) {
12642 output.WriteRawTag(136, 8);
12643 output.WriteBool(UseRinsLns);
12645 if (HasExploitBestSolution) {
12646 output.WriteRawTag(144, 8);
12647 output.WriteBool(ExploitBestSolution);
12649 if (HasExploitObjective) {
12650 output.WriteRawTag(152, 8);
12651 output.WriteBool(ExploitObjective);
12653 if (HasFillTightenedDomainsInResponse) {
12654 output.WriteRawTag(160, 8);
12655 output.WriteBool(FillTightenedDomainsInResponse);
12657 if (HasUseCombinedNoOverlap) {
12658 output.WriteRawTag(168, 8);
12659 output.WriteBool(UseCombinedNoOverlap);
12661 if (HasInterleaveBatchSize) {
12662 output.WriteRawTag(176, 8);
12663 output.WriteInt32(InterleaveBatchSize);
12665 if (HasCatchSigintSignal) {
12666 output.WriteRawTag(184, 8);
12667 output.WriteBool(CatchSigintSignal);
12669 if (HasInterleaveSearch) {
12670 output.WriteRawTag(192, 8);
12671 output.WriteBool(InterleaveSearch);
12673 if (HasDiversifyLnsParams) {
12674 output.WriteRawTag(200, 8);
12675 output.WriteBool(DiversifyLnsParams);
12677 if (HasMaxPresolveIterations) {
12678 output.WriteRawTag(208, 8);
12679 output.WriteInt32(MaxPresolveIterations);
12681 if (HasUseImpliedBounds) {
12682 output.WriteRawTag(128, 9);
12683 output.WriteBool(UseImpliedBounds);
12685 if (HasMergeNoOverlapWorkLimit) {
12686 output.WriteRawTag(137, 9);
12687 output.WriteDouble(MergeNoOverlapWorkLimit);
12689 if (HasMergeAtMostOneWorkLimit) {
12690 output.WriteRawTag(145, 9);
12691 output.WriteDouble(MergeAtMostOneWorkLimit);
12693 if (HasPresolveSubstitutionLevel) {
12694 output.WriteRawTag(152, 9);
12695 output.WriteInt32(PresolveSubstitutionLevel);
12697 if (HasMaxAllDiffCutSize) {
12698 output.WriteRawTag(160, 9);
12699 output.WriteInt32(MaxAllDiffCutSize);
12701 if (HasStopAfterPresolve) {
12702 output.WriteRawTag(168, 9);
12703 output.WriteBool(StopAfterPresolve);
12705 if (HasDebugMaxNumPresolveOperations) {
12706 output.WriteRawTag(184, 9);
12707 output.WriteInt32(DebugMaxNumPresolveOperations);
12709 if (HasAddLinMaxCuts) {
12710 output.WriteRawTag(192, 9);
12711 output.WriteBool(AddLinMaxCuts);
12713 if (HasHintConflictLimit) {
12714 output.WriteRawTag(200, 9);
12715 output.WriteInt32(HintConflictLimit);
12717 if (HasMaxCutRoundsAtLevelZero) {
12718 output.WriteRawTag(208, 9);
12719 output.WriteInt32(MaxCutRoundsAtLevelZero);
12721 if (HasCutMaxActiveCountValue) {
12722 output.WriteRawTag(217, 9);
12723 output.WriteDouble(CutMaxActiveCountValue);
12725 if (HasCutActiveCountDecay) {
12726 output.WriteRawTag(225, 9);
12727 output.WriteDouble(CutActiveCountDecay);
12729 if (HasCutCleanupTarget) {
12730 output.WriteRawTag(232, 9);
12731 output.WriteInt32(CutCleanupTarget);
12733 if (HasAbsoluteGapLimit) {
12734 output.WriteRawTag(249, 9);
12735 output.WriteDouble(AbsoluteGapLimit);
12737 if (HasRelativeGapLimit) {
12738 output.WriteRawTag(129, 10);
12739 output.WriteDouble(RelativeGapLimit);
12741 if (HasExploitRelaxationSolution) {
12742 output.WriteRawTag(136, 10);
12743 output.WriteBool(ExploitRelaxationSolution);
12745 if (HasDebugPostsolveWithFullSolver) {
12746 output.WriteRawTag(144, 10);
12747 output.WriteBool(DebugPostsolveWithFullSolver);
12749 if (HasUseSatInprocessing) {
12750 output.WriteRawTag(152, 10);
12751 output.WriteBool(UseSatInprocessing);
12753 if (HasUseFeasibilityPump) {
12754 output.WriteRawTag(160, 10);
12755 output.WriteBool(UseFeasibilityPump);
12757 if (HasFpRounding) {
12758 output.WriteRawTag(168, 10);
12759 output.WriteEnum((
int) FpRounding);
12761 if (HasMipAutomaticallyScaleVariables) {
12762 output.WriteRawTag(176, 10);
12763 output.WriteBool(MipAutomaticallyScaleVariables);
12765 if (HasRepairHint) {
12766 output.WriteRawTag(184, 10);
12767 output.WriteBool(RepairHint);
12769 if (HasPolarityRephaseIncrement) {
12770 output.WriteRawTag(192, 10);
12771 output.WriteInt32(PolarityRephaseIncrement);
12773 if (HasAddZeroHalfCuts) {
12774 output.WriteRawTag(200, 10);
12775 output.WriteBool(AddZeroHalfCuts);
12777 if (HasExpandAlldiffConstraints) {
12778 output.WriteRawTag(208, 10);
12779 output.WriteBool(ExpandAlldiffConstraints);
12782 output.WriteRawTag(218, 10);
12783 output.WriteString(Name);
12785 if (HasAddCliqueCuts) {
12786 output.WriteRawTag(224, 10);
12787 output.WriteBool(AddCliqueCuts);
12789 if (HasKeepAllFeasibleSolutionsInPresolve) {
12790 output.WriteRawTag(232, 10);
12791 output.WriteBool(KeepAllFeasibleSolutionsInPresolve);
12793 if (HasPresolveExtractIntegerEnforcement) {
12794 output.WriteRawTag(240, 10);
12795 output.WriteBool(PresolveExtractIntegerEnforcement);
12797 if (HasPolishLpSolution) {
12798 output.WriteRawTag(248, 10);
12799 output.WriteBool(PolishLpSolution);
12801 if (HasUseProbingSearch) {
12802 output.WriteRawTag(128, 11);
12803 output.WriteBool(UseProbingSearch);
12805 if (HasConvertIntervals) {
12806 output.WriteRawTag(136, 11);
12807 output.WriteBool(ConvertIntervals);
12809 if (HasPermuteVariableRandomly) {
12810 output.WriteRawTag(144, 11);
12811 output.WriteBool(PermuteVariableRandomly);
12813 if (HasPermutePresolveConstraintOrder) {
12814 output.WriteRawTag(152, 11);
12815 output.WriteBool(PermutePresolveConstraintOrder);
12817 if (HasUseAbslRandom) {
12818 output.WriteRawTag(160, 11);
12819 output.WriteBool(UseAbslRandom);
12821 if (HasDisableConstraintExpansion) {
12822 output.WriteRawTag(168, 11);
12823 output.WriteBool(DisableConstraintExpansion);
12825 if (HasExpandReservoirConstraints) {
12826 output.WriteRawTag(176, 11);
12827 output.WriteBool(ExpandReservoirConstraints);
12829 if (HasSymmetryLevel) {
12830 output.WriteRawTag(184, 11);
12831 output.WriteInt32(SymmetryLevel);
12833 if (HasLogPrefix) {
12834 output.WriteRawTag(202, 11);
12835 output.WriteString(LogPrefix);
12837 if (HasLogToStdout) {
12838 output.WriteRawTag(208, 11);
12839 output.WriteBool(LogToStdout);
12841 if (HasLogToResponse) {
12842 output.WriteRawTag(216, 11);
12843 output.WriteBool(LogToResponse);
12845 if (HasOptimizeWithLbTreeSearch) {
12846 output.WriteRawTag(224, 11);
12847 output.WriteBool(OptimizeWithLbTreeSearch);
12849 if (HasLogSubsolverStatistics) {
12850 output.WriteRawTag(232, 11);
12851 output.WriteBool(LogSubsolverStatistics);
12853 if (HasClauseCleanupRatio) {
12854 output.WriteRawTag(241, 11);
12855 output.WriteDouble(ClauseCleanupRatio);
12857 if (HasMaxDomainSizeWhenEncodingEqNeqConstraints) {
12858 output.WriteRawTag(248, 11);
12859 output.WriteInt32(MaxDomainSizeWhenEncodingEqNeqConstraints);
12861 if (HasFixVariablesToTheirHintedValue) {
12862 output.WriteRawTag(128, 12);
12863 output.WriteBool(FixVariablesToTheirHintedValue);
12865 if (HasSolutionPoolSize) {
12866 output.WriteRawTag(136, 12);
12867 output.WriteInt32(SolutionPoolSize);
12869 if (HasFillAdditionalSolutionsInResponse) {
12870 output.WriteRawTag(144, 12);
12871 output.WriteBool(FillAdditionalSolutionsInResponse);
12873 if (HasDebugCrashOnBadHint) {
12874 output.WriteRawTag(152, 12);
12875 output.WriteBool(DebugCrashOnBadHint);
12878 output.WriteRawTag(160, 12);
12879 output.WriteInt32(CutLevel);
12881 if (HasAddObjectiveCut) {
12882 output.WriteRawTag(168, 12);
12883 output.WriteBool(AddObjectiveCut);
12885 if (HasMipComputeTrueObjectiveBound) {
12886 output.WriteRawTag(176, 12);
12887 output.WriteBool(MipComputeTrueObjectiveBound);
12889 if (HasMipMaxValidMagnitude) {
12890 output.WriteRawTag(185, 12);
12891 output.WriteDouble(MipMaxValidMagnitude);
12893 if (HasUseTimetablingInNoOverlap2D) {
12894 output.WriteRawTag(192, 12);
12895 output.WriteBool(UseTimetablingInNoOverlap2D);
12897 if (HasPresolveInclusionWorkLimit) {
12898 output.WriteRawTag(200, 12);
12899 output.WriteInt64(PresolveInclusionWorkLimit);
12901 if (HasIgnoreNames) {
12902 output.WriteRawTag(208, 12);
12903 output.WriteBool(IgnoreNames);
12905 if (HasShareBinaryClauses) {
12906 output.WriteRawTag(216, 12);
12907 output.WriteBool(ShareBinaryClauses);
12909 if (HasShavingDeterministicTimeInProbingSearch) {
12910 output.WriteRawTag(225, 12);
12911 output.WriteDouble(ShavingDeterministicTimeInProbingSearch);
12913 if (HasShavingSearchDeterministicTime) {
12914 output.WriteRawTag(233, 12);
12915 output.WriteDouble(ShavingSearchDeterministicTime);
12917 if (HasNumWorkers) {
12918 output.WriteRawTag(240, 12);
12919 output.WriteInt32(NumWorkers);
12921 subsolvers_.WriteTo(ref output, _repeated_subsolvers_codec);
12922 ignoreSubsolvers_.WriteTo(ref output, _repeated_ignoreSubsolvers_codec);
12923 subsolverParams_.WriteTo(ref output, _repeated_subsolverParams_codec);
12924 if (HasUseEnergeticReasoningInNoOverlap2D) {
12925 output.WriteRawTag(168, 13);
12926 output.WriteBool(UseEnergeticReasoningInNoOverlap2D);
12928 if (HasUseDualSchedulingHeuristics) {
12929 output.WriteRawTag(176, 13);
12930 output.WriteBool(UseDualSchedulingHeuristics);
12932 if (HasUseHardPrecedencesInCumulative) {
12933 output.WriteRawTag(184, 13);
12934 output.WriteBool(UseHardPrecedencesInCumulative);
12936 if (HasDetectTableWithCost) {
12937 output.WriteRawTag(192, 13);
12938 output.WriteBool(DetectTableWithCost);
12940 if (HasTableCompressionLevel) {
12941 output.WriteRawTag(200, 13);
12942 output.WriteInt32(TableCompressionLevel);
12944 extraSubsolvers_.WriteTo(ref output, _repeated_extraSubsolvers_codec);
12945 if (HasExploitAllPrecedences) {
12946 output.WriteRawTag(224, 13);
12947 output.WriteBool(ExploitAllPrecedences);
12949 if (HasPropagationLoopDetectionFactor) {
12950 output.WriteRawTag(233, 13);
12951 output.WriteDouble(PropagationLoopDetectionFactor);
12953 if (HasOnlySolveIp) {
12954 output.WriteRawTag(240, 13);
12955 output.WriteBool(OnlySolveIp);
12957 if (HasEncodeComplexLinearConstraintWithInteger) {
12958 output.WriteRawTag(248, 13);
12959 output.WriteBool(EncodeComplexLinearConstraintWithInteger);
12961 if (HasNewLinearPropagation) {
12962 output.WriteRawTag(128, 14);
12963 output.WriteBool(NewLinearPropagation);
12965 if (HasMipScaleLargeDomain) {
12966 output.WriteRawTag(136, 14);
12967 output.WriteBool(MipScaleLargeDomain);
12969 if (HasProbingDeterministicTimeLimit) {
12970 output.WriteRawTag(145, 14);
12971 output.WriteDouble(ProbingDeterministicTimeLimit);
12973 if (HasRootLpIterations) {
12974 output.WriteRawTag(152, 14);
12975 output.WriteInt32(RootLpIterations);
12977 if (HasUseObjectiveLbSearch) {
12978 output.WriteRawTag(160, 14);
12979 output.WriteBool(UseObjectiveLbSearch);
12981 if (HasMaxSizeToCreatePrecedenceLiteralsInDisjunctive) {
12982 output.WriteRawTag(168, 14);
12983 output.WriteInt32(MaxSizeToCreatePrecedenceLiteralsInDisjunctive);
12985 if (HasUseStrongPropagationInDisjunctive) {
12986 output.WriteRawTag(176, 14);
12987 output.WriteBool(UseStrongPropagationInDisjunctive);
12989 if (HasMipDropTolerance) {
12990 output.WriteRawTag(193, 14);
12991 output.WriteDouble(MipDropTolerance);
12993 if (HasInferAllDiffs) {
12994 output.WriteRawTag(200, 14);
12995 output.WriteBool(InferAllDiffs);
12997 if (HasFindBigLinearOverlap) {
12998 output.WriteRawTag(208, 14);
12999 output.WriteBool(FindBigLinearOverlap);
13001 if (HasSharedTreeNumWorkers) {
13002 output.WriteRawTag(216, 14);
13003 output.WriteInt32(SharedTreeNumWorkers);
13005 if (HasUseSharedTreeSearch) {
13006 output.WriteRawTag(224, 14);
13007 output.WriteBool(UseSharedTreeSearch);
13009 if (HasSharedTreeMaxNodesPerWorker) {
13010 output.WriteRawTag(240, 14);
13011 output.WriteInt32(SharedTreeMaxNodesPerWorker);
13013 if (HasSharedTreeSplitStrategy) {
13014 output.WriteRawTag(248, 14);
13015 output.WriteEnum((
int) SharedTreeSplitStrategy);
13017 if (HasUseLsOnly) {
13018 output.WriteRawTag(128, 15);
13019 output.WriteBool(UseLsOnly);
13021 if (HasFeasibilityJumpDecay) {
13022 output.WriteRawTag(145, 15);
13023 output.WriteDouble(FeasibilityJumpDecay);
13025 if (HasNumViolationLs) {
13026 output.WriteRawTag(160, 15);
13027 output.WriteInt32(NumViolationLs);
13029 if (HasFeasibilityJumpVarRandomizationProbability) {
13030 output.WriteRawTag(185, 15);
13031 output.WriteDouble(FeasibilityJumpVarRandomizationProbability);
13033 if (HasFeasibilityJumpVarPerburbationRangeRatio) {
13034 output.WriteRawTag(193, 15);
13035 output.WriteDouble(FeasibilityJumpVarPerburbationRangeRatio);
13037 if (HasViolationLsPerturbationPeriod) {
13038 output.WriteRawTag(200, 15);
13039 output.WriteInt32(ViolationLsPerturbationPeriod);
13041 if (HasFeasibilityJumpEnableRestarts) {
13042 output.WriteRawTag(208, 15);
13043 output.WriteBool(FeasibilityJumpEnableRestarts);
13045 if (HasStopAfterRootPropagation) {
13046 output.WriteRawTag(224, 15);
13047 output.WriteBool(StopAfterRootPropagation);
13049 if (HasUseObjectiveShavingSearch) {
13050 output.WriteRawTag(232, 15);
13051 output.WriteBool(UseObjectiveShavingSearch);
13053 if (HasUseLbRelaxLns) {
13054 output.WriteRawTag(248, 15);
13055 output.WriteBool(UseLbRelaxLns);
13057 if (HasLinearSplitSize) {
13058 output.WriteRawTag(128, 16);
13059 output.WriteInt32(LinearSplitSize);
13061 if (HasFeasibilityJumpLinearizationLevel) {
13062 output.WriteRawTag(136, 16);
13063 output.WriteInt32(FeasibilityJumpLinearizationLevel);
13065 if (HasFeasibilityJumpRestartFactor) {
13066 output.WriteRawTag(144, 16);
13067 output.WriteInt32(FeasibilityJumpRestartFactor);
13069 if (HasViolationLsCompoundMoveProbability) {
13070 output.WriteRawTag(153, 16);
13071 output.WriteDouble(ViolationLsCompoundMoveProbability);
13073 if (HasMaxNumIntervalsForTimetableEdgeFinding) {
13074 output.WriteRawTag(160, 16);
13075 output.WriteInt32(MaxNumIntervalsForTimetableEdgeFinding);
13077 if (HasMipPresolveLevel) {
13078 output.WriteRawTag(168, 16);
13079 output.WriteInt32(MipPresolveLevel);
13081 if (HasPushAllTasksTowardStart) {
13082 output.WriteRawTag(176, 16);
13083 output.WriteBool(PushAllTasksTowardStart);
13085 if (HasUseDynamicPrecedenceInDisjunctive) {
13086 output.WriteRawTag(184, 16);
13087 output.WriteBool(UseDynamicPrecedenceInDisjunctive);
13089 if (HasFeasibilityJumpMaxExpandedConstraintSize) {
13090 output.WriteRawTag(192, 16);
13091 output.WriteInt32(FeasibilityJumpMaxExpandedConstraintSize);
13093 if (HasUseFeasibilityJump) {
13094 output.WriteRawTag(200, 16);
13095 output.WriteBool(UseFeasibilityJump);
13097 if (HasLpPrimalTolerance) {
13098 output.WriteRawTag(209, 16);
13099 output.WriteDouble(LpPrimalTolerance);
13101 if (HasLpDualTolerance) {
13102 output.WriteRawTag(217, 16);
13103 output.WriteDouble(LpDualTolerance);
13105 if (HasUseDynamicPrecedenceInCumulative) {
13106 output.WriteRawTag(224, 16);
13107 output.WriteBool(UseDynamicPrecedenceInCumulative);
13109 if (HasUseExtendedProbing) {
13110 output.WriteRawTag(232, 16);
13111 output.WriteBool(UseExtendedProbing);
13113 if (HasAtMostOneMaxExpansionSize) {
13114 output.WriteRawTag(240, 16);
13115 output.WriteInt32(AtMostOneMaxExpansionSize);
13117 if (HasUseAreaEnergeticReasoningInNoOverlap2D) {
13118 output.WriteRawTag(248, 16);
13119 output.WriteBool(UseAreaEnergeticReasoningInNoOverlap2D);
13121 if (HasProbingNumCombinationsLimit) {
13122 output.WriteRawTag(128, 17);
13123 output.WriteInt32(ProbingNumCombinationsLimit);
13125 if (HasInprocessingDtimeRatio) {
13126 output.WriteRawTag(137, 17);
13127 output.WriteDouble(InprocessingDtimeRatio);
13129 if (HasInprocessingProbingDtime) {
13130 output.WriteRawTag(145, 17);
13131 output.WriteDouble(InprocessingProbingDtime);
13133 if (HasInprocessingMinimizationDtime) {
13134 output.WriteRawTag(153, 17);
13135 output.WriteDouble(InprocessingMinimizationDtime);
13137 if (HasMaxPairsPairwiseReasoningInNoOverlap2D) {
13138 output.WriteRawTag(160, 17);
13139 output.WriteInt32(MaxPairsPairwiseReasoningInNoOverlap2D);
13141 if (HasDetectLinearizedProduct) {
13142 output.WriteRawTag(168, 17);
13143 output.WriteBool(DetectLinearizedProduct);
13145 if (HasMipTreatHighMagnitudeBoundsAsInfinity) {
13146 output.WriteRawTag(176, 17);
13147 output.WriteBool(MipTreatHighMagnitudeBoundsAsInfinity);
13149 if (HasAddRltCuts) {
13150 output.WriteRawTag(184, 17);
13151 output.WriteBool(AddRltCuts);
13153 if (HasMaxLinMaxSizeForExpansion) {
13154 output.WriteRawTag(192, 17);
13155 output.WriteInt32(MaxLinMaxSizeForExpansion);
13157 if (HasSharedTreeOpenLeavesPerWorker) {
13158 output.WriteRawTag(201, 17);
13159 output.WriteDouble(SharedTreeOpenLeavesPerWorker);
13161 if (HasSharedTreeWorkerMinRestartsPerSubtree) {
13162 output.WriteRawTag(208, 17);
13163 output.WriteInt32(SharedTreeWorkerMinRestartsPerSubtree);
13166 output.WriteRawTag(216, 17);
13167 output.WriteBool(UseLns);
13169 if (HasSaveLpBasisInLbTreeSearch) {
13170 output.WriteRawTag(224, 17);
13171 output.WriteBool(SaveLpBasisInLbTreeSearch);
13173 if (HasShareGlueClauses) {
13174 output.WriteRawTag(232, 17);
13175 output.WriteBool(ShareGlueClauses);
13177 if (HasUseConservativeScaleOverloadChecker) {
13178 output.WriteRawTag(240, 17);
13179 output.WriteBool(UseConservativeScaleOverloadChecker);
13181 if (HasEncodeCumulativeAsReservoir) {
13182 output.WriteRawTag(248, 17);
13183 output.WriteBool(EncodeCumulativeAsReservoir);
13185 if (HasExpandReservoirUsingCircuit) {
13186 output.WriteRawTag(128, 18);
13187 output.WriteBool(ExpandReservoirUsingCircuit);
13189 if (HasVariablesShavingLevel) {
13190 output.WriteRawTag(136, 18);
13191 output.WriteInt32(VariablesShavingLevel);
13193 if (HasShavingSearchThreshold) {
13194 output.WriteRawTag(144, 18);
13195 output.WriteInt64(ShavingSearchThreshold);
13197 if (HasMaxNumDeterministicBatches) {
13198 output.WriteRawTag(152, 18);
13199 output.WriteInt32(MaxNumDeterministicBatches);
13201 if (HasFeasibilityJumpBatchDtime) {
13202 output.WriteRawTag(161, 18);
13203 output.WriteDouble(FeasibilityJumpBatchDtime);
13205 filterSubsolvers_.WriteTo(ref output, _repeated_filterSubsolvers_codec);
13206 if (HasNumFullSubsolvers) {
13207 output.WriteRawTag(176, 18);
13208 output.WriteInt32(NumFullSubsolvers);
13210 if (HasSharedTreeWorkerEnableTrailSharing) {
13211 output.WriteRawTag(184, 18);
13212 output.WriteBool(SharedTreeWorkerEnableTrailSharing);
13214 if (HasLbRelaxNumWorkersThreshold) {
13215 output.WriteRawTag(192, 18);
13216 output.WriteInt32(LbRelaxNumWorkersThreshold);
13218 if (HasInprocessingMinimizationUseConflictAnalysis) {
13219 output.WriteRawTag(200, 18);
13220 output.WriteBool(InprocessingMinimizationUseConflictAnalysis);
13222 if (HasInprocessingMinimizationUseAllOrderings) {
13223 output.WriteRawTag(208, 18);
13224 output.WriteBool(InprocessingMinimizationUseAllOrderings);
13226 if (HasUseTryEdgeReasoningInNoOverlap2D) {
13227 output.WriteRawTag(216, 18);
13228 output.WriteBool(UseTryEdgeReasoningInNoOverlap2D);
13230 if (HasMinimizeSharedClauses) {
13231 output.WriteRawTag(224, 18);
13232 output.WriteBool(MinimizeSharedClauses);
13234 if (HasUseSymmetryInLp) {
13235 output.WriteRawTag(232, 18);
13236 output.WriteBool(UseSymmetryInLp);
13238 if (HasSymmetryDetectionDeterministicTimeLimit) {
13239 output.WriteRawTag(241, 18);
13240 output.WriteDouble(SymmetryDetectionDeterministicTimeLimit);
13242 if (HasKeepSymmetryInPresolve) {
13243 output.WriteRawTag(248, 18);
13244 output.WriteBool(KeepSymmetryInPresolve);
13246 if (HasSharedTreeWorkerEnablePhaseSharing) {
13247 output.WriteRawTag(128, 19);
13248 output.WriteBool(SharedTreeWorkerEnablePhaseSharing);
13250 if (HasSharedTreeBalanceTolerance) {
13251 output.WriteRawTag(136, 19);
13252 output.WriteInt32(SharedTreeBalanceTolerance);
13254 if (HasDebugCrashIfPresolveBreaksHint) {
13255 output.WriteRawTag(144, 19);
13256 output.WriteBool(DebugCrashIfPresolveBreaksHint);
13258 if (HasLnsInitialDifficulty) {
13259 output.WriteRawTag(153, 19);
13260 output.WriteDouble(LnsInitialDifficulty);
13262 if (HasLnsInitialDeterministicLimit) {
13263 output.WriteRawTag(161, 19);
13264 output.WriteDouble(LnsInitialDeterministicLimit);
13266 if (HasPolarityExploitLsHints) {
13267 output.WriteRawTag(168, 19);
13268 output.WriteBool(PolarityExploitLsHints);
13270 if (HasRemoveFixedVariablesEarly) {
13271 output.WriteRawTag(176, 19);
13272 output.WriteBool(RemoveFixedVariablesEarly);
13274 if (HasUseAllDifferentForCircuit) {
13275 output.WriteRawTag(184, 19);
13276 output.WriteBool(UseAllDifferentForCircuit);
13278 if (HasRoutingCutSubsetSizeForBinaryRelationBound) {
13279 output.WriteRawTag(192, 19);
13280 output.WriteInt32(RoutingCutSubsetSizeForBinaryRelationBound);
13282 if (HasRoutingCutSubsetSizeForTightBinaryRelationBound) {
13283 output.WriteRawTag(200, 19);
13284 output.WriteInt32(RoutingCutSubsetSizeForTightBinaryRelationBound);
13286 if (HasRoutingCutDpEffort) {
13287 output.WriteRawTag(209, 19);
13288 output.WriteDouble(RoutingCutDpEffort);
13290 if (HasMaximumRegionsToSplitInDisconnectedNoOverlap2D) {
13291 output.WriteRawTag(216, 19);
13292 output.WriteInt32(MaximumRegionsToSplitInDisconnectedNoOverlap2D);
13294 if (HasRoutingCutSubsetSizeForExactBinaryRelationBound) {
13295 output.WriteRawTag(224, 19);
13296 output.WriteInt32(RoutingCutSubsetSizeForExactBinaryRelationBound);
13298 if (HasRoutingCutMaxInfeasiblePathLength) {
13299 output.WriteRawTag(232, 19);
13300 output.WriteInt32(RoutingCutMaxInfeasiblePathLength);
13302 if (HasRoutingCutSubsetSizeForShortestPathsBound) {
13303 output.WriteRawTag(240, 19);
13304 output.WriteInt32(RoutingCutSubsetSizeForShortestPathsBound);
13306 if (HasMaxAlldiffDomainSize) {
13307 output.WriteRawTag(128, 20);
13308 output.WriteInt32(MaxAlldiffDomainSize);
13310 if (HasNoOverlap2DBooleanRelationsLimit) {
13311 output.WriteRawTag(136, 20);
13312 output.WriteInt32(NoOverlap2DBooleanRelationsLimit);
13314 if (HasShareGlueClausesDtime) {
13315 output.WriteRawTag(145, 20);
13316 output.WriteDouble(ShareGlueClausesDtime);
13318 if (HasUseLinear3ForNoOverlap2DPrecedences) {
13319 output.WriteRawTag(152, 20);
13320 output.WriteBool(UseLinear3ForNoOverlap2DPrecedences);
13322 if (HasFilterSatPostsolveClauses) {
13323 output.WriteRawTag(160, 20);
13324 output.WriteBool(FilterSatPostsolveClauses);
13326 if (HasAlternativePoolSize) {
13327 output.WriteRawTag(168, 20);
13328 output.WriteInt32(AlternativePoolSize);
13330 if (HasShareLinear2Bounds) {
13331 output.WriteRawTag(176, 20);
13332 output.WriteBool(ShareLinear2Bounds);
13334 if (HasTransitivePrecedencesWorkLimit) {
13335 output.WriteRawTag(184, 20);
13336 output.WriteInt32(TransitivePrecedencesWorkLimit);
13338 if (HasSharedTreeSplitMinDtime) {
13339 output.WriteRawTag(193, 20);
13340 output.WriteDouble(SharedTreeSplitMinDtime);
13342 if (HasSolutionPoolDiversityLimit) {
13343 output.WriteRawTag(200, 20);
13344 output.WriteInt32(SolutionPoolDiversityLimit);
13346 if (HasUseChronologicalBacktracking) {
13347 output.WriteRawTag(208, 20);
13348 output.WriteBool(UseChronologicalBacktracking);
13350 if (HasMaxBackjumpLevels) {
13351 output.WriteRawTag(216, 20);
13352 output.WriteInt32(MaxBackjumpLevels);
13354 if (HasChronologicalBacktrackMinConflicts) {
13355 output.WriteRawTag(224, 20);
13356 output.WriteInt32(ChronologicalBacktrackMinConflicts);
13358 if (HasFindClausesThatAreExactlyOne) {
13359 output.WriteRawTag(232, 20);
13360 output.WriteBool(FindClausesThatAreExactlyOne);
13362 if (HasLoadAtMostOnesInSatPresolve) {
13363 output.WriteRawTag(248, 20);
13364 output.WriteBool(LoadAtMostOnesInSatPresolve);
13366 if (HasUseNewIntegerConflictResolution) {
13367 output.WriteRawTag(128, 21);
13368 output.WriteBool(UseNewIntegerConflictResolution);
13370 if (HasClauseCleanupPeriodIncrement) {
13371 output.WriteRawTag(136, 21);
13372 output.WriteInt32(ClauseCleanupPeriodIncrement);
13374 if (HasDebugCrashIfLratCheckFails) {
13375 output.WriteRawTag(152, 21);
13376 output.WriteBool(DebugCrashIfLratCheckFails);
13378 if (HasMaxDomainSizeForLinear2Expansion) {
13379 output.WriteRawTag(160, 21);
13380 output.WriteInt32(MaxDomainSizeForLinear2Expansion);
13382 if (HasCreate1UipBooleanDuringIcr) {
13383 output.WriteRawTag(168, 21);
13384 output.WriteBool(Create1UipBooleanDuringIcr);
13386 if (HasInprocessingUseCongruenceClosure) {
13387 output.WriteRawTag(176, 21);
13388 output.WriteBool(InprocessingUseCongruenceClosure);
13390 if (HasEagerlySubsumeLastNConflicts) {
13391 output.WriteRawTag(184, 21);
13392 output.WriteInt32(EagerlySubsumeLastNConflicts);
13394 if (HasCheckLratProof) {
13395 output.WriteRawTag(192, 21);
13396 output.WriteBool(CheckLratProof);
13398 if (HasOutputLratProof) {
13399 output.WriteRawTag(200, 21);
13400 output.WriteBool(OutputLratProof);
13402 if (HasCheckDratProof) {
13403 output.WriteRawTag(208, 21);
13404 output.WriteBool(CheckDratProof);
13406 if (HasOutputDratProof) {
13407 output.WriteRawTag(216, 21);
13408 output.WriteBool(OutputDratProof);
13410 if (HasMaxDratTimeInSeconds) {
13411 output.WriteRawTag(225, 21);
13412 output.WriteDouble(MaxDratTimeInSeconds);
13414 if (HasClauseCleanupLbdTier1) {
13415 output.WriteRawTag(232, 21);
13416 output.WriteInt32(ClauseCleanupLbdTier1);
13418 if (HasClauseCleanupLbdTier2) {
13419 output.WriteRawTag(240, 21);
13420 output.WriteInt32(ClauseCleanupLbdTier2);
13422 if (HasExtraSubsumptionDuringConflictAnalysis) {
13423 output.WriteRawTag(248, 21);
13424 output.WriteBool(ExtraSubsumptionDuringConflictAnalysis);
13426 if (HasCheckMergedLratProof) {
13427 output.WriteRawTag(128, 22);
13428 output.WriteBool(CheckMergedLratProof);
13430 if (HasDecisionSubsumptionDuringConflictAnalysis) {
13431 output.WriteRawTag(136, 22);
13432 output.WriteBool(DecisionSubsumptionDuringConflictAnalysis);
13434 if (HasInprocessingUseSatSweeping) {
13435 output.WriteRawTag(144, 22);
13436 output.WriteBool(InprocessingUseSatSweeping);
13438 if (HasSubsumeDuringVivification) {
13439 output.WriteRawTag(152, 22);
13440 output.WriteBool(SubsumeDuringVivification);
13442 if (_unknownFields !=
null) {
13443 _unknownFields.WriteTo(ref output);
13448 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
13449 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
13450 public int CalculateSize() {
13453 size += 2 + pb::CodedOutputStream.ComputeStringSize(Name);
13455 if (HasPreferredVariableOrder) {
13456 size += 1 + pb::CodedOutputStream.ComputeEnumSize((
int) PreferredVariableOrder);
13458 if (HasInitialPolarity) {
13459 size += 1 + pb::CodedOutputStream.ComputeEnumSize((
int) InitialPolarity);
13461 if (HasUsePhaseSaving) {
13464 if (HasPolarityRephaseIncrement) {
13465 size += 2 + pb::CodedOutputStream.ComputeInt32Size(PolarityRephaseIncrement);
13467 if (HasPolarityExploitLsHints) {
13470 if (HasRandomPolarityRatio) {
13473 if (HasRandomBranchesRatio) {
13476 if (HasUseErwaHeuristic) {
13479 if (HasInitialVariablesActivity) {
13482 if (HasAlsoBumpVariablesInConflictReasons) {
13485 if (HasMinimizationAlgorithm) {
13486 size += 1 + pb::CodedOutputStream.ComputeEnumSize((
int) MinimizationAlgorithm);
13488 if (HasBinaryMinimizationAlgorithm) {
13489 size += 2 + pb::CodedOutputStream.ComputeEnumSize((
int) BinaryMinimizationAlgorithm);
13491 if (HasSubsumptionDuringConflictAnalysis) {
13494 if (HasExtraSubsumptionDuringConflictAnalysis) {
13497 if (HasDecisionSubsumptionDuringConflictAnalysis) {
13500 if (HasEagerlySubsumeLastNConflicts) {
13501 size += 2 + pb::CodedOutputStream.ComputeInt32Size(EagerlySubsumeLastNConflicts);
13503 if (HasSubsumeDuringVivification) {
13506 if (HasUseChronologicalBacktracking) {
13509 if (HasMaxBackjumpLevels) {
13510 size += 2 + pb::CodedOutputStream.ComputeInt32Size(MaxBackjumpLevels);
13515 if (HasClauseCleanupPeriod) {
13516 size += 1 + pb::CodedOutputStream.ComputeInt32Size(ClauseCleanupPeriod);
13518 if (HasClauseCleanupPeriodIncrement) {
13519 size += 2 + pb::CodedOutputStream.ComputeInt32Size(ClauseCleanupPeriodIncrement);
13521 if (HasClauseCleanupTarget) {
13522 size += 1 + pb::CodedOutputStream.ComputeInt32Size(ClauseCleanupTarget);
13524 if (HasClauseCleanupRatio) {
13527 if (HasClauseCleanupLbdBound) {
13528 size += 2 + pb::CodedOutputStream.ComputeInt32Size(ClauseCleanupLbdBound);
13530 if (HasClauseCleanupLbdTier1) {
13531 size += 2 + pb::CodedOutputStream.ComputeInt32Size(ClauseCleanupLbdTier1);
13533 if (HasClauseCleanupLbdTier2) {
13534 size += 2 + pb::CodedOutputStream.ComputeInt32Size(ClauseCleanupLbdTier2);
13536 if (HasClauseCleanupOrdering) {
13537 size += 2 + pb::CodedOutputStream.ComputeEnumSize((
int) ClauseCleanupOrdering);
13539 if (HasPbCleanupIncrement) {
13540 size += 2 + pb::CodedOutputStream.ComputeInt32Size(PbCleanupIncrement);
13542 if (HasPbCleanupRatio) {
13545 if (HasVariableActivityDecay) {
13548 if (HasMaxVariableActivityValue) {
13551 if (HasGlucoseMaxDecay) {
13554 if (HasGlucoseDecayIncrement) {
13557 if (HasGlucoseDecayIncrementPeriod) {
13558 size += 2 + pb::CodedOutputStream.ComputeInt32Size(GlucoseDecayIncrementPeriod);
13560 if (HasClauseActivityDecay) {
13563 if (HasMaxClauseActivityValue) {
13566 size += restartAlgorithms_.CalculateSize(_repeated_restartAlgorithms_codec);
13567 if (HasDefaultRestartAlgorithms) {
13568 size += 2 + pb::CodedOutputStream.ComputeStringSize(DefaultRestartAlgorithms);
13570 if (HasRestartPeriod) {
13571 size += 2 + pb::CodedOutputStream.ComputeInt32Size(RestartPeriod);
13573 if (HasRestartRunningWindowSize) {
13574 size += 2 + pb::CodedOutputStream.ComputeInt32Size(RestartRunningWindowSize);
13576 if (HasRestartDlAverageRatio) {
13579 if (HasRestartLbdAverageRatio) {
13582 if (HasUseBlockingRestart) {
13585 if (HasBlockingRestartWindowSize) {
13586 size += 2 + pb::CodedOutputStream.ComputeInt32Size(BlockingRestartWindowSize);
13588 if (HasBlockingRestartMultiplier) {
13591 if (HasNumConflictsBeforeStrategyChanges) {
13592 size += 2 + pb::CodedOutputStream.ComputeInt32Size(NumConflictsBeforeStrategyChanges);
13594 if (HasStrategyChangeIncreaseRatio) {
13597 if (HasMaxTimeInSeconds) {
13600 if (HasMaxDeterministicTime) {
13603 if (HasMaxNumDeterministicBatches) {
13604 size += 2 + pb::CodedOutputStream.ComputeInt32Size(MaxNumDeterministicBatches);
13606 if (HasMaxNumberOfConflicts) {
13607 size += 2 + pb::CodedOutputStream.ComputeInt64Size(MaxNumberOfConflicts);
13609 if (HasMaxMemoryInMb) {
13610 size += 2 + pb::CodedOutputStream.ComputeInt64Size(MaxMemoryInMb);
13612 if (HasAbsoluteGapLimit) {
13615 if (HasRelativeGapLimit) {
13618 if (HasRandomSeed) {
13619 size += 2 + pb::CodedOutputStream.ComputeInt32Size(RandomSeed);
13621 if (HasPermuteVariableRandomly) {
13624 if (HasPermutePresolveConstraintOrder) {
13627 if (HasUseAbslRandom) {
13630 if (HasLogSearchProgress) {
13633 if (HasLogSubsolverStatistics) {
13636 if (HasLogPrefix) {
13637 size += 2 + pb::CodedOutputStream.ComputeStringSize(LogPrefix);
13639 if (HasLogToStdout) {
13642 if (HasLogToResponse) {
13645 if (HasUsePbResolution) {
13648 if (HasMinimizeReductionDuringPbResolution) {
13651 if (HasCountAssumptionLevelsInLbd) {
13654 if (HasPresolveBveThreshold) {
13655 size += 2 + pb::CodedOutputStream.ComputeInt32Size(PresolveBveThreshold);
13657 if (HasFilterSatPostsolveClauses) {
13660 if (HasPresolveBveClauseWeight) {
13661 size += 2 + pb::CodedOutputStream.ComputeInt32Size(PresolveBveClauseWeight);
13663 if (HasProbingDeterministicTimeLimit) {
13666 if (HasPresolveProbingDeterministicTimeLimit) {
13669 if (HasPresolveBlockedClause) {
13672 if (HasPresolveUseBva) {
13675 if (HasPresolveBvaThreshold) {
13676 size += 2 + pb::CodedOutputStream.ComputeInt32Size(PresolveBvaThreshold);
13678 if (HasMaxPresolveIterations) {
13679 size += 2 + pb::CodedOutputStream.ComputeInt32Size(MaxPresolveIterations);
13681 if (HasCpModelPresolve) {
13684 if (HasCpModelProbingLevel) {
13685 size += 2 + pb::CodedOutputStream.ComputeInt32Size(CpModelProbingLevel);
13687 if (HasCpModelUseSatPresolve) {
13690 if (HasLoadAtMostOnesInSatPresolve) {
13693 if (HasRemoveFixedVariablesEarly) {
13696 if (HasDetectTableWithCost) {
13699 if (HasTableCompressionLevel) {
13700 size += 2 + pb::CodedOutputStream.ComputeInt32Size(TableCompressionLevel);
13702 if (HasExpandAlldiffConstraints) {
13705 if (HasMaxAlldiffDomainSize) {
13706 size += 2 + pb::CodedOutputStream.ComputeInt32Size(MaxAlldiffDomainSize);
13708 if (HasExpandReservoirConstraints) {
13711 if (HasMaxDomainSizeForLinear2Expansion) {
13712 size += 2 + pb::CodedOutputStream.ComputeInt32Size(MaxDomainSizeForLinear2Expansion);
13714 if (HasExpandReservoirUsingCircuit) {
13717 if (HasEncodeCumulativeAsReservoir) {
13720 if (HasMaxLinMaxSizeForExpansion) {
13721 size += 2 + pb::CodedOutputStream.ComputeInt32Size(MaxLinMaxSizeForExpansion);
13723 if (HasDisableConstraintExpansion) {
13726 if (HasEncodeComplexLinearConstraintWithInteger) {
13729 if (HasMergeNoOverlapWorkLimit) {
13732 if (HasMergeAtMostOneWorkLimit) {
13735 if (HasPresolveSubstitutionLevel) {
13736 size += 2 + pb::CodedOutputStream.ComputeInt32Size(PresolveSubstitutionLevel);
13738 if (HasPresolveExtractIntegerEnforcement) {
13741 if (HasPresolveInclusionWorkLimit) {
13742 size += 2 + pb::CodedOutputStream.ComputeInt64Size(PresolveInclusionWorkLimit);
13744 if (HasIgnoreNames) {
13747 if (HasInferAllDiffs) {
13750 if (HasFindBigLinearOverlap) {
13753 if (HasFindClausesThatAreExactlyOne) {
13756 if (HasUseSatInprocessing) {
13759 if (HasInprocessingDtimeRatio) {
13762 if (HasInprocessingProbingDtime) {
13765 if (HasInprocessingMinimizationDtime) {
13768 if (HasInprocessingMinimizationUseConflictAnalysis) {
13771 if (HasInprocessingMinimizationUseAllOrderings) {
13774 if (HasInprocessingUseCongruenceClosure) {
13777 if (HasInprocessingUseSatSweeping) {
13780 if (HasNumWorkers) {
13781 size += 2 + pb::CodedOutputStream.ComputeInt32Size(NumWorkers);
13783 if (HasNumSearchWorkers) {
13784 size += 2 + pb::CodedOutputStream.ComputeInt32Size(NumSearchWorkers);
13786 if (HasNumFullSubsolvers) {
13787 size += 2 + pb::CodedOutputStream.ComputeInt32Size(NumFullSubsolvers);
13789 size += subsolvers_.CalculateSize(_repeated_subsolvers_codec);
13790 size += extraSubsolvers_.CalculateSize(_repeated_extraSubsolvers_codec);
13791 size += ignoreSubsolvers_.CalculateSize(_repeated_ignoreSubsolvers_codec);
13792 size += filterSubsolvers_.CalculateSize(_repeated_filterSubsolvers_codec);
13793 size += subsolverParams_.CalculateSize(_repeated_subsolverParams_codec);
13794 if (HasInterleaveSearch) {
13797 if (HasInterleaveBatchSize) {
13798 size += 2 + pb::CodedOutputStream.ComputeInt32Size(InterleaveBatchSize);
13800 if (HasShareObjectiveBounds) {
13803 if (HasShareLevelZeroBounds) {
13806 if (HasShareLinear2Bounds) {
13809 if (HasShareBinaryClauses) {
13812 if (HasShareGlueClauses) {
13815 if (HasMinimizeSharedClauses) {
13818 if (HasShareGlueClausesDtime) {
13821 if (HasCheckLratProof) {
13824 if (HasCheckMergedLratProof) {
13827 if (HasOutputLratProof) {
13830 if (HasCheckDratProof) {
13833 if (HasOutputDratProof) {
13836 if (HasMaxDratTimeInSeconds) {
13839 if (HasDebugPostsolveWithFullSolver) {
13842 if (HasDebugMaxNumPresolveOperations) {
13843 size += 2 + pb::CodedOutputStream.ComputeInt32Size(DebugMaxNumPresolveOperations);
13845 if (HasDebugCrashOnBadHint) {
13848 if (HasDebugCrashIfPresolveBreaksHint) {
13851 if (HasDebugCrashIfLratCheckFails) {
13854 if (HasUseOptimizationHints) {
13857 if (HasCoreMinimizationLevel) {
13858 size += 2 + pb::CodedOutputStream.ComputeInt32Size(CoreMinimizationLevel);
13860 if (HasFindMultipleCores) {
13863 if (HasCoverOptimization) {
13866 if (HasMaxSatAssumptionOrder) {
13867 size += 2 + pb::CodedOutputStream.ComputeEnumSize((
int) MaxSatAssumptionOrder);
13869 if (HasMaxSatReverseAssumptionOrder) {
13872 if (HasMaxSatStratification) {
13873 size += 2 + pb::CodedOutputStream.ComputeEnumSize((
int) MaxSatStratification);
13875 if (HasPropagationLoopDetectionFactor) {
13878 if (HasUsePrecedencesInDisjunctiveConstraint) {
13881 if (HasTransitivePrecedencesWorkLimit) {
13882 size += 2 + pb::CodedOutputStream.ComputeInt32Size(TransitivePrecedencesWorkLimit);
13884 if (HasMaxSizeToCreatePrecedenceLiteralsInDisjunctive) {
13885 size += 2 + pb::CodedOutputStream.ComputeInt32Size(MaxSizeToCreatePrecedenceLiteralsInDisjunctive);
13887 if (HasUseStrongPropagationInDisjunctive) {
13890 if (HasUseDynamicPrecedenceInDisjunctive) {
13893 if (HasUseDynamicPrecedenceInCumulative) {
13896 if (HasUseOverloadCheckerInCumulative) {
13899 if (HasUseConservativeScaleOverloadChecker) {
13902 if (HasUseTimetableEdgeFindingInCumulative) {
13905 if (HasMaxNumIntervalsForTimetableEdgeFinding) {
13906 size += 2 + pb::CodedOutputStream.ComputeInt32Size(MaxNumIntervalsForTimetableEdgeFinding);
13908 if (HasUseHardPrecedencesInCumulative) {
13911 if (HasExploitAllPrecedences) {
13914 if (HasUseDisjunctiveConstraintInCumulative) {
13917 if (HasNoOverlap2DBooleanRelationsLimit) {
13918 size += 2 + pb::CodedOutputStream.ComputeInt32Size(NoOverlap2DBooleanRelationsLimit);
13920 if (HasUseTimetablingInNoOverlap2D) {
13923 if (HasUseEnergeticReasoningInNoOverlap2D) {
13926 if (HasUseAreaEnergeticReasoningInNoOverlap2D) {
13929 if (HasUseTryEdgeReasoningInNoOverlap2D) {
13932 if (HasMaxPairsPairwiseReasoningInNoOverlap2D) {
13933 size += 2 + pb::CodedOutputStream.ComputeInt32Size(MaxPairsPairwiseReasoningInNoOverlap2D);
13935 if (HasMaximumRegionsToSplitInDisconnectedNoOverlap2D) {
13936 size += 2 + pb::CodedOutputStream.ComputeInt32Size(MaximumRegionsToSplitInDisconnectedNoOverlap2D);
13938 if (HasUseLinear3ForNoOverlap2DPrecedences) {
13941 if (HasUseDualSchedulingHeuristics) {
13944 if (HasUseAllDifferentForCircuit) {
13947 if (HasRoutingCutSubsetSizeForBinaryRelationBound) {
13948 size += 2 + pb::CodedOutputStream.ComputeInt32Size(RoutingCutSubsetSizeForBinaryRelationBound);
13950 if (HasRoutingCutSubsetSizeForTightBinaryRelationBound) {
13951 size += 2 + pb::CodedOutputStream.ComputeInt32Size(RoutingCutSubsetSizeForTightBinaryRelationBound);
13953 if (HasRoutingCutSubsetSizeForExactBinaryRelationBound) {
13954 size += 2 + pb::CodedOutputStream.ComputeInt32Size(RoutingCutSubsetSizeForExactBinaryRelationBound);
13956 if (HasRoutingCutSubsetSizeForShortestPathsBound) {
13957 size += 2 + pb::CodedOutputStream.ComputeInt32Size(RoutingCutSubsetSizeForShortestPathsBound);
13959 if (HasRoutingCutDpEffort) {
13962 if (HasRoutingCutMaxInfeasiblePathLength) {
13963 size += 2 + pb::CodedOutputStream.ComputeInt32Size(RoutingCutMaxInfeasiblePathLength);
13965 if (HasSearchBranching) {
13966 size += 2 + pb::CodedOutputStream.ComputeEnumSize((
int) SearchBranching);
13968 if (HasHintConflictLimit) {
13969 size += 2 + pb::CodedOutputStream.ComputeInt32Size(HintConflictLimit);
13971 if (HasRepairHint) {
13974 if (HasFixVariablesToTheirHintedValue) {
13977 if (HasUseProbingSearch) {
13980 if (HasUseExtendedProbing) {
13983 if (HasProbingNumCombinationsLimit) {
13984 size += 2 + pb::CodedOutputStream.ComputeInt32Size(ProbingNumCombinationsLimit);
13986 if (HasShavingDeterministicTimeInProbingSearch) {
13989 if (HasShavingSearchDeterministicTime) {
13992 if (HasShavingSearchThreshold) {
13993 size += 2 + pb::CodedOutputStream.ComputeInt64Size(ShavingSearchThreshold);
13995 if (HasUseObjectiveLbSearch) {
13998 if (HasUseObjectiveShavingSearch) {
14001 if (HasVariablesShavingLevel) {
14002 size += 2 + pb::CodedOutputStream.ComputeInt32Size(VariablesShavingLevel);
14004 if (HasPseudoCostReliabilityThreshold) {
14005 size += 2 + pb::CodedOutputStream.ComputeInt64Size(PseudoCostReliabilityThreshold);
14007 if (HasOptimizeWithCore) {
14010 if (HasOptimizeWithLbTreeSearch) {
14013 if (HasSaveLpBasisInLbTreeSearch) {
14016 if (HasBinarySearchNumConflicts) {
14017 size += 2 + pb::CodedOutputStream.ComputeInt32Size(BinarySearchNumConflicts);
14019 if (HasOptimizeWithMaxHs) {
14022 if (HasUseFeasibilityJump) {
14025 if (HasUseLsOnly) {
14028 if (HasFeasibilityJumpDecay) {
14031 if (HasFeasibilityJumpLinearizationLevel) {
14032 size += 2 + pb::CodedOutputStream.ComputeInt32Size(FeasibilityJumpLinearizationLevel);
14034 if (HasFeasibilityJumpRestartFactor) {
14035 size += 2 + pb::CodedOutputStream.ComputeInt32Size(FeasibilityJumpRestartFactor);
14037 if (HasFeasibilityJumpBatchDtime) {
14040 if (HasFeasibilityJumpVarRandomizationProbability) {
14043 if (HasFeasibilityJumpVarPerburbationRangeRatio) {
14046 if (HasFeasibilityJumpEnableRestarts) {
14049 if (HasFeasibilityJumpMaxExpandedConstraintSize) {
14050 size += 2 + pb::CodedOutputStream.ComputeInt32Size(FeasibilityJumpMaxExpandedConstraintSize);
14052 if (HasNumViolationLs) {
14053 size += 2 + pb::CodedOutputStream.ComputeInt32Size(NumViolationLs);
14055 if (HasViolationLsPerturbationPeriod) {
14056 size += 2 + pb::CodedOutputStream.ComputeInt32Size(ViolationLsPerturbationPeriod);
14058 if (HasViolationLsCompoundMoveProbability) {
14061 if (HasSharedTreeNumWorkers) {
14062 size += 2 + pb::CodedOutputStream.ComputeInt32Size(SharedTreeNumWorkers);
14064 if (HasUseSharedTreeSearch) {
14067 if (HasSharedTreeWorkerMinRestartsPerSubtree) {
14068 size += 2 + pb::CodedOutputStream.ComputeInt32Size(SharedTreeWorkerMinRestartsPerSubtree);
14070 if (HasSharedTreeWorkerEnableTrailSharing) {
14073 if (HasSharedTreeWorkerEnablePhaseSharing) {
14076 if (HasSharedTreeOpenLeavesPerWorker) {
14079 if (HasSharedTreeMaxNodesPerWorker) {
14080 size += 2 + pb::CodedOutputStream.ComputeInt32Size(SharedTreeMaxNodesPerWorker);
14082 if (HasSharedTreeSplitStrategy) {
14083 size += 2 + pb::CodedOutputStream.ComputeEnumSize((
int) SharedTreeSplitStrategy);
14085 if (HasSharedTreeBalanceTolerance) {
14086 size += 2 + pb::CodedOutputStream.ComputeInt32Size(SharedTreeBalanceTolerance);
14088 if (HasSharedTreeSplitMinDtime) {
14091 if (HasEnumerateAllSolutions) {
14094 if (HasKeepAllFeasibleSolutionsInPresolve) {
14097 if (HasFillTightenedDomainsInResponse) {
14100 if (HasFillAdditionalSolutionsInResponse) {
14103 if (HasInstantiateAllVariables) {
14106 if (HasAutoDetectGreaterThanAtLeastOneOf) {
14109 if (HasStopAfterFirstSolution) {
14112 if (HasStopAfterPresolve) {
14115 if (HasStopAfterRootPropagation) {
14118 if (HasLnsInitialDifficulty) {
14121 if (HasLnsInitialDeterministicLimit) {
14127 if (HasUseLnsOnly) {
14130 if (HasSolutionPoolSize) {
14131 size += 2 + pb::CodedOutputStream.ComputeInt32Size(SolutionPoolSize);
14133 if (HasSolutionPoolDiversityLimit) {
14134 size += 2 + pb::CodedOutputStream.ComputeInt32Size(SolutionPoolDiversityLimit);
14136 if (HasAlternativePoolSize) {
14137 size += 2 + pb::CodedOutputStream.ComputeInt32Size(AlternativePoolSize);
14139 if (HasUseRinsLns) {
14142 if (HasUseFeasibilityPump) {
14145 if (HasUseLbRelaxLns) {
14148 if (HasLbRelaxNumWorkersThreshold) {
14149 size += 2 + pb::CodedOutputStream.ComputeInt32Size(LbRelaxNumWorkersThreshold);
14151 if (HasFpRounding) {
14152 size += 2 + pb::CodedOutputStream.ComputeEnumSize((
int) FpRounding);
14154 if (HasDiversifyLnsParams) {
14157 if (HasRandomizeSearch) {
14160 if (HasSearchRandomVariablePoolSize) {
14161 size += 2 + pb::CodedOutputStream.ComputeInt64Size(SearchRandomVariablePoolSize);
14163 if (HasPushAllTasksTowardStart) {
14166 if (HasUseOptionalVariables) {
14169 if (HasUseExactLpReason) {
14172 if (HasUseCombinedNoOverlap) {
14175 if (HasAtMostOneMaxExpansionSize) {
14176 size += 2 + pb::CodedOutputStream.ComputeInt32Size(AtMostOneMaxExpansionSize);
14178 if (HasCatchSigintSignal) {
14181 if (HasUseImpliedBounds) {
14184 if (HasPolishLpSolution) {
14187 if (HasLpPrimalTolerance) {
14190 if (HasLpDualTolerance) {
14193 if (HasConvertIntervals) {
14196 if (HasSymmetryLevel) {
14197 size += 2 + pb::CodedOutputStream.ComputeInt32Size(SymmetryLevel);
14199 if (HasUseSymmetryInLp) {
14202 if (HasKeepSymmetryInPresolve) {
14205 if (HasSymmetryDetectionDeterministicTimeLimit) {
14208 if (HasNewLinearPropagation) {
14211 if (HasLinearSplitSize) {
14212 size += 2 + pb::CodedOutputStream.ComputeInt32Size(LinearSplitSize);
14214 if (HasLinearizationLevel) {
14215 size += 2 + pb::CodedOutputStream.ComputeInt32Size(LinearizationLevel);
14217 if (HasBooleanEncodingLevel) {
14218 size += 2 + pb::CodedOutputStream.ComputeInt32Size(BooleanEncodingLevel);
14220 if (HasMaxDomainSizeWhenEncodingEqNeqConstraints) {
14221 size += 2 + pb::CodedOutputStream.ComputeInt32Size(MaxDomainSizeWhenEncodingEqNeqConstraints);
14223 if (HasMaxNumCuts) {
14224 size += 2 + pb::CodedOutputStream.ComputeInt32Size(MaxNumCuts);
14227 size += 2 + pb::CodedOutputStream.ComputeInt32Size(CutLevel);
14229 if (HasOnlyAddCutsAtLevelZero) {
14232 if (HasAddObjectiveCut) {
14235 if (HasAddCgCuts) {
14238 if (HasAddMirCuts) {
14241 if (HasAddZeroHalfCuts) {
14244 if (HasAddCliqueCuts) {
14247 if (HasAddRltCuts) {
14250 if (HasMaxAllDiffCutSize) {
14251 size += 2 + pb::CodedOutputStream.ComputeInt32Size(MaxAllDiffCutSize);
14253 if (HasAddLinMaxCuts) {
14256 if (HasMaxIntegerRoundingScaling) {
14257 size += 2 + pb::CodedOutputStream.ComputeInt32Size(MaxIntegerRoundingScaling);
14259 if (HasAddLpConstraintsLazily) {
14262 if (HasRootLpIterations) {
14263 size += 2 + pb::CodedOutputStream.ComputeInt32Size(RootLpIterations);
14265 if (HasMinOrthogonalityForLpConstraints) {
14268 if (HasMaxCutRoundsAtLevelZero) {
14269 size += 2 + pb::CodedOutputStream.ComputeInt32Size(MaxCutRoundsAtLevelZero);
14271 if (HasMaxConsecutiveInactiveCount) {
14272 size += 2 + pb::CodedOutputStream.ComputeInt32Size(MaxConsecutiveInactiveCount);
14274 if (HasCutMaxActiveCountValue) {
14277 if (HasCutActiveCountDecay) {
14280 if (HasCutCleanupTarget) {
14281 size += 2 + pb::CodedOutputStream.ComputeInt32Size(CutCleanupTarget);
14283 if (HasNewConstraintsBatchSize) {
14284 size += 2 + pb::CodedOutputStream.ComputeInt32Size(NewConstraintsBatchSize);
14286 if (HasExploitIntegerLpSolution) {
14289 if (HasExploitAllLpSolution) {
14292 if (HasExploitBestSolution) {
14295 if (HasExploitRelaxationSolution) {
14298 if (HasExploitObjective) {
14301 if (HasDetectLinearizedProduct) {
14304 if (HasUseNewIntegerConflictResolution) {
14307 if (HasCreate1UipBooleanDuringIcr) {
14310 if (HasMipMaxBound) {
14313 if (HasMipVarScaling) {
14316 if (HasMipScaleLargeDomain) {
14319 if (HasMipAutomaticallyScaleVariables) {
14322 if (HasOnlySolveIp) {
14325 if (HasMipWantedPrecision) {
14328 if (HasMipMaxActivityExponent) {
14329 size += 2 + pb::CodedOutputStream.ComputeInt32Size(MipMaxActivityExponent);
14331 if (HasMipCheckPrecision) {
14334 if (HasMipComputeTrueObjectiveBound) {
14337 if (HasMipMaxValidMagnitude) {
14340 if (HasMipTreatHighMagnitudeBoundsAsInfinity) {
14343 if (HasMipDropTolerance) {
14346 if (HasMipPresolveLevel) {
14347 size += 2 + pb::CodedOutputStream.ComputeInt32Size(MipPresolveLevel);
14349 if (_unknownFields !=
null) {
14350 size += _unknownFields.CalculateSize();
14355 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
14356 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
14357 public void MergeFrom(SatParameters other) {
14358 if (other ==
null) {
14361 if (other.HasName) {
14364 if (other.HasPreferredVariableOrder) {
14365 PreferredVariableOrder = other.PreferredVariableOrder;
14367 if (other.HasInitialPolarity) {
14368 InitialPolarity = other.InitialPolarity;
14370 if (other.HasUsePhaseSaving) {
14371 UsePhaseSaving = other.UsePhaseSaving;
14373 if (other.HasPolarityRephaseIncrement) {
14374 PolarityRephaseIncrement = other.PolarityRephaseIncrement;
14376 if (other.HasPolarityExploitLsHints) {
14377 PolarityExploitLsHints = other.PolarityExploitLsHints;
14379 if (other.HasRandomPolarityRatio) {
14380 RandomPolarityRatio = other.RandomPolarityRatio;
14382 if (other.HasRandomBranchesRatio) {
14383 RandomBranchesRatio = other.RandomBranchesRatio;
14385 if (other.HasUseErwaHeuristic) {
14386 UseErwaHeuristic = other.UseErwaHeuristic;
14388 if (other.HasInitialVariablesActivity) {
14389 InitialVariablesActivity = other.InitialVariablesActivity;
14391 if (other.HasAlsoBumpVariablesInConflictReasons) {
14392 AlsoBumpVariablesInConflictReasons = other.AlsoBumpVariablesInConflictReasons;
14394 if (other.HasMinimizationAlgorithm) {
14395 MinimizationAlgorithm = other.MinimizationAlgorithm;
14397 if (other.HasBinaryMinimizationAlgorithm) {
14398 BinaryMinimizationAlgorithm = other.BinaryMinimizationAlgorithm;
14400 if (other.HasSubsumptionDuringConflictAnalysis) {
14401 SubsumptionDuringConflictAnalysis = other.SubsumptionDuringConflictAnalysis;
14403 if (other.HasExtraSubsumptionDuringConflictAnalysis) {
14404 ExtraSubsumptionDuringConflictAnalysis = other.ExtraSubsumptionDuringConflictAnalysis;
14406 if (other.HasDecisionSubsumptionDuringConflictAnalysis) {
14407 DecisionSubsumptionDuringConflictAnalysis = other.DecisionSubsumptionDuringConflictAnalysis;
14409 if (other.HasEagerlySubsumeLastNConflicts) {
14410 EagerlySubsumeLastNConflicts = other.EagerlySubsumeLastNConflicts;
14412 if (other.HasSubsumeDuringVivification) {
14413 SubsumeDuringVivification = other.SubsumeDuringVivification;
14415 if (other.HasUseChronologicalBacktracking) {
14416 UseChronologicalBacktracking = other.UseChronologicalBacktracking;
14418 if (other.HasMaxBackjumpLevels) {
14421 if (other.HasChronologicalBacktrackMinConflicts) {
14422 ChronologicalBacktrackMinConflicts = other.ChronologicalBacktrackMinConflicts;
14424 if (other.HasClauseCleanupPeriod) {
14425 ClauseCleanupPeriod = other.ClauseCleanupPeriod;
14427 if (other.HasClauseCleanupPeriodIncrement) {
14428 ClauseCleanupPeriodIncrement = other.ClauseCleanupPeriodIncrement;
14430 if (other.HasClauseCleanupTarget) {
14431 ClauseCleanupTarget = other.ClauseCleanupTarget;
14433 if (other.HasClauseCleanupRatio) {
14434 ClauseCleanupRatio = other.ClauseCleanupRatio;
14436 if (other.HasClauseCleanupLbdBound) {
14437 ClauseCleanupLbdBound = other.ClauseCleanupLbdBound;
14439 if (other.HasClauseCleanupLbdTier1) {
14440 ClauseCleanupLbdTier1 = other.ClauseCleanupLbdTier1;
14442 if (other.HasClauseCleanupLbdTier2) {
14443 ClauseCleanupLbdTier2 = other.ClauseCleanupLbdTier2;
14445 if (other.HasClauseCleanupOrdering) {
14446 ClauseCleanupOrdering = other.ClauseCleanupOrdering;
14448 if (other.HasPbCleanupIncrement) {
14449 PbCleanupIncrement = other.PbCleanupIncrement;
14451 if (other.HasPbCleanupRatio) {
14452 PbCleanupRatio = other.PbCleanupRatio;
14454 if (other.HasVariableActivityDecay) {
14455 VariableActivityDecay = other.VariableActivityDecay;
14457 if (other.HasMaxVariableActivityValue) {
14458 MaxVariableActivityValue = other.MaxVariableActivityValue;
14460 if (other.HasGlucoseMaxDecay) {
14461 GlucoseMaxDecay = other.GlucoseMaxDecay;
14463 if (other.HasGlucoseDecayIncrement) {
14464 GlucoseDecayIncrement = other.GlucoseDecayIncrement;
14466 if (other.HasGlucoseDecayIncrementPeriod) {
14467 GlucoseDecayIncrementPeriod = other.GlucoseDecayIncrementPeriod;
14469 if (other.HasClauseActivityDecay) {
14470 ClauseActivityDecay = other.ClauseActivityDecay;
14472 if (other.HasMaxClauseActivityValue) {
14473 MaxClauseActivityValue = other.MaxClauseActivityValue;
14475 restartAlgorithms_.Add(other.restartAlgorithms_);
14476 if (other.HasDefaultRestartAlgorithms) {
14477 DefaultRestartAlgorithms = other.DefaultRestartAlgorithms;
14479 if (other.HasRestartPeriod) {
14480 RestartPeriod = other.RestartPeriod;
14482 if (other.HasRestartRunningWindowSize) {
14483 RestartRunningWindowSize = other.RestartRunningWindowSize;
14485 if (other.HasRestartDlAverageRatio) {
14486 RestartDlAverageRatio = other.RestartDlAverageRatio;
14488 if (other.HasRestartLbdAverageRatio) {
14489 RestartLbdAverageRatio = other.RestartLbdAverageRatio;
14491 if (other.HasUseBlockingRestart) {
14492 UseBlockingRestart = other.UseBlockingRestart;
14494 if (other.HasBlockingRestartWindowSize) {
14495 BlockingRestartWindowSize = other.BlockingRestartWindowSize;
14497 if (other.HasBlockingRestartMultiplier) {
14498 BlockingRestartMultiplier = other.BlockingRestartMultiplier;
14500 if (other.HasNumConflictsBeforeStrategyChanges) {
14501 NumConflictsBeforeStrategyChanges = other.NumConflictsBeforeStrategyChanges;
14503 if (other.HasStrategyChangeIncreaseRatio) {
14504 StrategyChangeIncreaseRatio = other.StrategyChangeIncreaseRatio;
14506 if (other.HasMaxTimeInSeconds) {
14507 MaxTimeInSeconds = other.MaxTimeInSeconds;
14509 if (other.HasMaxDeterministicTime) {
14510 MaxDeterministicTime = other.MaxDeterministicTime;
14512 if (other.HasMaxNumDeterministicBatches) {
14513 MaxNumDeterministicBatches = other.MaxNumDeterministicBatches;
14515 if (other.HasMaxNumberOfConflicts) {
14516 MaxNumberOfConflicts = other.MaxNumberOfConflicts;
14518 if (other.HasMaxMemoryInMb) {
14519 MaxMemoryInMb = other.MaxMemoryInMb;
14521 if (other.HasAbsoluteGapLimit) {
14522 AbsoluteGapLimit = other.AbsoluteGapLimit;
14524 if (other.HasRelativeGapLimit) {
14525 RelativeGapLimit = other.RelativeGapLimit;
14527 if (other.HasRandomSeed) {
14528 RandomSeed = other.RandomSeed;
14530 if (other.HasPermuteVariableRandomly) {
14531 PermuteVariableRandomly = other.PermuteVariableRandomly;
14533 if (other.HasPermutePresolveConstraintOrder) {
14534 PermutePresolveConstraintOrder = other.PermutePresolveConstraintOrder;
14536 if (other.HasUseAbslRandom) {
14537 UseAbslRandom = other.UseAbslRandom;
14539 if (other.HasLogSearchProgress) {
14540 LogSearchProgress = other.LogSearchProgress;
14542 if (other.HasLogSubsolverStatistics) {
14543 LogSubsolverStatistics = other.LogSubsolverStatistics;
14545 if (other.HasLogPrefix) {
14546 LogPrefix = other.LogPrefix;
14548 if (other.HasLogToStdout) {
14549 LogToStdout = other.LogToStdout;
14551 if (other.HasLogToResponse) {
14552 LogToResponse = other.LogToResponse;
14554 if (other.HasUsePbResolution) {
14555 UsePbResolution = other.UsePbResolution;
14557 if (other.HasMinimizeReductionDuringPbResolution) {
14558 MinimizeReductionDuringPbResolution = other.MinimizeReductionDuringPbResolution;
14560 if (other.HasCountAssumptionLevelsInLbd) {
14561 CountAssumptionLevelsInLbd = other.CountAssumptionLevelsInLbd;
14563 if (other.HasPresolveBveThreshold) {
14564 PresolveBveThreshold = other.PresolveBveThreshold;
14566 if (other.HasFilterSatPostsolveClauses) {
14567 FilterSatPostsolveClauses = other.FilterSatPostsolveClauses;
14569 if (other.HasPresolveBveClauseWeight) {
14570 PresolveBveClauseWeight = other.PresolveBveClauseWeight;
14572 if (other.HasProbingDeterministicTimeLimit) {
14573 ProbingDeterministicTimeLimit = other.ProbingDeterministicTimeLimit;
14575 if (other.HasPresolveProbingDeterministicTimeLimit) {
14576 PresolveProbingDeterministicTimeLimit = other.PresolveProbingDeterministicTimeLimit;
14578 if (other.HasPresolveBlockedClause) {
14579 PresolveBlockedClause = other.PresolveBlockedClause;
14581 if (other.HasPresolveUseBva) {
14582 PresolveUseBva = other.PresolveUseBva;
14584 if (other.HasPresolveBvaThreshold) {
14585 PresolveBvaThreshold = other.PresolveBvaThreshold;
14587 if (other.HasMaxPresolveIterations) {
14588 MaxPresolveIterations = other.MaxPresolveIterations;
14590 if (other.HasCpModelPresolve) {
14591 CpModelPresolve = other.CpModelPresolve;
14593 if (other.HasCpModelProbingLevel) {
14594 CpModelProbingLevel = other.CpModelProbingLevel;
14596 if (other.HasCpModelUseSatPresolve) {
14597 CpModelUseSatPresolve = other.CpModelUseSatPresolve;
14599 if (other.HasLoadAtMostOnesInSatPresolve) {
14600 LoadAtMostOnesInSatPresolve = other.LoadAtMostOnesInSatPresolve;
14602 if (other.HasRemoveFixedVariablesEarly) {
14603 RemoveFixedVariablesEarly = other.RemoveFixedVariablesEarly;
14605 if (other.HasDetectTableWithCost) {
14606 DetectTableWithCost = other.DetectTableWithCost;
14608 if (other.HasTableCompressionLevel) {
14609 TableCompressionLevel = other.TableCompressionLevel;
14611 if (other.HasExpandAlldiffConstraints) {
14612 ExpandAlldiffConstraints = other.ExpandAlldiffConstraints;
14614 if (other.HasMaxAlldiffDomainSize) {
14615 MaxAlldiffDomainSize = other.MaxAlldiffDomainSize;
14617 if (other.HasExpandReservoirConstraints) {
14618 ExpandReservoirConstraints = other.ExpandReservoirConstraints;
14620 if (other.HasMaxDomainSizeForLinear2Expansion) {
14621 MaxDomainSizeForLinear2Expansion = other.MaxDomainSizeForLinear2Expansion;
14623 if (other.HasExpandReservoirUsingCircuit) {
14624 ExpandReservoirUsingCircuit = other.ExpandReservoirUsingCircuit;
14626 if (other.HasEncodeCumulativeAsReservoir) {
14627 EncodeCumulativeAsReservoir = other.EncodeCumulativeAsReservoir;
14629 if (other.HasMaxLinMaxSizeForExpansion) {
14630 MaxLinMaxSizeForExpansion = other.MaxLinMaxSizeForExpansion;
14632 if (other.HasDisableConstraintExpansion) {
14633 DisableConstraintExpansion = other.DisableConstraintExpansion;
14635 if (other.HasEncodeComplexLinearConstraintWithInteger) {
14636 EncodeComplexLinearConstraintWithInteger = other.EncodeComplexLinearConstraintWithInteger;
14638 if (other.HasMergeNoOverlapWorkLimit) {
14639 MergeNoOverlapWorkLimit = other.MergeNoOverlapWorkLimit;
14641 if (other.HasMergeAtMostOneWorkLimit) {
14642 MergeAtMostOneWorkLimit = other.MergeAtMostOneWorkLimit;
14644 if (other.HasPresolveSubstitutionLevel) {
14645 PresolveSubstitutionLevel = other.PresolveSubstitutionLevel;
14647 if (other.HasPresolveExtractIntegerEnforcement) {
14648 PresolveExtractIntegerEnforcement = other.PresolveExtractIntegerEnforcement;
14650 if (other.HasPresolveInclusionWorkLimit) {
14651 PresolveInclusionWorkLimit = other.PresolveInclusionWorkLimit;
14653 if (other.HasIgnoreNames) {
14654 IgnoreNames = other.IgnoreNames;
14656 if (other.HasInferAllDiffs) {
14657 InferAllDiffs = other.InferAllDiffs;
14659 if (other.HasFindBigLinearOverlap) {
14660 FindBigLinearOverlap = other.FindBigLinearOverlap;
14662 if (other.HasFindClausesThatAreExactlyOne) {
14663 FindClausesThatAreExactlyOne = other.FindClausesThatAreExactlyOne;
14665 if (other.HasUseSatInprocessing) {
14666 UseSatInprocessing = other.UseSatInprocessing;
14668 if (other.HasInprocessingDtimeRatio) {
14669 InprocessingDtimeRatio = other.InprocessingDtimeRatio;
14671 if (other.HasInprocessingProbingDtime) {
14672 InprocessingProbingDtime = other.InprocessingProbingDtime;
14674 if (other.HasInprocessingMinimizationDtime) {
14675 InprocessingMinimizationDtime = other.InprocessingMinimizationDtime;
14677 if (other.HasInprocessingMinimizationUseConflictAnalysis) {
14678 InprocessingMinimizationUseConflictAnalysis = other.InprocessingMinimizationUseConflictAnalysis;
14680 if (other.HasInprocessingMinimizationUseAllOrderings) {
14681 InprocessingMinimizationUseAllOrderings = other.InprocessingMinimizationUseAllOrderings;
14683 if (other.HasInprocessingUseCongruenceClosure) {
14684 InprocessingUseCongruenceClosure = other.InprocessingUseCongruenceClosure;
14686 if (other.HasInprocessingUseSatSweeping) {
14687 InprocessingUseSatSweeping = other.InprocessingUseSatSweeping;
14689 if (other.HasNumWorkers) {
14690 NumWorkers = other.NumWorkers;
14692 if (other.HasNumSearchWorkers) {
14693 NumSearchWorkers = other.NumSearchWorkers;
14695 if (other.HasNumFullSubsolvers) {
14696 NumFullSubsolvers = other.NumFullSubsolvers;
14698 subsolvers_.Add(other.subsolvers_);
14699 extraSubsolvers_.Add(other.extraSubsolvers_);
14700 ignoreSubsolvers_.Add(other.ignoreSubsolvers_);
14701 filterSubsolvers_.Add(other.filterSubsolvers_);
14702 subsolverParams_.Add(other.subsolverParams_);
14703 if (other.HasInterleaveSearch) {
14704 InterleaveSearch = other.InterleaveSearch;
14706 if (other.HasInterleaveBatchSize) {
14707 InterleaveBatchSize = other.InterleaveBatchSize;
14709 if (other.HasShareObjectiveBounds) {
14710 ShareObjectiveBounds = other.ShareObjectiveBounds;
14712 if (other.HasShareLevelZeroBounds) {
14713 ShareLevelZeroBounds = other.ShareLevelZeroBounds;
14715 if (other.HasShareLinear2Bounds) {
14716 ShareLinear2Bounds = other.ShareLinear2Bounds;
14718 if (other.HasShareBinaryClauses) {
14719 ShareBinaryClauses = other.ShareBinaryClauses;
14721 if (other.HasShareGlueClauses) {
14722 ShareGlueClauses = other.ShareGlueClauses;
14724 if (other.HasMinimizeSharedClauses) {
14725 MinimizeSharedClauses = other.MinimizeSharedClauses;
14727 if (other.HasShareGlueClausesDtime) {
14728 ShareGlueClausesDtime = other.ShareGlueClausesDtime;
14730 if (other.HasCheckLratProof) {
14731 CheckLratProof = other.CheckLratProof;
14733 if (other.HasCheckMergedLratProof) {
14734 CheckMergedLratProof = other.CheckMergedLratProof;
14736 if (other.HasOutputLratProof) {
14737 OutputLratProof = other.OutputLratProof;
14739 if (other.HasCheckDratProof) {
14740 CheckDratProof = other.CheckDratProof;
14742 if (other.HasOutputDratProof) {
14743 OutputDratProof = other.OutputDratProof;
14745 if (other.HasMaxDratTimeInSeconds) {
14746 MaxDratTimeInSeconds = other.MaxDratTimeInSeconds;
14748 if (other.HasDebugPostsolveWithFullSolver) {
14749 DebugPostsolveWithFullSolver = other.DebugPostsolveWithFullSolver;
14751 if (other.HasDebugMaxNumPresolveOperations) {
14752 DebugMaxNumPresolveOperations = other.DebugMaxNumPresolveOperations;
14754 if (other.HasDebugCrashOnBadHint) {
14755 DebugCrashOnBadHint = other.DebugCrashOnBadHint;
14757 if (other.HasDebugCrashIfPresolveBreaksHint) {
14758 DebugCrashIfPresolveBreaksHint = other.DebugCrashIfPresolveBreaksHint;
14760 if (other.HasDebugCrashIfLratCheckFails) {
14761 DebugCrashIfLratCheckFails = other.DebugCrashIfLratCheckFails;
14763 if (other.HasUseOptimizationHints) {
14764 UseOptimizationHints = other.UseOptimizationHints;
14766 if (other.HasCoreMinimizationLevel) {
14767 CoreMinimizationLevel = other.CoreMinimizationLevel;
14769 if (other.HasFindMultipleCores) {
14770 FindMultipleCores = other.FindMultipleCores;
14772 if (other.HasCoverOptimization) {
14773 CoverOptimization = other.CoverOptimization;
14775 if (other.HasMaxSatAssumptionOrder) {
14776 MaxSatAssumptionOrder = other.MaxSatAssumptionOrder;
14778 if (other.HasMaxSatReverseAssumptionOrder) {
14779 MaxSatReverseAssumptionOrder = other.MaxSatReverseAssumptionOrder;
14781 if (other.HasMaxSatStratification) {
14782 MaxSatStratification = other.MaxSatStratification;
14784 if (other.HasPropagationLoopDetectionFactor) {
14785 PropagationLoopDetectionFactor = other.PropagationLoopDetectionFactor;
14787 if (other.HasUsePrecedencesInDisjunctiveConstraint) {
14788 UsePrecedencesInDisjunctiveConstraint = other.UsePrecedencesInDisjunctiveConstraint;
14790 if (other.HasTransitivePrecedencesWorkLimit) {
14791 TransitivePrecedencesWorkLimit = other.TransitivePrecedencesWorkLimit;
14793 if (other.HasMaxSizeToCreatePrecedenceLiteralsInDisjunctive) {
14794 MaxSizeToCreatePrecedenceLiteralsInDisjunctive = other.MaxSizeToCreatePrecedenceLiteralsInDisjunctive;
14796 if (other.HasUseStrongPropagationInDisjunctive) {
14797 UseStrongPropagationInDisjunctive = other.UseStrongPropagationInDisjunctive;
14799 if (other.HasUseDynamicPrecedenceInDisjunctive) {
14800 UseDynamicPrecedenceInDisjunctive = other.UseDynamicPrecedenceInDisjunctive;
14802 if (other.HasUseDynamicPrecedenceInCumulative) {
14803 UseDynamicPrecedenceInCumulative = other.UseDynamicPrecedenceInCumulative;
14805 if (other.HasUseOverloadCheckerInCumulative) {
14806 UseOverloadCheckerInCumulative = other.UseOverloadCheckerInCumulative;
14808 if (other.HasUseConservativeScaleOverloadChecker) {
14809 UseConservativeScaleOverloadChecker = other.UseConservativeScaleOverloadChecker;
14811 if (other.HasUseTimetableEdgeFindingInCumulative) {
14812 UseTimetableEdgeFindingInCumulative = other.UseTimetableEdgeFindingInCumulative;
14814 if (other.HasMaxNumIntervalsForTimetableEdgeFinding) {
14815 MaxNumIntervalsForTimetableEdgeFinding = other.MaxNumIntervalsForTimetableEdgeFinding;
14817 if (other.HasUseHardPrecedencesInCumulative) {
14818 UseHardPrecedencesInCumulative = other.UseHardPrecedencesInCumulative;
14820 if (other.HasExploitAllPrecedences) {
14821 ExploitAllPrecedences = other.ExploitAllPrecedences;
14823 if (other.HasUseDisjunctiveConstraintInCumulative) {
14824 UseDisjunctiveConstraintInCumulative = other.UseDisjunctiveConstraintInCumulative;
14826 if (other.HasNoOverlap2DBooleanRelationsLimit) {
14827 NoOverlap2DBooleanRelationsLimit = other.NoOverlap2DBooleanRelationsLimit;
14829 if (other.HasUseTimetablingInNoOverlap2D) {
14830 UseTimetablingInNoOverlap2D = other.UseTimetablingInNoOverlap2D;
14832 if (other.HasUseEnergeticReasoningInNoOverlap2D) {
14833 UseEnergeticReasoningInNoOverlap2D = other.UseEnergeticReasoningInNoOverlap2D;
14835 if (other.HasUseAreaEnergeticReasoningInNoOverlap2D) {
14836 UseAreaEnergeticReasoningInNoOverlap2D = other.UseAreaEnergeticReasoningInNoOverlap2D;
14838 if (other.HasUseTryEdgeReasoningInNoOverlap2D) {
14839 UseTryEdgeReasoningInNoOverlap2D = other.UseTryEdgeReasoningInNoOverlap2D;
14841 if (other.HasMaxPairsPairwiseReasoningInNoOverlap2D) {
14842 MaxPairsPairwiseReasoningInNoOverlap2D = other.MaxPairsPairwiseReasoningInNoOverlap2D;
14844 if (other.HasMaximumRegionsToSplitInDisconnectedNoOverlap2D) {
14845 MaximumRegionsToSplitInDisconnectedNoOverlap2D = other.MaximumRegionsToSplitInDisconnectedNoOverlap2D;
14847 if (other.HasUseLinear3ForNoOverlap2DPrecedences) {
14848 UseLinear3ForNoOverlap2DPrecedences = other.UseLinear3ForNoOverlap2DPrecedences;
14850 if (other.HasUseDualSchedulingHeuristics) {
14851 UseDualSchedulingHeuristics = other.UseDualSchedulingHeuristics;
14853 if (other.HasUseAllDifferentForCircuit) {
14854 UseAllDifferentForCircuit = other.UseAllDifferentForCircuit;
14856 if (other.HasRoutingCutSubsetSizeForBinaryRelationBound) {
14857 RoutingCutSubsetSizeForBinaryRelationBound = other.RoutingCutSubsetSizeForBinaryRelationBound;
14859 if (other.HasRoutingCutSubsetSizeForTightBinaryRelationBound) {
14860 RoutingCutSubsetSizeForTightBinaryRelationBound = other.RoutingCutSubsetSizeForTightBinaryRelationBound;
14862 if (other.HasRoutingCutSubsetSizeForExactBinaryRelationBound) {
14863 RoutingCutSubsetSizeForExactBinaryRelationBound = other.RoutingCutSubsetSizeForExactBinaryRelationBound;
14865 if (other.HasRoutingCutSubsetSizeForShortestPathsBound) {
14866 RoutingCutSubsetSizeForShortestPathsBound = other.RoutingCutSubsetSizeForShortestPathsBound;
14868 if (other.HasRoutingCutDpEffort) {
14869 RoutingCutDpEffort = other.RoutingCutDpEffort;
14871 if (other.HasRoutingCutMaxInfeasiblePathLength) {
14872 RoutingCutMaxInfeasiblePathLength = other.RoutingCutMaxInfeasiblePathLength;
14874 if (other.HasSearchBranching) {
14875 SearchBranching = other.SearchBranching;
14877 if (other.HasHintConflictLimit) {
14878 HintConflictLimit = other.HintConflictLimit;
14880 if (other.HasRepairHint) {
14881 RepairHint = other.RepairHint;
14883 if (other.HasFixVariablesToTheirHintedValue) {
14884 FixVariablesToTheirHintedValue = other.FixVariablesToTheirHintedValue;
14886 if (other.HasUseProbingSearch) {
14887 UseProbingSearch = other.UseProbingSearch;
14889 if (other.HasUseExtendedProbing) {
14890 UseExtendedProbing = other.UseExtendedProbing;
14892 if (other.HasProbingNumCombinationsLimit) {
14893 ProbingNumCombinationsLimit = other.ProbingNumCombinationsLimit;
14895 if (other.HasShavingDeterministicTimeInProbingSearch) {
14896 ShavingDeterministicTimeInProbingSearch = other.ShavingDeterministicTimeInProbingSearch;
14898 if (other.HasShavingSearchDeterministicTime) {
14899 ShavingSearchDeterministicTime = other.ShavingSearchDeterministicTime;
14901 if (other.HasShavingSearchThreshold) {
14902 ShavingSearchThreshold = other.ShavingSearchThreshold;
14904 if (other.HasUseObjectiveLbSearch) {
14905 UseObjectiveLbSearch = other.UseObjectiveLbSearch;
14907 if (other.HasUseObjectiveShavingSearch) {
14908 UseObjectiveShavingSearch = other.UseObjectiveShavingSearch;
14910 if (other.HasVariablesShavingLevel) {
14911 VariablesShavingLevel = other.VariablesShavingLevel;
14913 if (other.HasPseudoCostReliabilityThreshold) {
14914 PseudoCostReliabilityThreshold = other.PseudoCostReliabilityThreshold;
14916 if (other.HasOptimizeWithCore) {
14917 OptimizeWithCore = other.OptimizeWithCore;
14919 if (other.HasOptimizeWithLbTreeSearch) {
14920 OptimizeWithLbTreeSearch = other.OptimizeWithLbTreeSearch;
14922 if (other.HasSaveLpBasisInLbTreeSearch) {
14923 SaveLpBasisInLbTreeSearch = other.SaveLpBasisInLbTreeSearch;
14925 if (other.HasBinarySearchNumConflicts) {
14926 BinarySearchNumConflicts = other.BinarySearchNumConflicts;
14928 if (other.HasOptimizeWithMaxHs) {
14929 OptimizeWithMaxHs = other.OptimizeWithMaxHs;
14931 if (other.HasUseFeasibilityJump) {
14932 UseFeasibilityJump = other.UseFeasibilityJump;
14934 if (other.HasUseLsOnly) {
14935 UseLsOnly = other.UseLsOnly;
14937 if (other.HasFeasibilityJumpDecay) {
14938 FeasibilityJumpDecay = other.FeasibilityJumpDecay;
14940 if (other.HasFeasibilityJumpLinearizationLevel) {
14941 FeasibilityJumpLinearizationLevel = other.FeasibilityJumpLinearizationLevel;
14943 if (other.HasFeasibilityJumpRestartFactor) {
14944 FeasibilityJumpRestartFactor = other.FeasibilityJumpRestartFactor;
14946 if (other.HasFeasibilityJumpBatchDtime) {
14947 FeasibilityJumpBatchDtime = other.FeasibilityJumpBatchDtime;
14949 if (other.HasFeasibilityJumpVarRandomizationProbability) {
14950 FeasibilityJumpVarRandomizationProbability = other.FeasibilityJumpVarRandomizationProbability;
14952 if (other.HasFeasibilityJumpVarPerburbationRangeRatio) {
14953 FeasibilityJumpVarPerburbationRangeRatio = other.FeasibilityJumpVarPerburbationRangeRatio;
14955 if (other.HasFeasibilityJumpEnableRestarts) {
14956 FeasibilityJumpEnableRestarts = other.FeasibilityJumpEnableRestarts;
14958 if (other.HasFeasibilityJumpMaxExpandedConstraintSize) {
14959 FeasibilityJumpMaxExpandedConstraintSize = other.FeasibilityJumpMaxExpandedConstraintSize;
14961 if (other.HasNumViolationLs) {
14962 NumViolationLs = other.NumViolationLs;
14964 if (other.HasViolationLsPerturbationPeriod) {
14965 ViolationLsPerturbationPeriod = other.ViolationLsPerturbationPeriod;
14967 if (other.HasViolationLsCompoundMoveProbability) {
14968 ViolationLsCompoundMoveProbability = other.ViolationLsCompoundMoveProbability;
14970 if (other.HasSharedTreeNumWorkers) {
14971 SharedTreeNumWorkers = other.SharedTreeNumWorkers;
14973 if (other.HasUseSharedTreeSearch) {
14974 UseSharedTreeSearch = other.UseSharedTreeSearch;
14976 if (other.HasSharedTreeWorkerMinRestartsPerSubtree) {
14977 SharedTreeWorkerMinRestartsPerSubtree = other.SharedTreeWorkerMinRestartsPerSubtree;
14979 if (other.HasSharedTreeWorkerEnableTrailSharing) {
14980 SharedTreeWorkerEnableTrailSharing = other.SharedTreeWorkerEnableTrailSharing;
14982 if (other.HasSharedTreeWorkerEnablePhaseSharing) {
14983 SharedTreeWorkerEnablePhaseSharing = other.SharedTreeWorkerEnablePhaseSharing;
14985 if (other.HasSharedTreeOpenLeavesPerWorker) {
14986 SharedTreeOpenLeavesPerWorker = other.SharedTreeOpenLeavesPerWorker;
14988 if (other.HasSharedTreeMaxNodesPerWorker) {
14989 SharedTreeMaxNodesPerWorker = other.SharedTreeMaxNodesPerWorker;
14991 if (other.HasSharedTreeSplitStrategy) {
14992 SharedTreeSplitStrategy = other.SharedTreeSplitStrategy;
14994 if (other.HasSharedTreeBalanceTolerance) {
14995 SharedTreeBalanceTolerance = other.SharedTreeBalanceTolerance;
14997 if (other.HasSharedTreeSplitMinDtime) {
14998 SharedTreeSplitMinDtime = other.SharedTreeSplitMinDtime;
15000 if (other.HasEnumerateAllSolutions) {
15001 EnumerateAllSolutions = other.EnumerateAllSolutions;
15003 if (other.HasKeepAllFeasibleSolutionsInPresolve) {
15004 KeepAllFeasibleSolutionsInPresolve = other.KeepAllFeasibleSolutionsInPresolve;
15006 if (other.HasFillTightenedDomainsInResponse) {
15007 FillTightenedDomainsInResponse = other.FillTightenedDomainsInResponse;
15009 if (other.HasFillAdditionalSolutionsInResponse) {
15010 FillAdditionalSolutionsInResponse = other.FillAdditionalSolutionsInResponse;
15012 if (other.HasInstantiateAllVariables) {
15013 InstantiateAllVariables = other.InstantiateAllVariables;
15015 if (other.HasAutoDetectGreaterThanAtLeastOneOf) {
15016 AutoDetectGreaterThanAtLeastOneOf = other.AutoDetectGreaterThanAtLeastOneOf;
15018 if (other.HasStopAfterFirstSolution) {
15019 StopAfterFirstSolution = other.StopAfterFirstSolution;
15021 if (other.HasStopAfterPresolve) {
15022 StopAfterPresolve = other.StopAfterPresolve;
15024 if (other.HasStopAfterRootPropagation) {
15025 StopAfterRootPropagation = other.StopAfterRootPropagation;
15027 if (other.HasLnsInitialDifficulty) {
15028 LnsInitialDifficulty = other.LnsInitialDifficulty;
15030 if (other.HasLnsInitialDeterministicLimit) {
15031 LnsInitialDeterministicLimit = other.LnsInitialDeterministicLimit;
15033 if (other.HasUseLns) {
15034 UseLns = other.UseLns;
15036 if (other.HasUseLnsOnly) {
15037 UseLnsOnly = other.UseLnsOnly;
15039 if (other.HasSolutionPoolSize) {
15040 SolutionPoolSize = other.SolutionPoolSize;
15042 if (other.HasSolutionPoolDiversityLimit) {
15043 SolutionPoolDiversityLimit = other.SolutionPoolDiversityLimit;
15045 if (other.HasAlternativePoolSize) {
15046 AlternativePoolSize = other.AlternativePoolSize;
15048 if (other.HasUseRinsLns) {
15049 UseRinsLns = other.UseRinsLns;
15051 if (other.HasUseFeasibilityPump) {
15052 UseFeasibilityPump = other.UseFeasibilityPump;
15054 if (other.HasUseLbRelaxLns) {
15055 UseLbRelaxLns = other.UseLbRelaxLns;
15057 if (other.HasLbRelaxNumWorkersThreshold) {
15058 LbRelaxNumWorkersThreshold = other.LbRelaxNumWorkersThreshold;
15060 if (other.HasFpRounding) {
15061 FpRounding = other.FpRounding;
15063 if (other.HasDiversifyLnsParams) {
15064 DiversifyLnsParams = other.DiversifyLnsParams;
15066 if (other.HasRandomizeSearch) {
15067 RandomizeSearch = other.RandomizeSearch;
15069 if (other.HasSearchRandomVariablePoolSize) {
15070 SearchRandomVariablePoolSize = other.SearchRandomVariablePoolSize;
15072 if (other.HasPushAllTasksTowardStart) {
15073 PushAllTasksTowardStart = other.PushAllTasksTowardStart;
15075 if (other.HasUseOptionalVariables) {
15076 UseOptionalVariables = other.UseOptionalVariables;
15078 if (other.HasUseExactLpReason) {
15079 UseExactLpReason = other.UseExactLpReason;
15081 if (other.HasUseCombinedNoOverlap) {
15082 UseCombinedNoOverlap = other.UseCombinedNoOverlap;
15084 if (other.HasAtMostOneMaxExpansionSize) {
15085 AtMostOneMaxExpansionSize = other.AtMostOneMaxExpansionSize;
15087 if (other.HasCatchSigintSignal) {
15088 CatchSigintSignal = other.CatchSigintSignal;
15090 if (other.HasUseImpliedBounds) {
15091 UseImpliedBounds = other.UseImpliedBounds;
15093 if (other.HasPolishLpSolution) {
15094 PolishLpSolution = other.PolishLpSolution;
15096 if (other.HasLpPrimalTolerance) {
15097 LpPrimalTolerance = other.LpPrimalTolerance;
15099 if (other.HasLpDualTolerance) {
15100 LpDualTolerance = other.LpDualTolerance;
15102 if (other.HasConvertIntervals) {
15103 ConvertIntervals = other.ConvertIntervals;
15105 if (other.HasSymmetryLevel) {
15106 SymmetryLevel = other.SymmetryLevel;
15108 if (other.HasUseSymmetryInLp) {
15109 UseSymmetryInLp = other.UseSymmetryInLp;
15111 if (other.HasKeepSymmetryInPresolve) {
15112 KeepSymmetryInPresolve = other.KeepSymmetryInPresolve;
15114 if (other.HasSymmetryDetectionDeterministicTimeLimit) {
15115 SymmetryDetectionDeterministicTimeLimit = other.SymmetryDetectionDeterministicTimeLimit;
15117 if (other.HasNewLinearPropagation) {
15118 NewLinearPropagation = other.NewLinearPropagation;
15120 if (other.HasLinearSplitSize) {
15121 LinearSplitSize = other.LinearSplitSize;
15123 if (other.HasLinearizationLevel) {
15124 LinearizationLevel = other.LinearizationLevel;
15126 if (other.HasBooleanEncodingLevel) {
15127 BooleanEncodingLevel = other.BooleanEncodingLevel;
15129 if (other.HasMaxDomainSizeWhenEncodingEqNeqConstraints) {
15130 MaxDomainSizeWhenEncodingEqNeqConstraints = other.MaxDomainSizeWhenEncodingEqNeqConstraints;
15132 if (other.HasMaxNumCuts) {
15133 MaxNumCuts = other.MaxNumCuts;
15135 if (other.HasCutLevel) {
15136 CutLevel = other.CutLevel;
15138 if (other.HasOnlyAddCutsAtLevelZero) {
15139 OnlyAddCutsAtLevelZero = other.OnlyAddCutsAtLevelZero;
15141 if (other.HasAddObjectiveCut) {
15142 AddObjectiveCut = other.AddObjectiveCut;
15144 if (other.HasAddCgCuts) {
15145 AddCgCuts = other.AddCgCuts;
15147 if (other.HasAddMirCuts) {
15148 AddMirCuts = other.AddMirCuts;
15150 if (other.HasAddZeroHalfCuts) {
15151 AddZeroHalfCuts = other.AddZeroHalfCuts;
15153 if (other.HasAddCliqueCuts) {
15154 AddCliqueCuts = other.AddCliqueCuts;
15156 if (other.HasAddRltCuts) {
15157 AddRltCuts = other.AddRltCuts;
15159 if (other.HasMaxAllDiffCutSize) {
15160 MaxAllDiffCutSize = other.MaxAllDiffCutSize;
15162 if (other.HasAddLinMaxCuts) {
15163 AddLinMaxCuts = other.AddLinMaxCuts;
15165 if (other.HasMaxIntegerRoundingScaling) {
15166 MaxIntegerRoundingScaling = other.MaxIntegerRoundingScaling;
15168 if (other.HasAddLpConstraintsLazily) {
15169 AddLpConstraintsLazily = other.AddLpConstraintsLazily;
15171 if (other.HasRootLpIterations) {
15172 RootLpIterations = other.RootLpIterations;
15174 if (other.HasMinOrthogonalityForLpConstraints) {
15175 MinOrthogonalityForLpConstraints = other.MinOrthogonalityForLpConstraints;
15177 if (other.HasMaxCutRoundsAtLevelZero) {
15178 MaxCutRoundsAtLevelZero = other.MaxCutRoundsAtLevelZero;
15180 if (other.HasMaxConsecutiveInactiveCount) {
15181 MaxConsecutiveInactiveCount = other.MaxConsecutiveInactiveCount;
15183 if (other.HasCutMaxActiveCountValue) {
15184 CutMaxActiveCountValue = other.CutMaxActiveCountValue;
15186 if (other.HasCutActiveCountDecay) {
15187 CutActiveCountDecay = other.CutActiveCountDecay;
15189 if (other.HasCutCleanupTarget) {
15190 CutCleanupTarget = other.CutCleanupTarget;
15192 if (other.HasNewConstraintsBatchSize) {
15193 NewConstraintsBatchSize = other.NewConstraintsBatchSize;
15195 if (other.HasExploitIntegerLpSolution) {
15196 ExploitIntegerLpSolution = other.ExploitIntegerLpSolution;
15198 if (other.HasExploitAllLpSolution) {
15199 ExploitAllLpSolution = other.ExploitAllLpSolution;
15201 if (other.HasExploitBestSolution) {
15202 ExploitBestSolution = other.ExploitBestSolution;
15204 if (other.HasExploitRelaxationSolution) {
15205 ExploitRelaxationSolution = other.ExploitRelaxationSolution;
15207 if (other.HasExploitObjective) {
15208 ExploitObjective = other.ExploitObjective;
15210 if (other.HasDetectLinearizedProduct) {
15211 DetectLinearizedProduct = other.DetectLinearizedProduct;
15213 if (other.HasUseNewIntegerConflictResolution) {
15214 UseNewIntegerConflictResolution = other.UseNewIntegerConflictResolution;
15216 if (other.HasCreate1UipBooleanDuringIcr) {
15217 Create1UipBooleanDuringIcr = other.Create1UipBooleanDuringIcr;
15219 if (other.HasMipMaxBound) {
15220 MipMaxBound = other.MipMaxBound;
15222 if (other.HasMipVarScaling) {
15223 MipVarScaling = other.MipVarScaling;
15225 if (other.HasMipScaleLargeDomain) {
15226 MipScaleLargeDomain = other.MipScaleLargeDomain;
15228 if (other.HasMipAutomaticallyScaleVariables) {
15229 MipAutomaticallyScaleVariables = other.MipAutomaticallyScaleVariables;
15231 if (other.HasOnlySolveIp) {
15232 OnlySolveIp = other.OnlySolveIp;
15234 if (other.HasMipWantedPrecision) {
15235 MipWantedPrecision = other.MipWantedPrecision;
15237 if (other.HasMipMaxActivityExponent) {
15238 MipMaxActivityExponent = other.MipMaxActivityExponent;
15240 if (other.HasMipCheckPrecision) {
15241 MipCheckPrecision = other.MipCheckPrecision;
15243 if (other.HasMipComputeTrueObjectiveBound) {
15244 MipComputeTrueObjectiveBound = other.MipComputeTrueObjectiveBound;
15246 if (other.HasMipMaxValidMagnitude) {
15247 MipMaxValidMagnitude = other.MipMaxValidMagnitude;
15249 if (other.HasMipTreatHighMagnitudeBoundsAsInfinity) {
15250 MipTreatHighMagnitudeBoundsAsInfinity = other.MipTreatHighMagnitudeBoundsAsInfinity;
15252 if (other.HasMipDropTolerance) {
15253 MipDropTolerance = other.MipDropTolerance;
15255 if (other.HasMipPresolveLevel) {
15256 MipPresolveLevel = other.MipPresolveLevel;
15258 _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
15261 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
15262 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
15263 public void MergeFrom(pb::CodedInputStream input) {
15264 #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
15265 input.ReadRawMessage(
this);
15268 while ((tag = input.ReadTag()) != 0) {
15269 if ((tag & 7) == 4) {
15275 _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
15278 PreferredVariableOrder = (global::Google.OrTools.Sat.SatParameters.Types.VariableOrder) input.ReadEnum();
15282 InitialPolarity = (global::Google.OrTools.Sat.SatParameters.Types.Polarity) input.ReadEnum();
15286 MinimizationAlgorithm = (global::Google.OrTools.Sat.SatParameters.Types.ConflictMinimizationAlgorithm) input.ReadEnum();
15290 ClauseCleanupPeriod = input.ReadInt32();
15294 ClauseCleanupTarget = input.ReadInt32();
15298 VariableActivityDecay = input.ReadDouble();
15302 MaxVariableActivityValue = input.ReadDouble();
15306 ClauseActivityDecay = input.ReadDouble();
15310 MaxClauseActivityValue = input.ReadDouble();
15314 GlucoseMaxDecay = input.ReadDouble();
15318 GlucoseDecayIncrement = input.ReadDouble();
15322 GlucoseDecayIncrementPeriod = input.ReadInt32();
15330 RandomSeed = input.ReadInt32();
15334 RandomBranchesRatio = input.ReadDouble();
15338 BinaryMinimizationAlgorithm = (global::Google.OrTools.Sat.SatParameters.Types.BinaryMinizationAlgorithm) input.ReadEnum();
15342 UseOptimizationHints = input.ReadBool();
15346 MaxTimeInSeconds = input.ReadDouble();
15350 MaxNumberOfConflicts = input.ReadInt64();
15354 MaxMemoryInMb = input.ReadInt64();
15358 LogSearchProgress = input.ReadBool();
15362 UsePbResolution = input.ReadBool();
15366 UsePhaseSaving = input.ReadBool();
15370 RandomPolarityRatio = input.ReadDouble();
15374 PbCleanupIncrement = input.ReadInt32();
15378 PbCleanupRatio = input.ReadDouble();
15382 MinimizeReductionDuringPbResolution = input.ReadBool();
15386 CountAssumptionLevelsInLbd = input.ReadBool();
15390 CoreMinimizationLevel = input.ReadInt32();
15394 MaxSatAssumptionOrder = (global::Google.OrTools.Sat.SatParameters.Types.MaxSatAssumptionOrder) input.ReadEnum();
15398 MaxSatReverseAssumptionOrder = input.ReadBool();
15402 MaxSatStratification = (global::Google.OrTools.Sat.SatParameters.Types.MaxSatStratificationAlgorithm) input.ReadEnum();
15406 PresolveBveThreshold = input.ReadInt32();
15410 PresolveBveClauseWeight = input.ReadInt32();
15414 SubsumptionDuringConflictAnalysis = input.ReadBool();
15418 PresolveProbingDeterministicTimeLimit = input.ReadDouble();
15422 ClauseCleanupLbdBound = input.ReadInt32();
15426 ClauseCleanupOrdering = (global::Google.OrTools.Sat.SatParameters.Types.ClauseOrdering) input.ReadEnum();
15431 restartAlgorithms_.AddEntriesFrom(input, _repeated_restartAlgorithms_codec);
15435 RestartRunningWindowSize = input.ReadInt32();
15439 RestartDlAverageRatio = input.ReadDouble();
15443 UseBlockingRestart = input.ReadBool();
15447 BlockingRestartWindowSize = input.ReadInt32();
15451 BlockingRestartMultiplier = input.ReadDouble();
15455 MaxDeterministicTime = input.ReadDouble();
15459 NumConflictsBeforeStrategyChanges = input.ReadInt32();
15463 StrategyChangeIncreaseRatio = input.ReadDouble();
15467 DefaultRestartAlgorithms = input.ReadString();
15471 RestartLbdAverageRatio = input.ReadDouble();
15475 PresolveUseBva = input.ReadBool();
15479 PresolveBvaThreshold = input.ReadInt32();
15483 UsePrecedencesInDisjunctiveConstraint = input.ReadBool();
15487 UseErwaHeuristic = input.ReadBool();
15491 InitialVariablesActivity = input.ReadDouble();
15495 AlsoBumpVariablesInConflictReasons = input.ReadBool();
15499 UseOverloadCheckerInCumulative = input.ReadBool();
15503 UseTimetableEdgeFindingInCumulative = input.ReadBool();
15507 UseDisjunctiveConstraintInCumulative = input.ReadBool();
15511 SearchBranching = (global::Google.OrTools.Sat.SatParameters.Types.SearchBranching) input.ReadEnum();
15515 OptimizeWithCore = input.ReadBool();
15519 FindMultipleCores = input.ReadBool();
15523 OptimizeWithMaxHs = input.ReadBool();
15527 CpModelPresolve = input.ReadBool();
15531 EnumerateAllSolutions = input.ReadBool();
15535 PresolveBlockedClause = input.ReadBool();
15539 CoverOptimization = input.ReadBool();
15543 LinearizationLevel = input.ReadInt32();
15547 MaxNumCuts = input.ReadInt32();
15551 OnlyAddCutsAtLevelZero = input.ReadBool();
15555 CpModelUseSatPresolve = input.ReadBool();
15559 ExploitIntegerLpSolution = input.ReadBool();
15563 AutoDetectGreaterThanAtLeastOneOf = input.ReadBool();
15567 StopAfterFirstSolution = input.ReadBool();
15571 BinarySearchNumConflicts = input.ReadInt32();
15575 NumSearchWorkers = input.ReadInt32();
15579 UseLnsOnly = input.ReadBool();
15583 RandomizeSearch = input.ReadBool();
15587 SearchRandomVariablePoolSize = input.ReadInt64();
15591 InstantiateAllVariables = input.ReadBool();
15595 BooleanEncodingLevel = input.ReadInt32();
15599 UseOptionalVariables = input.ReadBool();
15603 UseExactLpReason = input.ReadBool();
15607 CpModelProbingLevel = input.ReadInt32();
15611 AddLpConstraintsLazily = input.ReadBool();
15615 ShareObjectiveBounds = input.ReadBool();
15619 ShareLevelZeroBounds = input.ReadBool();
15623 MinOrthogonalityForLpConstraints = input.ReadDouble();
15627 ExploitAllLpSolution = input.ReadBool();
15631 AddCgCuts = input.ReadBool();
15635 MaxIntegerRoundingScaling = input.ReadInt32();
15639 AddMirCuts = input.ReadBool();
15643 MaxConsecutiveInactiveCount = input.ReadInt32();
15647 NewConstraintsBatchSize = input.ReadInt32();
15651 PseudoCostReliabilityThreshold = input.ReadInt64();
15655 MipMaxBound = input.ReadDouble();
15659 MipVarScaling = input.ReadDouble();
15663 MipWantedPrecision = input.ReadDouble();
15667 MipMaxActivityExponent = input.ReadInt32();
15671 MipCheckPrecision = input.ReadDouble();
15675 UseRinsLns = input.ReadBool();
15679 ExploitBestSolution = input.ReadBool();
15683 ExploitObjective = input.ReadBool();
15687 FillTightenedDomainsInResponse = input.ReadBool();
15691 UseCombinedNoOverlap = input.ReadBool();
15695 InterleaveBatchSize = input.ReadInt32();
15699 CatchSigintSignal = input.ReadBool();
15703 InterleaveSearch = input.ReadBool();
15707 DiversifyLnsParams = input.ReadBool();
15711 MaxPresolveIterations = input.ReadInt32();
15715 UseImpliedBounds = input.ReadBool();
15719 MergeNoOverlapWorkLimit = input.ReadDouble();
15723 MergeAtMostOneWorkLimit = input.ReadDouble();
15727 PresolveSubstitutionLevel = input.ReadInt32();
15731 MaxAllDiffCutSize = input.ReadInt32();
15735 StopAfterPresolve = input.ReadBool();
15739 DebugMaxNumPresolveOperations = input.ReadInt32();
15743 AddLinMaxCuts = input.ReadBool();
15747 HintConflictLimit = input.ReadInt32();
15751 MaxCutRoundsAtLevelZero = input.ReadInt32();
15755 CutMaxActiveCountValue = input.ReadDouble();
15759 CutActiveCountDecay = input.ReadDouble();
15763 CutCleanupTarget = input.ReadInt32();
15767 AbsoluteGapLimit = input.ReadDouble();
15771 RelativeGapLimit = input.ReadDouble();
15775 ExploitRelaxationSolution = input.ReadBool();
15779 DebugPostsolveWithFullSolver = input.ReadBool();
15783 UseSatInprocessing = input.ReadBool();
15787 UseFeasibilityPump = input.ReadBool();
15791 FpRounding = (global::Google.OrTools.Sat.SatParameters.Types.FPRoundingMethod) input.ReadEnum();
15795 MipAutomaticallyScaleVariables = input.ReadBool();
15799 RepairHint = input.ReadBool();
15803 PolarityRephaseIncrement = input.ReadInt32();
15807 AddZeroHalfCuts = input.ReadBool();
15811 ExpandAlldiffConstraints = input.ReadBool();
15815 Name = input.ReadString();
15819 AddCliqueCuts = input.ReadBool();
15823 KeepAllFeasibleSolutionsInPresolve = input.ReadBool();
15827 PresolveExtractIntegerEnforcement = input.ReadBool();
15831 PolishLpSolution = input.ReadBool();
15835 UseProbingSearch = input.ReadBool();
15839 ConvertIntervals = input.ReadBool();
15843 PermuteVariableRandomly = input.ReadBool();
15847 PermutePresolveConstraintOrder = input.ReadBool();
15851 UseAbslRandom = input.ReadBool();
15855 DisableConstraintExpansion = input.ReadBool();
15859 ExpandReservoirConstraints = input.ReadBool();
15863 SymmetryLevel = input.ReadInt32();
15867 LogPrefix = input.ReadString();
15871 LogToStdout = input.ReadBool();
15875 LogToResponse = input.ReadBool();
15879 OptimizeWithLbTreeSearch = input.ReadBool();
15883 LogSubsolverStatistics = input.ReadBool();
15887 ClauseCleanupRatio = input.ReadDouble();
15891 MaxDomainSizeWhenEncodingEqNeqConstraints = input.ReadInt32();
15895 FixVariablesToTheirHintedValue = input.ReadBool();
15899 SolutionPoolSize = input.ReadInt32();
15903 FillAdditionalSolutionsInResponse = input.ReadBool();
15907 DebugCrashOnBadHint = input.ReadBool();
15911 CutLevel = input.ReadInt32();
15915 AddObjectiveCut = input.ReadBool();
15919 MipComputeTrueObjectiveBound = input.ReadBool();
15923 MipMaxValidMagnitude = input.ReadDouble();
15927 UseTimetablingInNoOverlap2D = input.ReadBool();
15931 PresolveInclusionWorkLimit = input.ReadInt64();
15935 IgnoreNames = input.ReadBool();
15939 ShareBinaryClauses = input.ReadBool();
15943 ShavingDeterministicTimeInProbingSearch = input.ReadDouble();
15947 ShavingSearchDeterministicTime = input.ReadDouble();
15951 NumWorkers = input.ReadInt32();
15955 subsolvers_.AddEntriesFrom(input, _repeated_subsolvers_codec);
15959 ignoreSubsolvers_.AddEntriesFrom(input, _repeated_ignoreSubsolvers_codec);
15963 subsolverParams_.AddEntriesFrom(input, _repeated_subsolverParams_codec);
15967 UseEnergeticReasoningInNoOverlap2D = input.ReadBool();
15971 UseDualSchedulingHeuristics = input.ReadBool();
15975 UseHardPrecedencesInCumulative = input.ReadBool();
15979 DetectTableWithCost = input.ReadBool();
15983 TableCompressionLevel = input.ReadInt32();
15987 extraSubsolvers_.AddEntriesFrom(input, _repeated_extraSubsolvers_codec);
15991 ExploitAllPrecedences = input.ReadBool();
15995 PropagationLoopDetectionFactor = input.ReadDouble();
15999 OnlySolveIp = input.ReadBool();
16003 EncodeComplexLinearConstraintWithInteger = input.ReadBool();
16007 NewLinearPropagation = input.ReadBool();
16011 MipScaleLargeDomain = input.ReadBool();
16015 ProbingDeterministicTimeLimit = input.ReadDouble();
16019 RootLpIterations = input.ReadInt32();
16023 UseObjectiveLbSearch = input.ReadBool();
16027 MaxSizeToCreatePrecedenceLiteralsInDisjunctive = input.ReadInt32();
16031 UseStrongPropagationInDisjunctive = input.ReadBool();
16035 MipDropTolerance = input.ReadDouble();
16039 InferAllDiffs = input.ReadBool();
16043 FindBigLinearOverlap = input.ReadBool();
16047 SharedTreeNumWorkers = input.ReadInt32();
16051 UseSharedTreeSearch = input.ReadBool();
16055 SharedTreeMaxNodesPerWorker = input.ReadInt32();
16059 SharedTreeSplitStrategy = (global::Google.OrTools.Sat.SatParameters.Types.SharedTreeSplitStrategy) input.ReadEnum();
16063 UseLsOnly = input.ReadBool();
16067 FeasibilityJumpDecay = input.ReadDouble();
16071 NumViolationLs = input.ReadInt32();
16075 FeasibilityJumpVarRandomizationProbability = input.ReadDouble();
16079 FeasibilityJumpVarPerburbationRangeRatio = input.ReadDouble();
16083 ViolationLsPerturbationPeriod = input.ReadInt32();
16087 FeasibilityJumpEnableRestarts = input.ReadBool();
16091 StopAfterRootPropagation = input.ReadBool();
16095 UseObjectiveShavingSearch = input.ReadBool();
16099 UseLbRelaxLns = input.ReadBool();
16103 LinearSplitSize = input.ReadInt32();
16107 FeasibilityJumpLinearizationLevel = input.ReadInt32();
16111 FeasibilityJumpRestartFactor = input.ReadInt32();
16115 ViolationLsCompoundMoveProbability = input.ReadDouble();
16119 MaxNumIntervalsForTimetableEdgeFinding = input.ReadInt32();
16123 MipPresolveLevel = input.ReadInt32();
16127 PushAllTasksTowardStart = input.ReadBool();
16131 UseDynamicPrecedenceInDisjunctive = input.ReadBool();
16135 FeasibilityJumpMaxExpandedConstraintSize = input.ReadInt32();
16139 UseFeasibilityJump = input.ReadBool();
16143 LpPrimalTolerance = input.ReadDouble();
16147 LpDualTolerance = input.ReadDouble();
16151 UseDynamicPrecedenceInCumulative = input.ReadBool();
16155 UseExtendedProbing = input.ReadBool();
16159 AtMostOneMaxExpansionSize = input.ReadInt32();
16163 UseAreaEnergeticReasoningInNoOverlap2D = input.ReadBool();
16167 ProbingNumCombinationsLimit = input.ReadInt32();
16171 InprocessingDtimeRatio = input.ReadDouble();
16175 InprocessingProbingDtime = input.ReadDouble();
16179 InprocessingMinimizationDtime = input.ReadDouble();
16183 MaxPairsPairwiseReasoningInNoOverlap2D = input.ReadInt32();
16187 DetectLinearizedProduct = input.ReadBool();
16191 MipTreatHighMagnitudeBoundsAsInfinity = input.ReadBool();
16195 AddRltCuts = input.ReadBool();
16199 MaxLinMaxSizeForExpansion = input.ReadInt32();
16203 SharedTreeOpenLeavesPerWorker = input.ReadDouble();
16207 SharedTreeWorkerMinRestartsPerSubtree = input.ReadInt32();
16211 UseLns = input.ReadBool();
16215 SaveLpBasisInLbTreeSearch = input.ReadBool();
16219 ShareGlueClauses = input.ReadBool();
16223 UseConservativeScaleOverloadChecker = input.ReadBool();
16227 EncodeCumulativeAsReservoir = input.ReadBool();
16231 ExpandReservoirUsingCircuit = input.ReadBool();
16235 VariablesShavingLevel = input.ReadInt32();
16239 ShavingSearchThreshold = input.ReadInt64();
16243 MaxNumDeterministicBatches = input.ReadInt32();
16247 FeasibilityJumpBatchDtime = input.ReadDouble();
16251 filterSubsolvers_.AddEntriesFrom(input, _repeated_filterSubsolvers_codec);
16255 NumFullSubsolvers = input.ReadInt32();
16259 SharedTreeWorkerEnableTrailSharing = input.ReadBool();
16263 LbRelaxNumWorkersThreshold = input.ReadInt32();
16267 InprocessingMinimizationUseConflictAnalysis = input.ReadBool();
16271 InprocessingMinimizationUseAllOrderings = input.ReadBool();
16275 UseTryEdgeReasoningInNoOverlap2D = input.ReadBool();
16279 MinimizeSharedClauses = input.ReadBool();
16283 UseSymmetryInLp = input.ReadBool();
16287 SymmetryDetectionDeterministicTimeLimit = input.ReadDouble();
16291 KeepSymmetryInPresolve = input.ReadBool();
16295 SharedTreeWorkerEnablePhaseSharing = input.ReadBool();
16299 SharedTreeBalanceTolerance = input.ReadInt32();
16303 DebugCrashIfPresolveBreaksHint = input.ReadBool();
16307 LnsInitialDifficulty = input.ReadDouble();
16311 LnsInitialDeterministicLimit = input.ReadDouble();
16315 PolarityExploitLsHints = input.ReadBool();
16319 RemoveFixedVariablesEarly = input.ReadBool();
16323 UseAllDifferentForCircuit = input.ReadBool();
16327 RoutingCutSubsetSizeForBinaryRelationBound = input.ReadInt32();
16331 RoutingCutSubsetSizeForTightBinaryRelationBound = input.ReadInt32();
16335 RoutingCutDpEffort = input.ReadDouble();
16339 MaximumRegionsToSplitInDisconnectedNoOverlap2D = input.ReadInt32();
16343 RoutingCutSubsetSizeForExactBinaryRelationBound = input.ReadInt32();
16347 RoutingCutMaxInfeasiblePathLength = input.ReadInt32();
16351 RoutingCutSubsetSizeForShortestPathsBound = input.ReadInt32();
16355 MaxAlldiffDomainSize = input.ReadInt32();
16359 NoOverlap2DBooleanRelationsLimit = input.ReadInt32();
16363 ShareGlueClausesDtime = input.ReadDouble();
16367 UseLinear3ForNoOverlap2DPrecedences = input.ReadBool();
16371 FilterSatPostsolveClauses = input.ReadBool();
16375 AlternativePoolSize = input.ReadInt32();
16379 ShareLinear2Bounds = input.ReadBool();
16383 TransitivePrecedencesWorkLimit = input.ReadInt32();
16387 SharedTreeSplitMinDtime = input.ReadDouble();
16391 SolutionPoolDiversityLimit = input.ReadInt32();
16395 UseChronologicalBacktracking = input.ReadBool();
16399 MaxBackjumpLevels = input.ReadInt32();
16403 ChronologicalBacktrackMinConflicts = input.ReadInt32();
16407 FindClausesThatAreExactlyOne = input.ReadBool();
16411 LoadAtMostOnesInSatPresolve = input.ReadBool();
16415 UseNewIntegerConflictResolution = input.ReadBool();
16419 ClauseCleanupPeriodIncrement = input.ReadInt32();
16423 DebugCrashIfLratCheckFails = input.ReadBool();
16427 MaxDomainSizeForLinear2Expansion = input.ReadInt32();
16431 Create1UipBooleanDuringIcr = input.ReadBool();
16435 InprocessingUseCongruenceClosure = input.ReadBool();
16439 EagerlySubsumeLastNConflicts = input.ReadInt32();
16443 CheckLratProof = input.ReadBool();
16447 OutputLratProof = input.ReadBool();
16451 CheckDratProof = input.ReadBool();
16455 OutputDratProof = input.ReadBool();
16459 MaxDratTimeInSeconds = input.ReadDouble();
16463 ClauseCleanupLbdTier1 = input.ReadInt32();
16467 ClauseCleanupLbdTier2 = input.ReadInt32();
16471 ExtraSubsumptionDuringConflictAnalysis = input.ReadBool();
16475 CheckMergedLratProof = input.ReadBool();
16479 DecisionSubsumptionDuringConflictAnalysis = input.ReadBool();
16483 InprocessingUseSatSweeping = input.ReadBool();
16487 SubsumeDuringVivification = input.ReadBool();
16495 #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
16496 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
16497 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
16498 void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) {
16500 while ((tag = input.ReadTag()) != 0) {
16501 if ((tag & 7) == 4) {
16507 _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);
16510 PreferredVariableOrder = (global::Google.OrTools.Sat.SatParameters.Types.VariableOrder) input.ReadEnum();
16514 InitialPolarity = (global::Google.OrTools.Sat.SatParameters.Types.Polarity) input.ReadEnum();
16518 MinimizationAlgorithm = (global::Google.OrTools.Sat.SatParameters.Types.ConflictMinimizationAlgorithm) input.ReadEnum();
16522 ClauseCleanupPeriod = input.ReadInt32();
16526 ClauseCleanupTarget = input.ReadInt32();
16530 VariableActivityDecay = input.ReadDouble();
16534 MaxVariableActivityValue = input.ReadDouble();
16538 ClauseActivityDecay = input.ReadDouble();
16542 MaxClauseActivityValue = input.ReadDouble();
16546 GlucoseMaxDecay = input.ReadDouble();
16550 GlucoseDecayIncrement = input.ReadDouble();
16554 GlucoseDecayIncrementPeriod = input.ReadInt32();
16558 RestartPeriod = input.ReadInt32();
16562 RandomSeed = input.ReadInt32();
16566 RandomBranchesRatio = input.ReadDouble();
16570 BinaryMinimizationAlgorithm = (global::Google.OrTools.Sat.SatParameters.Types.BinaryMinizationAlgorithm) input.ReadEnum();
16574 UseOptimizationHints = input.ReadBool();
16578 MaxTimeInSeconds = input.ReadDouble();
16582 MaxNumberOfConflicts = input.ReadInt64();
16586 MaxMemoryInMb = input.ReadInt64();
16590 LogSearchProgress = input.ReadBool();
16594 UsePbResolution = input.ReadBool();
16598 UsePhaseSaving = input.ReadBool();
16602 RandomPolarityRatio = input.ReadDouble();
16606 PbCleanupIncrement = input.ReadInt32();
16610 PbCleanupRatio = input.ReadDouble();
16614 MinimizeReductionDuringPbResolution = input.ReadBool();
16618 CountAssumptionLevelsInLbd = input.ReadBool();
16622 CoreMinimizationLevel = input.ReadInt32();
16626 MaxSatAssumptionOrder = (global::Google.OrTools.Sat.SatParameters.Types.MaxSatAssumptionOrder) input.ReadEnum();
16630 MaxSatReverseAssumptionOrder = input.ReadBool();
16634 MaxSatStratification = (global::Google.OrTools.Sat.SatParameters.Types.MaxSatStratificationAlgorithm) input.ReadEnum();
16638 PresolveBveThreshold = input.ReadInt32();
16642 PresolveBveClauseWeight = input.ReadInt32();
16646 SubsumptionDuringConflictAnalysis = input.ReadBool();
16650 PresolveProbingDeterministicTimeLimit = input.ReadDouble();
16654 ClauseCleanupLbdBound = input.ReadInt32();
16658 ClauseCleanupOrdering = (global::Google.OrTools.Sat.SatParameters.Types.ClauseOrdering) input.ReadEnum();
16663 restartAlgorithms_.AddEntriesFrom(ref input, _repeated_restartAlgorithms_codec);
16667 RestartRunningWindowSize = input.ReadInt32();
16671 RestartDlAverageRatio = input.ReadDouble();
16675 UseBlockingRestart = input.ReadBool();
16679 BlockingRestartWindowSize = input.ReadInt32();
16683 BlockingRestartMultiplier = input.ReadDouble();
16687 MaxDeterministicTime = input.ReadDouble();
16691 NumConflictsBeforeStrategyChanges = input.ReadInt32();
16695 StrategyChangeIncreaseRatio = input.ReadDouble();
16699 DefaultRestartAlgorithms = input.ReadString();
16703 RestartLbdAverageRatio = input.ReadDouble();
16707 PresolveUseBva = input.ReadBool();
16711 PresolveBvaThreshold = input.ReadInt32();
16715 UsePrecedencesInDisjunctiveConstraint = input.ReadBool();
16719 UseErwaHeuristic = input.ReadBool();
16723 InitialVariablesActivity = input.ReadDouble();
16727 AlsoBumpVariablesInConflictReasons = input.ReadBool();
16731 UseOverloadCheckerInCumulative = input.ReadBool();
16735 UseTimetableEdgeFindingInCumulative = input.ReadBool();
16739 UseDisjunctiveConstraintInCumulative = input.ReadBool();
16743 SearchBranching = (global::Google.OrTools.Sat.SatParameters.Types.SearchBranching) input.ReadEnum();
16747 OptimizeWithCore = input.ReadBool();
16751 FindMultipleCores = input.ReadBool();
16755 OptimizeWithMaxHs = input.ReadBool();
16759 CpModelPresolve = input.ReadBool();
16763 EnumerateAllSolutions = input.ReadBool();
16767 PresolveBlockedClause = input.ReadBool();
16771 CoverOptimization = input.ReadBool();
16775 LinearizationLevel = input.ReadInt32();
16779 MaxNumCuts = input.ReadInt32();
16783 OnlyAddCutsAtLevelZero = input.ReadBool();
16787 CpModelUseSatPresolve = input.ReadBool();
16791 ExploitIntegerLpSolution = input.ReadBool();
16795 AutoDetectGreaterThanAtLeastOneOf = input.ReadBool();
16799 StopAfterFirstSolution = input.ReadBool();
16803 BinarySearchNumConflicts = input.ReadInt32();
16807 NumSearchWorkers = input.ReadInt32();
16811 UseLnsOnly = input.ReadBool();
16815 RandomizeSearch = input.ReadBool();
16819 SearchRandomVariablePoolSize = input.ReadInt64();
16823 InstantiateAllVariables = input.ReadBool();
16827 BooleanEncodingLevel = input.ReadInt32();
16831 UseOptionalVariables = input.ReadBool();
16835 UseExactLpReason = input.ReadBool();
16839 CpModelProbingLevel = input.ReadInt32();
16843 AddLpConstraintsLazily = input.ReadBool();
16847 ShareObjectiveBounds = input.ReadBool();
16851 ShareLevelZeroBounds = input.ReadBool();
16855 MinOrthogonalityForLpConstraints = input.ReadDouble();
16859 ExploitAllLpSolution = input.ReadBool();
16863 AddCgCuts = input.ReadBool();
16867 MaxIntegerRoundingScaling = input.ReadInt32();
16871 AddMirCuts = input.ReadBool();
16875 MaxConsecutiveInactiveCount = input.ReadInt32();
16879 NewConstraintsBatchSize = input.ReadInt32();
16883 PseudoCostReliabilityThreshold = input.ReadInt64();
16887 MipMaxBound = input.ReadDouble();
16891 MipVarScaling = input.ReadDouble();
16895 MipWantedPrecision = input.ReadDouble();
16899 MipMaxActivityExponent = input.ReadInt32();
16903 MipCheckPrecision = input.ReadDouble();
16907 UseRinsLns = input.ReadBool();
16911 ExploitBestSolution = input.ReadBool();
16915 ExploitObjective = input.ReadBool();
16919 FillTightenedDomainsInResponse = input.ReadBool();
16923 UseCombinedNoOverlap = input.ReadBool();
16927 InterleaveBatchSize = input.ReadInt32();
16931 CatchSigintSignal = input.ReadBool();
16935 InterleaveSearch = input.ReadBool();
16939 DiversifyLnsParams = input.ReadBool();
16943 MaxPresolveIterations = input.ReadInt32();
16947 UseImpliedBounds = input.ReadBool();
16951 MergeNoOverlapWorkLimit = input.ReadDouble();
16955 MergeAtMostOneWorkLimit = input.ReadDouble();
16959 PresolveSubstitutionLevel = input.ReadInt32();
16963 MaxAllDiffCutSize = input.ReadInt32();
16967 StopAfterPresolve = input.ReadBool();
16971 DebugMaxNumPresolveOperations = input.ReadInt32();
16975 AddLinMaxCuts = input.ReadBool();
16979 HintConflictLimit = input.ReadInt32();
16983 MaxCutRoundsAtLevelZero = input.ReadInt32();
16987 CutMaxActiveCountValue = input.ReadDouble();
16991 CutActiveCountDecay = input.ReadDouble();
16995 CutCleanupTarget = input.ReadInt32();
16999 AbsoluteGapLimit = input.ReadDouble();
17003 RelativeGapLimit = input.ReadDouble();
17007 ExploitRelaxationSolution = input.ReadBool();
17011 DebugPostsolveWithFullSolver = input.ReadBool();
17015 UseSatInprocessing = input.ReadBool();
17019 UseFeasibilityPump = input.ReadBool();
17023 FpRounding = (global::Google.OrTools.Sat.SatParameters.Types.FPRoundingMethod) input.ReadEnum();
17027 MipAutomaticallyScaleVariables = input.ReadBool();
17031 RepairHint = input.ReadBool();
17035 PolarityRephaseIncrement = input.ReadInt32();
17039 AddZeroHalfCuts = input.ReadBool();
17043 ExpandAlldiffConstraints = input.ReadBool();
17047 Name = input.ReadString();
17051 AddCliqueCuts = input.ReadBool();
17055 KeepAllFeasibleSolutionsInPresolve = input.ReadBool();
17059 PresolveExtractIntegerEnforcement = input.ReadBool();
17063 PolishLpSolution = input.ReadBool();
17067 UseProbingSearch = input.ReadBool();
17071 ConvertIntervals = input.ReadBool();
17075 PermuteVariableRandomly = input.ReadBool();
17079 PermutePresolveConstraintOrder = input.ReadBool();
17083 UseAbslRandom = input.ReadBool();
17087 DisableConstraintExpansion = input.ReadBool();
17091 ExpandReservoirConstraints = input.ReadBool();
17095 SymmetryLevel = input.ReadInt32();
17099 LogPrefix = input.ReadString();
17103 LogToStdout = input.ReadBool();
17107 LogToResponse = input.ReadBool();
17111 OptimizeWithLbTreeSearch = input.ReadBool();
17115 LogSubsolverStatistics = input.ReadBool();
17119 ClauseCleanupRatio = input.ReadDouble();
17123 MaxDomainSizeWhenEncodingEqNeqConstraints = input.ReadInt32();
17127 FixVariablesToTheirHintedValue = input.ReadBool();
17131 SolutionPoolSize = input.ReadInt32();
17135 FillAdditionalSolutionsInResponse = input.ReadBool();
17139 DebugCrashOnBadHint = input.ReadBool();
17143 CutLevel = input.ReadInt32();
17147 AddObjectiveCut = input.ReadBool();
17151 MipComputeTrueObjectiveBound = input.ReadBool();
17155 MipMaxValidMagnitude = input.ReadDouble();
17159 UseTimetablingInNoOverlap2D = input.ReadBool();
17163 PresolveInclusionWorkLimit = input.ReadInt64();
17167 IgnoreNames = input.ReadBool();
17171 ShareBinaryClauses = input.ReadBool();
17175 ShavingDeterministicTimeInProbingSearch = input.ReadDouble();
17179 ShavingSearchDeterministicTime = input.ReadDouble();
17183 NumWorkers = input.ReadInt32();
17187 subsolvers_.AddEntriesFrom(ref input, _repeated_subsolvers_codec);
17191 ignoreSubsolvers_.AddEntriesFrom(ref input, _repeated_ignoreSubsolvers_codec);
17195 subsolverParams_.AddEntriesFrom(ref input, _repeated_subsolverParams_codec);
17199 UseEnergeticReasoningInNoOverlap2D = input.ReadBool();
17203 UseDualSchedulingHeuristics = input.ReadBool();
17207 UseHardPrecedencesInCumulative = input.ReadBool();
17211 DetectTableWithCost = input.ReadBool();
17215 TableCompressionLevel = input.ReadInt32();
17219 extraSubsolvers_.AddEntriesFrom(ref input, _repeated_extraSubsolvers_codec);
17223 ExploitAllPrecedences = input.ReadBool();
17227 PropagationLoopDetectionFactor = input.ReadDouble();
17231 OnlySolveIp = input.ReadBool();
17235 EncodeComplexLinearConstraintWithInteger = input.ReadBool();
17239 NewLinearPropagation = input.ReadBool();
17243 MipScaleLargeDomain = input.ReadBool();
17247 ProbingDeterministicTimeLimit = input.ReadDouble();
17251 RootLpIterations = input.ReadInt32();
17255 UseObjectiveLbSearch = input.ReadBool();
17259 MaxSizeToCreatePrecedenceLiteralsInDisjunctive = input.ReadInt32();
17263 UseStrongPropagationInDisjunctive = input.ReadBool();
17267 MipDropTolerance = input.ReadDouble();
17271 InferAllDiffs = input.ReadBool();
17275 FindBigLinearOverlap = input.ReadBool();
17279 SharedTreeNumWorkers = input.ReadInt32();
17283 UseSharedTreeSearch = input.ReadBool();
17287 SharedTreeMaxNodesPerWorker = input.ReadInt32();
17291 SharedTreeSplitStrategy = (global::Google.OrTools.Sat.SatParameters.Types.SharedTreeSplitStrategy) input.ReadEnum();
17295 UseLsOnly = input.ReadBool();
17299 FeasibilityJumpDecay = input.ReadDouble();
17303 NumViolationLs = input.ReadInt32();
17307 FeasibilityJumpVarRandomizationProbability = input.ReadDouble();
17311 FeasibilityJumpVarPerburbationRangeRatio = input.ReadDouble();
17315 ViolationLsPerturbationPeriod = input.ReadInt32();
17319 FeasibilityJumpEnableRestarts = input.ReadBool();
17323 StopAfterRootPropagation = input.ReadBool();
17327 UseObjectiveShavingSearch = input.ReadBool();
17331 UseLbRelaxLns = input.ReadBool();
17335 LinearSplitSize = input.ReadInt32();
17339 FeasibilityJumpLinearizationLevel = input.ReadInt32();
17343 FeasibilityJumpRestartFactor = input.ReadInt32();
17347 ViolationLsCompoundMoveProbability = input.ReadDouble();
17351 MaxNumIntervalsForTimetableEdgeFinding = input.ReadInt32();
17355 MipPresolveLevel = input.ReadInt32();
17359 PushAllTasksTowardStart = input.ReadBool();
17363 UseDynamicPrecedenceInDisjunctive = input.ReadBool();
17367 FeasibilityJumpMaxExpandedConstraintSize = input.ReadInt32();
17371 UseFeasibilityJump = input.ReadBool();
17375 LpPrimalTolerance = input.ReadDouble();
17379 LpDualTolerance = input.ReadDouble();
17383 UseDynamicPrecedenceInCumulative = input.ReadBool();
17387 UseExtendedProbing = input.ReadBool();
17391 AtMostOneMaxExpansionSize = input.ReadInt32();
17395 UseAreaEnergeticReasoningInNoOverlap2D = input.ReadBool();
17399 ProbingNumCombinationsLimit = input.ReadInt32();
17403 InprocessingDtimeRatio = input.ReadDouble();
17407 InprocessingProbingDtime = input.ReadDouble();
17411 InprocessingMinimizationDtime = input.ReadDouble();
17415 MaxPairsPairwiseReasoningInNoOverlap2D = input.ReadInt32();
17419 DetectLinearizedProduct = input.ReadBool();
17423 MipTreatHighMagnitudeBoundsAsInfinity = input.ReadBool();
17427 AddRltCuts = input.ReadBool();
17431 MaxLinMaxSizeForExpansion = input.ReadInt32();
17435 SharedTreeOpenLeavesPerWorker = input.ReadDouble();
17439 SharedTreeWorkerMinRestartsPerSubtree = input.ReadInt32();
17443 UseLns = input.ReadBool();
17447 SaveLpBasisInLbTreeSearch = input.ReadBool();
17451 ShareGlueClauses = input.ReadBool();
17455 UseConservativeScaleOverloadChecker = input.ReadBool();
17459 EncodeCumulativeAsReservoir = input.ReadBool();
17463 ExpandReservoirUsingCircuit = input.ReadBool();
17467 VariablesShavingLevel = input.ReadInt32();
17471 ShavingSearchThreshold = input.ReadInt64();
17475 MaxNumDeterministicBatches = input.ReadInt32();
17479 FeasibilityJumpBatchDtime = input.ReadDouble();
17483 filterSubsolvers_.AddEntriesFrom(ref input, _repeated_filterSubsolvers_codec);
17487 NumFullSubsolvers = input.ReadInt32();
17491 SharedTreeWorkerEnableTrailSharing = input.ReadBool();
17495 LbRelaxNumWorkersThreshold = input.ReadInt32();
17499 InprocessingMinimizationUseConflictAnalysis = input.ReadBool();
17503 InprocessingMinimizationUseAllOrderings = input.ReadBool();
17507 UseTryEdgeReasoningInNoOverlap2D = input.ReadBool();
17511 MinimizeSharedClauses = input.ReadBool();
17515 UseSymmetryInLp = input.ReadBool();
17519 SymmetryDetectionDeterministicTimeLimit = input.ReadDouble();
17523 KeepSymmetryInPresolve = input.ReadBool();
17527 SharedTreeWorkerEnablePhaseSharing = input.ReadBool();
17531 SharedTreeBalanceTolerance = input.ReadInt32();
17535 DebugCrashIfPresolveBreaksHint = input.ReadBool();
17539 LnsInitialDifficulty = input.ReadDouble();
17543 LnsInitialDeterministicLimit = input.ReadDouble();
17547 PolarityExploitLsHints = input.ReadBool();
17551 RemoveFixedVariablesEarly = input.ReadBool();
17555 UseAllDifferentForCircuit = input.ReadBool();
17559 RoutingCutSubsetSizeForBinaryRelationBound = input.ReadInt32();
17563 RoutingCutSubsetSizeForTightBinaryRelationBound = input.ReadInt32();
17567 RoutingCutDpEffort = input.ReadDouble();
17571 MaximumRegionsToSplitInDisconnectedNoOverlap2D = input.ReadInt32();
17575 RoutingCutSubsetSizeForExactBinaryRelationBound = input.ReadInt32();
17579 RoutingCutMaxInfeasiblePathLength = input.ReadInt32();
17583 RoutingCutSubsetSizeForShortestPathsBound = input.ReadInt32();
17587 MaxAlldiffDomainSize = input.ReadInt32();
17591 NoOverlap2DBooleanRelationsLimit = input.ReadInt32();
17595 ShareGlueClausesDtime = input.ReadDouble();
17599 UseLinear3ForNoOverlap2DPrecedences = input.ReadBool();
17603 FilterSatPostsolveClauses = input.ReadBool();
17607 AlternativePoolSize = input.ReadInt32();
17611 ShareLinear2Bounds = input.ReadBool();
17615 TransitivePrecedencesWorkLimit = input.ReadInt32();
17619 SharedTreeSplitMinDtime = input.ReadDouble();
17623 SolutionPoolDiversityLimit = input.ReadInt32();
17627 UseChronologicalBacktracking = input.ReadBool();
17631 MaxBackjumpLevels = input.ReadInt32();
17635 ChronologicalBacktrackMinConflicts = input.ReadInt32();
17639 FindClausesThatAreExactlyOne = input.ReadBool();
17643 LoadAtMostOnesInSatPresolve = input.ReadBool();
17647 UseNewIntegerConflictResolution = input.ReadBool();
17651 ClauseCleanupPeriodIncrement = input.ReadInt32();
17655 DebugCrashIfLratCheckFails = input.ReadBool();
17659 MaxDomainSizeForLinear2Expansion = input.ReadInt32();
17663 Create1UipBooleanDuringIcr = input.ReadBool();
17667 InprocessingUseCongruenceClosure = input.ReadBool();
17671 EagerlySubsumeLastNConflicts = input.ReadInt32();
17675 CheckLratProof = input.ReadBool();
17679 OutputLratProof = input.ReadBool();
17683 CheckDratProof = input.ReadBool();
17687 OutputDratProof = input.ReadBool();
17691 MaxDratTimeInSeconds = input.ReadDouble();
17695 ClauseCleanupLbdTier1 = input.ReadInt32();
17699 ClauseCleanupLbdTier2 = input.ReadInt32();
17703 ExtraSubsumptionDuringConflictAnalysis = input.ReadBool();
17707 CheckMergedLratProof = input.ReadBool();
17711 DecisionSubsumptionDuringConflictAnalysis = input.ReadBool();
17715 InprocessingUseSatSweeping = input.ReadBool();
17719 SubsumeDuringVivification = input.ReadBool();
17727 #region Nested types
17729 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
17730 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
17731 public static partial class Types {
17736 public enum VariableOrder {
17740 [pbr::OriginalName(
"IN_ORDER")] InOrder = 0,
17741 [pbr::OriginalName(
"IN_REVERSE_ORDER")] InReverseOrder = 1,
17742 [pbr::OriginalName(
"IN_RANDOM_ORDER")] InRandomOrder = 2,
17753 public enum Polarity {
17754 [pbr::OriginalName(
"POLARITY_TRUE")] True = 0,
17755 [pbr::OriginalName(
"POLARITY_FALSE")] False = 1,
17756 [pbr::OriginalName(
"POLARITY_RANDOM")] Random = 2,
17762 public enum ConflictMinimizationAlgorithm {
17763 [pbr::OriginalName(
"NONE")]
None = 0,
17764 [pbr::OriginalName(
"SIMPLE")] Simple = 1,
17765 [pbr::OriginalName(
"RECURSIVE")] Recursive = 2,
17771 public enum BinaryMinizationAlgorithm {
17772 [pbr::OriginalName(
"NO_BINARY_MINIMIZATION")] NoBinaryMinimization = 0,
17773 [pbr::OriginalName(
"BINARY_MINIMIZATION_FROM_UIP")] BinaryMinimizationFromUip = 1,
17774 [pbr::OriginalName(
"BINARY_MINIMIZATION_FROM_UIP_AND_DECISIONS")] BinaryMinimizationFromUipAndDecisions = 5,
17781 public enum ClauseOrdering {
17785 [pbr::OriginalName(
"CLAUSE_ACTIVITY")] ClauseActivity = 0,
17789 [pbr::OriginalName(
"CLAUSE_LBD")] ClauseLbd = 1,
17801 [pbr::OriginalName(
"NO_RESTART")] NoRestart = 0,
17805 [pbr::OriginalName(
"LUBY_RESTART")] LubyRestart = 1,
17809 [pbr::OriginalName(
"DL_MOVING_AVERAGE_RESTART")] DlMovingAverageRestart = 2,
17813 [pbr::OriginalName(
"LBD_MOVING_AVERAGE_RESTART")] LbdMovingAverageRestart = 3,
17817 [pbr::OriginalName(
"FIXED_RESTART")] FixedRestart = 4,
17824 [pbr::OriginalName(
"DEFAULT_ASSUMPTION_ORDER")] DefaultAssumptionOrder = 0,
17825 [pbr::OriginalName(
"ORDER_ASSUMPTION_BY_DEPTH")] OrderAssumptionByDepth = 1,
17826 [pbr::OriginalName(
"ORDER_ASSUMPTION_BY_WEIGHT")] OrderAssumptionByWeight = 2,
17836 [pbr::OriginalName(
"STRATIFICATION_NONE")] StratificationNone = 0,
17841 [pbr::OriginalName(
"STRATIFICATION_DESCENT")] StratificationDescent = 1,
17848 [pbr::OriginalName(
"STRATIFICATION_ASCENT")] StratificationAscent = 2,
17861 [pbr::OriginalName(
"AUTOMATIC_SEARCH")] AutomaticSearch = 0,
17867 [pbr::OriginalName(
"FIXED_SEARCH")] FixedSearch = 1,
17871 [pbr::OriginalName(
"PORTFOLIO_SEARCH")] PortfolioSearch = 2,
17876 [pbr::OriginalName(
"LP_SEARCH")] LpSearch = 3,
17882 [pbr::OriginalName(
"PSEUDO_COST_SEARCH")] PseudoCostSearch = 4,
17888 [pbr::OriginalName(
"PORTFOLIO_WITH_QUICK_RESTART_SEARCH")] PortfolioWithQuickRestartSearch = 5,
17894 [pbr::OriginalName(
"HINT_SEARCH")] HintSearch = 6,
17901 [pbr::OriginalName(
"PARTIAL_FIXED_SEARCH")] PartialFixedSearch = 7,
17905 [pbr::OriginalName(
"RANDOMIZED_SEARCH")] RandomizedSearch = 8,
17913 [pbr::OriginalName(
"SPLIT_STRATEGY_AUTO")] SplitStrategyAuto = 0,
17922 [pbr::OriginalName(
"SPLIT_STRATEGY_DISCREPANCY")] SplitStrategyDiscrepancy = 1,
17927 [pbr::OriginalName(
"SPLIT_STRATEGY_OBJECTIVE_LB")] SplitStrategyObjectiveLb = 2,
17931 [pbr::OriginalName(
"SPLIT_STRATEGY_BALANCED_TREE")] SplitStrategyBalancedTree = 3,
17935 [pbr::OriginalName(
"SPLIT_STRATEGY_FIRST_PROPOSAL")] SplitStrategyFirstProposal = 4,
17945 [pbr::OriginalName(
"NEAREST_INTEGER")] NearestInteger = 0,
17951 [pbr::OriginalName(
"LOCK_BASED")] LockBased = 1,
17956 [pbr::OriginalName(
"ACTIVE_LOCK_BASED")] ActiveLockBased = 3,
17965 [pbr::OriginalName(
"PROPAGATION_ASSISTED")] PropagationAssisted = 2,
17977#endregion Designer generated code
1.15.0