360 #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
364 private static readonly pb::MessageParser<SatParameters> _parser =
new pb::MessageParser<SatParameters>(() =>
new SatParameters());
365 private pb::UnknownFieldSet _unknownFields;
366 private int _hasBits0;
367 private int _hasBits1;
368 private int _hasBits2;
369 private int _hasBits3;
370 private int _hasBits4;
371 private int _hasBits5;
372 private int _hasBits6;
373 private int _hasBits7;
374 private int _hasBits8;
375 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
376 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
377 public static pb::MessageParser<SatParameters>
Parser {
get {
return _parser; } }
379 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
380 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
381 public static pbr::MessageDescriptor
Descriptor {
382 get {
return global::Google.OrTools.Sat.SatParametersReflection.Descriptor.MessageTypes[0]; }
385 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
386 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
387 pbr::MessageDescriptor pb::IMessage.Descriptor {
391 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
392 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
397 partial
void OnConstruction();
399 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
400 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
402 _hasBits0 = other._hasBits0;
403 _hasBits1 = other._hasBits1;
404 _hasBits2 = other._hasBits2;
405 _hasBits3 = other._hasBits3;
406 _hasBits4 = other._hasBits4;
407 _hasBits5 = other._hasBits5;
408 _hasBits6 = other._hasBits6;
409 _hasBits7 = other._hasBits7;
410 _hasBits8 = other._hasBits8;
412 preferredVariableOrder_ = other.preferredVariableOrder_;
413 initialPolarity_ = other.initialPolarity_;
414 usePhaseSaving_ = other.usePhaseSaving_;
415 polarityRephaseIncrement_ = other.polarityRephaseIncrement_;
416 polarityExploitLsHints_ = other.polarityExploitLsHints_;
417 randomPolarityRatio_ = other.randomPolarityRatio_;
418 randomBranchesRatio_ = other.randomBranchesRatio_;
419 useErwaHeuristic_ = other.useErwaHeuristic_;
420 initialVariablesActivity_ = other.initialVariablesActivity_;
421 alsoBumpVariablesInConflictReasons_ = other.alsoBumpVariablesInConflictReasons_;
422 minimizationAlgorithm_ = other.minimizationAlgorithm_;
423 binaryMinimizationAlgorithm_ = other.binaryMinimizationAlgorithm_;
424 subsumptionDuringConflictAnalysis_ = other.subsumptionDuringConflictAnalysis_;
425 clauseCleanupPeriod_ = other.clauseCleanupPeriod_;
426 clauseCleanupTarget_ = other.clauseCleanupTarget_;
427 clauseCleanupRatio_ = other.clauseCleanupRatio_;
428 clauseCleanupProtection_ = other.clauseCleanupProtection_;
429 clauseCleanupLbdBound_ = other.clauseCleanupLbdBound_;
430 clauseCleanupOrdering_ = other.clauseCleanupOrdering_;
431 pbCleanupIncrement_ = other.pbCleanupIncrement_;
432 pbCleanupRatio_ = other.pbCleanupRatio_;
433 variableActivityDecay_ = other.variableActivityDecay_;
434 maxVariableActivityValue_ = other.maxVariableActivityValue_;
435 glucoseMaxDecay_ = other.glucoseMaxDecay_;
436 glucoseDecayIncrement_ = other.glucoseDecayIncrement_;
437 glucoseDecayIncrementPeriod_ = other.glucoseDecayIncrementPeriod_;
438 clauseActivityDecay_ = other.clauseActivityDecay_;
439 maxClauseActivityValue_ = other.maxClauseActivityValue_;
440 restartAlgorithms_ = other.restartAlgorithms_.Clone();
441 defaultRestartAlgorithms_ = other.defaultRestartAlgorithms_;
442 restartPeriod_ = other.restartPeriod_;
443 restartRunningWindowSize_ = other.restartRunningWindowSize_;
444 restartDlAverageRatio_ = other.restartDlAverageRatio_;
445 restartLbdAverageRatio_ = other.restartLbdAverageRatio_;
446 useBlockingRestart_ = other.useBlockingRestart_;
447 blockingRestartWindowSize_ = other.blockingRestartWindowSize_;
448 blockingRestartMultiplier_ = other.blockingRestartMultiplier_;
449 numConflictsBeforeStrategyChanges_ = other.numConflictsBeforeStrategyChanges_;
450 strategyChangeIncreaseRatio_ = other.strategyChangeIncreaseRatio_;
451 maxTimeInSeconds_ = other.maxTimeInSeconds_;
452 maxDeterministicTime_ = other.maxDeterministicTime_;
453 maxNumDeterministicBatches_ = other.maxNumDeterministicBatches_;
454 maxNumberOfConflicts_ = other.maxNumberOfConflicts_;
455 maxMemoryInMb_ = other.maxMemoryInMb_;
456 absoluteGapLimit_ = other.absoluteGapLimit_;
457 relativeGapLimit_ = other.relativeGapLimit_;
458 randomSeed_ = other.randomSeed_;
459 permuteVariableRandomly_ = other.permuteVariableRandomly_;
460 permutePresolveConstraintOrder_ = other.permutePresolveConstraintOrder_;
461 useAbslRandom_ = other.useAbslRandom_;
462 logSearchProgress_ = other.logSearchProgress_;
463 logSubsolverStatistics_ = other.logSubsolverStatistics_;
464 logPrefix_ = other.logPrefix_;
465 logToStdout_ = other.logToStdout_;
466 logToResponse_ = other.logToResponse_;
467 usePbResolution_ = other.usePbResolution_;
468 minimizeReductionDuringPbResolution_ = other.minimizeReductionDuringPbResolution_;
469 countAssumptionLevelsInLbd_ = other.countAssumptionLevelsInLbd_;
470 presolveBveThreshold_ = other.presolveBveThreshold_;
471 filterSatPostsolveClauses_ = other.filterSatPostsolveClauses_;
472 presolveBveClauseWeight_ = other.presolveBveClauseWeight_;
473 probingDeterministicTimeLimit_ = other.probingDeterministicTimeLimit_;
474 presolveProbingDeterministicTimeLimit_ = other.presolveProbingDeterministicTimeLimit_;
475 presolveBlockedClause_ = other.presolveBlockedClause_;
476 presolveUseBva_ = other.presolveUseBva_;
477 presolveBvaThreshold_ = other.presolveBvaThreshold_;
478 maxPresolveIterations_ = other.maxPresolveIterations_;
479 cpModelPresolve_ = other.cpModelPresolve_;
480 cpModelProbingLevel_ = other.cpModelProbingLevel_;
481 cpModelUseSatPresolve_ = other.cpModelUseSatPresolve_;
482 removeFixedVariablesEarly_ = other.removeFixedVariablesEarly_;
483 detectTableWithCost_ = other.detectTableWithCost_;
484 tableCompressionLevel_ = other.tableCompressionLevel_;
485 expandAlldiffConstraints_ = other.expandAlldiffConstraints_;
486 maxAlldiffDomainSize_ = other.maxAlldiffDomainSize_;
487 expandReservoirConstraints_ = other.expandReservoirConstraints_;
488 expandReservoirUsingCircuit_ = other.expandReservoirUsingCircuit_;
489 encodeCumulativeAsReservoir_ = other.encodeCumulativeAsReservoir_;
490 maxLinMaxSizeForExpansion_ = other.maxLinMaxSizeForExpansion_;
491 disableConstraintExpansion_ = other.disableConstraintExpansion_;
492 encodeComplexLinearConstraintWithInteger_ = other.encodeComplexLinearConstraintWithInteger_;
493 mergeNoOverlapWorkLimit_ = other.mergeNoOverlapWorkLimit_;
494 mergeAtMostOneWorkLimit_ = other.mergeAtMostOneWorkLimit_;
495 presolveSubstitutionLevel_ = other.presolveSubstitutionLevel_;
496 presolveExtractIntegerEnforcement_ = other.presolveExtractIntegerEnforcement_;
497 presolveInclusionWorkLimit_ = other.presolveInclusionWorkLimit_;
498 ignoreNames_ = other.ignoreNames_;
499 inferAllDiffs_ = other.inferAllDiffs_;
500 findBigLinearOverlap_ = other.findBigLinearOverlap_;
501 useSatInprocessing_ = other.useSatInprocessing_;
502 inprocessingDtimeRatio_ = other.inprocessingDtimeRatio_;
503 inprocessingProbingDtime_ = other.inprocessingProbingDtime_;
504 inprocessingMinimizationDtime_ = other.inprocessingMinimizationDtime_;
505 inprocessingMinimizationUseConflictAnalysis_ = other.inprocessingMinimizationUseConflictAnalysis_;
506 inprocessingMinimizationUseAllOrderings_ = other.inprocessingMinimizationUseAllOrderings_;
507 numWorkers_ = other.numWorkers_;
508 numSearchWorkers_ = other.numSearchWorkers_;
509 numFullSubsolvers_ = other.numFullSubsolvers_;
510 subsolvers_ = other.subsolvers_.Clone();
511 extraSubsolvers_ = other.extraSubsolvers_.Clone();
512 ignoreSubsolvers_ = other.ignoreSubsolvers_.Clone();
513 filterSubsolvers_ = other.filterSubsolvers_.Clone();
514 subsolverParams_ = other.subsolverParams_.Clone();
515 interleaveSearch_ = other.interleaveSearch_;
516 interleaveBatchSize_ = other.interleaveBatchSize_;
517 shareObjectiveBounds_ = other.shareObjectiveBounds_;
518 shareLevelZeroBounds_ = other.shareLevelZeroBounds_;
519 shareBinaryClauses_ = other.shareBinaryClauses_;
520 shareGlueClauses_ = other.shareGlueClauses_;
521 minimizeSharedClauses_ = other.minimizeSharedClauses_;
522 shareGlueClausesDtime_ = other.shareGlueClausesDtime_;
523 debugPostsolveWithFullSolver_ = other.debugPostsolveWithFullSolver_;
524 debugMaxNumPresolveOperations_ = other.debugMaxNumPresolveOperations_;
525 debugCrashOnBadHint_ = other.debugCrashOnBadHint_;
526 debugCrashIfPresolveBreaksHint_ = other.debugCrashIfPresolveBreaksHint_;
527 useOptimizationHints_ = other.useOptimizationHints_;
528 coreMinimizationLevel_ = other.coreMinimizationLevel_;
529 findMultipleCores_ = other.findMultipleCores_;
530 coverOptimization_ = other.coverOptimization_;
531 maxSatAssumptionOrder_ = other.maxSatAssumptionOrder_;
532 maxSatReverseAssumptionOrder_ = other.maxSatReverseAssumptionOrder_;
533 maxSatStratification_ = other.maxSatStratification_;
534 propagationLoopDetectionFactor_ = other.propagationLoopDetectionFactor_;
535 usePrecedencesInDisjunctiveConstraint_ = other.usePrecedencesInDisjunctiveConstraint_;
536 maxSizeToCreatePrecedenceLiteralsInDisjunctive_ = other.maxSizeToCreatePrecedenceLiteralsInDisjunctive_;
537 useStrongPropagationInDisjunctive_ = other.useStrongPropagationInDisjunctive_;
538 useDynamicPrecedenceInDisjunctive_ = other.useDynamicPrecedenceInDisjunctive_;
539 useDynamicPrecedenceInCumulative_ = other.useDynamicPrecedenceInCumulative_;
540 useOverloadCheckerInCumulative_ = other.useOverloadCheckerInCumulative_;
541 useConservativeScaleOverloadChecker_ = other.useConservativeScaleOverloadChecker_;
542 useTimetableEdgeFindingInCumulative_ = other.useTimetableEdgeFindingInCumulative_;
543 maxNumIntervalsForTimetableEdgeFinding_ = other.maxNumIntervalsForTimetableEdgeFinding_;
544 useHardPrecedencesInCumulative_ = other.useHardPrecedencesInCumulative_;
545 exploitAllPrecedences_ = other.exploitAllPrecedences_;
546 useDisjunctiveConstraintInCumulative_ = other.useDisjunctiveConstraintInCumulative_;
547 noOverlap2DBooleanRelationsLimit_ = other.noOverlap2DBooleanRelationsLimit_;
548 useTimetablingInNoOverlap2D_ = other.useTimetablingInNoOverlap2D_;
549 useEnergeticReasoningInNoOverlap2D_ = other.useEnergeticReasoningInNoOverlap2D_;
550 useAreaEnergeticReasoningInNoOverlap2D_ = other.useAreaEnergeticReasoningInNoOverlap2D_;
551 useTryEdgeReasoningInNoOverlap2D_ = other.useTryEdgeReasoningInNoOverlap2D_;
552 maxPairsPairwiseReasoningInNoOverlap2D_ = other.maxPairsPairwiseReasoningInNoOverlap2D_;
553 maximumRegionsToSplitInDisconnectedNoOverlap2D_ = other.maximumRegionsToSplitInDisconnectedNoOverlap2D_;
554 useLinear3ForNoOverlap2DPrecedences_ = other.useLinear3ForNoOverlap2DPrecedences_;
555 useDualSchedulingHeuristics_ = other.useDualSchedulingHeuristics_;
556 useAllDifferentForCircuit_ = other.useAllDifferentForCircuit_;
557 routingCutSubsetSizeForBinaryRelationBound_ = other.routingCutSubsetSizeForBinaryRelationBound_;
558 routingCutSubsetSizeForTightBinaryRelationBound_ = other.routingCutSubsetSizeForTightBinaryRelationBound_;
559 routingCutSubsetSizeForExactBinaryRelationBound_ = other.routingCutSubsetSizeForExactBinaryRelationBound_;
560 routingCutSubsetSizeForShortestPathsBound_ = other.routingCutSubsetSizeForShortestPathsBound_;
561 routingCutDpEffort_ = other.routingCutDpEffort_;
562 routingCutMaxInfeasiblePathLength_ = other.routingCutMaxInfeasiblePathLength_;
563 searchBranching_ = other.searchBranching_;
564 hintConflictLimit_ = other.hintConflictLimit_;
565 repairHint_ = other.repairHint_;
566 fixVariablesToTheirHintedValue_ = other.fixVariablesToTheirHintedValue_;
567 useProbingSearch_ = other.useProbingSearch_;
568 useExtendedProbing_ = other.useExtendedProbing_;
569 probingNumCombinationsLimit_ = other.probingNumCombinationsLimit_;
570 shavingDeterministicTimeInProbingSearch_ = other.shavingDeterministicTimeInProbingSearch_;
571 shavingSearchDeterministicTime_ = other.shavingSearchDeterministicTime_;
572 shavingSearchThreshold_ = other.shavingSearchThreshold_;
573 useObjectiveLbSearch_ = other.useObjectiveLbSearch_;
574 useObjectiveShavingSearch_ = other.useObjectiveShavingSearch_;
575 variablesShavingLevel_ = other.variablesShavingLevel_;
576 pseudoCostReliabilityThreshold_ = other.pseudoCostReliabilityThreshold_;
577 optimizeWithCore_ = other.optimizeWithCore_;
578 optimizeWithLbTreeSearch_ = other.optimizeWithLbTreeSearch_;
579 saveLpBasisInLbTreeSearch_ = other.saveLpBasisInLbTreeSearch_;
580 binarySearchNumConflicts_ = other.binarySearchNumConflicts_;
581 optimizeWithMaxHs_ = other.optimizeWithMaxHs_;
582 useFeasibilityJump_ = other.useFeasibilityJump_;
583 useLsOnly_ = other.useLsOnly_;
584 feasibilityJumpDecay_ = other.feasibilityJumpDecay_;
585 feasibilityJumpLinearizationLevel_ = other.feasibilityJumpLinearizationLevel_;
586 feasibilityJumpRestartFactor_ = other.feasibilityJumpRestartFactor_;
587 feasibilityJumpBatchDtime_ = other.feasibilityJumpBatchDtime_;
588 feasibilityJumpVarRandomizationProbability_ = other.feasibilityJumpVarRandomizationProbability_;
589 feasibilityJumpVarPerburbationRangeRatio_ = other.feasibilityJumpVarPerburbationRangeRatio_;
590 feasibilityJumpEnableRestarts_ = other.feasibilityJumpEnableRestarts_;
591 feasibilityJumpMaxExpandedConstraintSize_ = other.feasibilityJumpMaxExpandedConstraintSize_;
592 numViolationLs_ = other.numViolationLs_;
593 violationLsPerturbationPeriod_ = other.violationLsPerturbationPeriod_;
594 violationLsCompoundMoveProbability_ = other.violationLsCompoundMoveProbability_;
595 sharedTreeNumWorkers_ = other.sharedTreeNumWorkers_;
596 useSharedTreeSearch_ = other.useSharedTreeSearch_;
597 sharedTreeWorkerMinRestartsPerSubtree_ = other.sharedTreeWorkerMinRestartsPerSubtree_;
598 sharedTreeWorkerEnableTrailSharing_ = other.sharedTreeWorkerEnableTrailSharing_;
599 sharedTreeWorkerEnablePhaseSharing_ = other.sharedTreeWorkerEnablePhaseSharing_;
600 sharedTreeOpenLeavesPerWorker_ = other.sharedTreeOpenLeavesPerWorker_;
601 sharedTreeMaxNodesPerWorker_ = other.sharedTreeMaxNodesPerWorker_;
602 sharedTreeSplitStrategy_ = other.sharedTreeSplitStrategy_;
603 sharedTreeBalanceTolerance_ = other.sharedTreeBalanceTolerance_;
604 enumerateAllSolutions_ = other.enumerateAllSolutions_;
605 keepAllFeasibleSolutionsInPresolve_ = other.keepAllFeasibleSolutionsInPresolve_;
606 fillTightenedDomainsInResponse_ = other.fillTightenedDomainsInResponse_;
607 fillAdditionalSolutionsInResponse_ = other.fillAdditionalSolutionsInResponse_;
608 instantiateAllVariables_ = other.instantiateAllVariables_;
609 autoDetectGreaterThanAtLeastOneOf_ = other.autoDetectGreaterThanAtLeastOneOf_;
610 stopAfterFirstSolution_ = other.stopAfterFirstSolution_;
611 stopAfterPresolve_ = other.stopAfterPresolve_;
612 stopAfterRootPropagation_ = other.stopAfterRootPropagation_;
613 lnsInitialDifficulty_ = other.lnsInitialDifficulty_;
614 lnsInitialDeterministicLimit_ = other.lnsInitialDeterministicLimit_;
615 useLns_ = other.useLns_;
616 useLnsOnly_ = other.useLnsOnly_;
617 solutionPoolSize_ = other.solutionPoolSize_;
618 useRinsLns_ = other.useRinsLns_;
619 useFeasibilityPump_ = other.useFeasibilityPump_;
620 useLbRelaxLns_ = other.useLbRelaxLns_;
621 lbRelaxNumWorkersThreshold_ = other.lbRelaxNumWorkersThreshold_;
622 fpRounding_ = other.fpRounding_;
623 diversifyLnsParams_ = other.diversifyLnsParams_;
624 randomizeSearch_ = other.randomizeSearch_;
625 searchRandomVariablePoolSize_ = other.searchRandomVariablePoolSize_;
626 pushAllTasksTowardStart_ = other.pushAllTasksTowardStart_;
627 useOptionalVariables_ = other.useOptionalVariables_;
628 useExactLpReason_ = other.useExactLpReason_;
629 useCombinedNoOverlap_ = other.useCombinedNoOverlap_;
630 atMostOneMaxExpansionSize_ = other.atMostOneMaxExpansionSize_;
631 catchSigintSignal_ = other.catchSigintSignal_;
632 useImpliedBounds_ = other.useImpliedBounds_;
633 polishLpSolution_ = other.polishLpSolution_;
634 lpPrimalTolerance_ = other.lpPrimalTolerance_;
635 lpDualTolerance_ = other.lpDualTolerance_;
636 convertIntervals_ = other.convertIntervals_;
637 symmetryLevel_ = other.symmetryLevel_;
638 useSymmetryInLp_ = other.useSymmetryInLp_;
639 keepSymmetryInPresolve_ = other.keepSymmetryInPresolve_;
640 symmetryDetectionDeterministicTimeLimit_ = other.symmetryDetectionDeterministicTimeLimit_;
641 newLinearPropagation_ = other.newLinearPropagation_;
642 linearSplitSize_ = other.linearSplitSize_;
643 linearizationLevel_ = other.linearizationLevel_;
644 booleanEncodingLevel_ = other.booleanEncodingLevel_;
645 maxDomainSizeWhenEncodingEqNeqConstraints_ = other.maxDomainSizeWhenEncodingEqNeqConstraints_;
646 maxNumCuts_ = other.maxNumCuts_;
647 cutLevel_ = other.cutLevel_;
648 onlyAddCutsAtLevelZero_ = other.onlyAddCutsAtLevelZero_;
649 addObjectiveCut_ = other.addObjectiveCut_;
650 addCgCuts_ = other.addCgCuts_;
651 addMirCuts_ = other.addMirCuts_;
652 addZeroHalfCuts_ = other.addZeroHalfCuts_;
653 addCliqueCuts_ = other.addCliqueCuts_;
654 addRltCuts_ = other.addRltCuts_;
655 maxAllDiffCutSize_ = other.maxAllDiffCutSize_;
656 addLinMaxCuts_ = other.addLinMaxCuts_;
657 maxIntegerRoundingScaling_ = other.maxIntegerRoundingScaling_;
658 addLpConstraintsLazily_ = other.addLpConstraintsLazily_;
659 rootLpIterations_ = other.rootLpIterations_;
660 minOrthogonalityForLpConstraints_ = other.minOrthogonalityForLpConstraints_;
661 maxCutRoundsAtLevelZero_ = other.maxCutRoundsAtLevelZero_;
662 maxConsecutiveInactiveCount_ = other.maxConsecutiveInactiveCount_;
663 cutMaxActiveCountValue_ = other.cutMaxActiveCountValue_;
664 cutActiveCountDecay_ = other.cutActiveCountDecay_;
665 cutCleanupTarget_ = other.cutCleanupTarget_;
666 newConstraintsBatchSize_ = other.newConstraintsBatchSize_;
667 exploitIntegerLpSolution_ = other.exploitIntegerLpSolution_;
668 exploitAllLpSolution_ = other.exploitAllLpSolution_;
669 exploitBestSolution_ = other.exploitBestSolution_;
670 exploitRelaxationSolution_ = other.exploitRelaxationSolution_;
671 exploitObjective_ = other.exploitObjective_;
672 detectLinearizedProduct_ = other.detectLinearizedProduct_;
673 mipMaxBound_ = other.mipMaxBound_;
674 mipVarScaling_ = other.mipVarScaling_;
675 mipScaleLargeDomain_ = other.mipScaleLargeDomain_;
676 mipAutomaticallyScaleVariables_ = other.mipAutomaticallyScaleVariables_;
677 onlySolveIp_ = other.onlySolveIp_;
678 mipWantedPrecision_ = other.mipWantedPrecision_;
679 mipMaxActivityExponent_ = other.mipMaxActivityExponent_;
680 mipCheckPrecision_ = other.mipCheckPrecision_;
681 mipComputeTrueObjectiveBound_ = other.mipComputeTrueObjectiveBound_;
682 mipMaxValidMagnitude_ = other.mipMaxValidMagnitude_;
683 mipTreatHighMagnitudeBoundsAsInfinity_ = other.mipTreatHighMagnitudeBoundsAsInfinity_;
684 mipDropTolerance_ = other.mipDropTolerance_;
685 mipPresolveLevel_ = other.mipPresolveLevel_;
686 _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
689 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
690 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
697 private readonly
static string NameDefaultValue =
"";
699 private string name_;
704 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
705 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
707 get {
return name_ ?? NameDefaultValue; }
709 name_ = pb::ProtoPreconditions.CheckNotNull(value,
"value");
713 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
714 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
716 get {
return name_ !=
null; }
719 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
720 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
727 private readonly
static global::Google.OrTools.Sat.SatParameters.Types.VariableOrder PreferredVariableOrderDefaultValue = global::Google.OrTools.Sat.SatParameters.Types.VariableOrder.InOrder;
729 private global::Google.OrTools.Sat.SatParameters.Types.VariableOrder preferredVariableOrder_;
730 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
731 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
733 get { if ((_hasBits0 & 1) != 0) { return preferredVariableOrder_; } else { return PreferredVariableOrderDefaultValue; } }
736 preferredVariableOrder_ = value;
740 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
741 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
742 public bool HasPreferredVariableOrder {
743 get {
return (_hasBits0 & 1) != 0; }
746 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
747 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
748 public void ClearPreferredVariableOrder() {
753 public const int InitialPolarityFieldNumber = 2;
754 private readonly
static global::Google.OrTools.Sat.SatParameters.Types.Polarity InitialPolarityDefaultValue = global::Google.OrTools.Sat.SatParameters.Types.Polarity.False;
756 private global::Google.OrTools.Sat.SatParameters.Types.Polarity initialPolarity_;
757 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
758 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
760 get { if ((_hasBits0 & 2) != 0) { return initialPolarity_; } else { return InitialPolarityDefaultValue; } }
763 initialPolarity_ = value;
767 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
768 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
769 public bool HasInitialPolarity {
770 get {
return (_hasBits0 & 2) != 0; }
773 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
774 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
775 public void ClearInitialPolarity() {
780 public const int UsePhaseSavingFieldNumber = 44;
781 private readonly
static bool UsePhaseSavingDefaultValue =
true;
783 private bool usePhaseSaving_;
797 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
798 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
800 get {
if ((_hasBits0 & 4194304) != 0) {
return usePhaseSaving_; }
else {
return UsePhaseSavingDefaultValue; } }
802 _hasBits0 |= 4194304;
803 usePhaseSaving_ = value;
807 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
808 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
809 public bool HasUsePhaseSaving {
810 get {
return (_hasBits0 & 4194304) != 0; }
813 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
814 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
816 _hasBits0 &= ~4194304;
821 private readonly
static int PolarityRephaseIncrementDefaultValue = 1000;
823 private int polarityRephaseIncrement_;
829 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
830 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
832 get {
if ((_hasBits4 & 4) != 0) {
return polarityRephaseIncrement_; }
else {
return PolarityRephaseIncrementDefaultValue; } }
835 polarityRephaseIncrement_ = value;
839 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
840 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
841 public bool HasPolarityRephaseIncrement {
842 get {
return (_hasBits4 & 4) != 0; }
845 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
846 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
853 private readonly
static bool PolarityExploitLsHintsDefaultValue =
false;
855 private bool polarityExploitLsHints_;
860 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
861 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
863 get {
if ((_hasBits7 & 134217728) != 0) {
return polarityExploitLsHints_; }
else {
return PolarityExploitLsHintsDefaultValue; } }
865 _hasBits7 |= 134217728;
866 polarityExploitLsHints_ = value;
870 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
871 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
872 public bool HasPolarityExploitLsHints {
873 get {
return (_hasBits7 & 134217728) != 0; }
876 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
877 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
879 _hasBits7 &= ~134217728;
884 private readonly
static double RandomPolarityRatioDefaultValue = 0D;
886 private double randomPolarityRatio_;
894 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
895 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
897 get {
if ((_hasBits0 & 8388608) != 0) {
return randomPolarityRatio_; }
else {
return RandomPolarityRatioDefaultValue; } }
899 _hasBits0 |= 8388608;
900 randomPolarityRatio_ = value;
904 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
905 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
906 public bool HasRandomPolarityRatio {
907 get {
return (_hasBits0 & 8388608) != 0; }
910 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
911 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
913 _hasBits0 &= ~8388608;
918 private readonly
static double RandomBranchesRatioDefaultValue = 0D;
920 private double randomBranchesRatio_;
926 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
927 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
929 get {
if ((_hasBits0 & 16384) != 0) {
return randomBranchesRatio_; }
else {
return RandomBranchesRatioDefaultValue; } }
932 randomBranchesRatio_ = value;
936 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
937 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
938 public bool HasRandomBranchesRatio {
939 get {
return (_hasBits0 & 16384) != 0; }
942 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
943 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
950 private readonly
static bool UseErwaHeuristicDefaultValue =
false;
952 private bool useErwaHeuristic_;
958 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
959 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
961 get {
if ((_hasBits1 & 524288) != 0) {
return useErwaHeuristic_; }
else {
return UseErwaHeuristicDefaultValue; } }
964 useErwaHeuristic_ = value;
968 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
969 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
970 public bool HasUseErwaHeuristic {
971 get {
return (_hasBits1 & 524288) != 0; }
974 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
975 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
977 _hasBits1 &= ~524288;
982 private readonly
static double InitialVariablesActivityDefaultValue = 0D;
984 private double initialVariablesActivity_;
993 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
994 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
996 get {
if ((_hasBits1 & 1048576) != 0) {
return initialVariablesActivity_; }
else {
return InitialVariablesActivityDefaultValue; } }
998 _hasBits1 |= 1048576;
999 initialVariablesActivity_ = value;
1003 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1004 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1005 public bool HasInitialVariablesActivity {
1006 get {
return (_hasBits1 & 1048576) != 0; }
1009 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1010 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1012 _hasBits1 &= ~1048576;
1017 private readonly
static bool AlsoBumpVariablesInConflictReasonsDefaultValue =
false;
1019 private bool alsoBumpVariablesInConflictReasons_;
1026 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1027 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1029 get {
if ((_hasBits1 & 2097152) != 0) {
return alsoBumpVariablesInConflictReasons_; }
else {
return AlsoBumpVariablesInConflictReasonsDefaultValue; } }
1031 _hasBits1 |= 2097152;
1032 alsoBumpVariablesInConflictReasons_ = value;
1036 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1037 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1038 public bool HasAlsoBumpVariablesInConflictReasons {
1039 get {
return (_hasBits1 & 2097152) != 0; }
1042 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1043 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1045 _hasBits1 &= ~2097152;
1050 private readonly
static global::Google.OrTools.Sat.SatParameters.Types.ConflictMinimizationAlgorithm MinimizationAlgorithmDefaultValue = global::Google.OrTools.Sat.SatParameters.Types.ConflictMinimizationAlgorithm.Recursive;
1052 private global::Google.OrTools.Sat.SatParameters.Types.ConflictMinimizationAlgorithm minimizationAlgorithm_;
1053 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1054 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1056 get { if ((_hasBits0 & 4) != 0) { return minimizationAlgorithm_; } else { return MinimizationAlgorithmDefaultValue; } }
1059 minimizationAlgorithm_ = value;
1063 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1064 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1065 public bool HasMinimizationAlgorithm {
1066 get {
return (_hasBits0 & 4) != 0; }
1069 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1070 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1077 private readonly
static global::Google.OrTools.Sat.SatParameters.Types.BinaryMinizationAlgorithm BinaryMinimizationAlgorithmDefaultValue = global::Google.OrTools.Sat.SatParameters.Types.BinaryMinizationAlgorithm.BinaryMinimizationFirst;
1079 private global::Google.OrTools.Sat.SatParameters.Types.BinaryMinizationAlgorithm binaryMinimizationAlgorithm_;
1080 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1081 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1083 get { if ((_hasBits0 & 32768) != 0) { return binaryMinimizationAlgorithm_; } else { return BinaryMinimizationAlgorithmDefaultValue; } }
1086 binaryMinimizationAlgorithm_ = value;
1090 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1091 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1092 public bool HasBinaryMinimizationAlgorithm {
1093 get {
return (_hasBits0 & 32768) != 0; }
1096 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1097 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1099 _hasBits0 &= ~32768;
1104 private readonly
static bool SubsumptionDuringConflictAnalysisDefaultValue =
true;
1106 private bool subsumptionDuringConflictAnalysis_;
1113 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1114 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1116 get {
if ((_hasBits1 & 4) != 0) {
return subsumptionDuringConflictAnalysis_; }
else {
return SubsumptionDuringConflictAnalysisDefaultValue; } }
1119 subsumptionDuringConflictAnalysis_ = value;
1123 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1124 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1125 public bool HasSubsumptionDuringConflictAnalysis {
1126 get {
return (_hasBits1 & 4) != 0; }
1129 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1130 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1137 private readonly
static int ClauseCleanupPeriodDefaultValue = 10000;
1139 private int clauseCleanupPeriod_;
1143 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1144 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1146 get {
if ((_hasBits0 & 8) != 0) {
return clauseCleanupPeriod_; }
else {
return ClauseCleanupPeriodDefaultValue; } }
1149 clauseCleanupPeriod_ = value;
1153 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1154 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1155 public bool HasClauseCleanupPeriod {
1156 get {
return (_hasBits0 & 8) != 0; }
1159 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1160 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1167 private readonly
static int ClauseCleanupTargetDefaultValue = 0;
1169 private int clauseCleanupTarget_;
1174 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1175 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1177 get {
if ((_hasBits0 & 16) != 0) {
return clauseCleanupTarget_; }
else {
return ClauseCleanupTargetDefaultValue; } }
1180 clauseCleanupTarget_ = value;
1184 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1185 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1186 public bool HasClauseCleanupTarget {
1187 get {
return (_hasBits0 & 16) != 0; }
1190 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1191 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1198 private readonly
static double ClauseCleanupRatioDefaultValue = 0.5D;
1200 private double clauseCleanupRatio_;
1206 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1207 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1209 get {
if ((_hasBits4 & 2097152) != 0) {
return clauseCleanupRatio_; }
else {
return ClauseCleanupRatioDefaultValue; } }
1211 _hasBits4 |= 2097152;
1212 clauseCleanupRatio_ = value;
1216 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1217 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1218 public bool HasClauseCleanupRatio {
1219 get {
return (_hasBits4 & 2097152) != 0; }
1222 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1223 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1225 _hasBits4 &= ~2097152;
1230 private readonly
static global::Google.OrTools.Sat.SatParameters.Types.ClauseProtection ClauseCleanupProtectionDefaultValue = global::Google.OrTools.Sat.SatParameters.Types.ClauseProtection.ProtectionNone;
1232 private global::Google.OrTools.Sat.SatParameters.Types.ClauseProtection clauseCleanupProtection_;
1233 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1234 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1236 get { if ((_hasBits1 & 16) != 0) { return clauseCleanupProtection_; } else { return ClauseCleanupProtectionDefaultValue; } }
1239 clauseCleanupProtection_ = value;
1243 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1244 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1245 public bool HasClauseCleanupProtection {
1246 get {
return (_hasBits1 & 16) != 0; }
1249 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1250 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1257 private readonly
static int ClauseCleanupLbdBoundDefaultValue = 5;
1259 private int clauseCleanupLbdBound_;
1264 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1265 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1267 get {
if ((_hasBits1 & 32) != 0) {
return clauseCleanupLbdBound_; }
else {
return ClauseCleanupLbdBoundDefaultValue; } }
1270 clauseCleanupLbdBound_ = value;
1274 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1275 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1276 public bool HasClauseCleanupLbdBound {
1277 get {
return (_hasBits1 & 32) != 0; }
1280 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1281 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1288 private readonly
static global::Google.OrTools.Sat.SatParameters.Types.ClauseOrdering ClauseCleanupOrderingDefaultValue = global::Google.OrTools.Sat.SatParameters.Types.ClauseOrdering.ClauseActivity;
1290 private global::Google.OrTools.Sat.SatParameters.Types.ClauseOrdering clauseCleanupOrdering_;
1291 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1292 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1294 get { if ((_hasBits1 & 64) != 0) { return clauseCleanupOrdering_; } else { return ClauseCleanupOrderingDefaultValue; } }
1297 clauseCleanupOrdering_ = value;
1301 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1302 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1303 public bool HasClauseCleanupOrdering {
1304 get {
return (_hasBits1 & 64) != 0; }
1307 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1308 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1315 private readonly
static int PbCleanupIncrementDefaultValue = 200;
1317 private int pbCleanupIncrement_;
1321 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1322 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1324 get {
if ((_hasBits0 & 16777216) != 0) {
return pbCleanupIncrement_; }
else {
return PbCleanupIncrementDefaultValue; } }
1326 _hasBits0 |= 16777216;
1327 pbCleanupIncrement_ = value;
1331 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1332 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1333 public bool HasPbCleanupIncrement {
1334 get {
return (_hasBits0 & 16777216) != 0; }
1337 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1338 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1340 _hasBits0 &= ~16777216;
1345 private readonly
static double PbCleanupRatioDefaultValue = 0.5D;
1347 private double pbCleanupRatio_;
1348 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1349 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1351 get {
if ((_hasBits0 & 33554432) != 0) {
return pbCleanupRatio_; }
else {
return PbCleanupRatioDefaultValue; } }
1353 _hasBits0 |= 33554432;
1354 pbCleanupRatio_ = value;
1358 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1359 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1360 public bool HasPbCleanupRatio {
1361 get {
return (_hasBits0 & 33554432) != 0; }
1364 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1365 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1367 _hasBits0 &= ~33554432;
1372 private readonly
static double VariableActivityDecayDefaultValue = 0.8D;
1374 private double variableActivityDecay_;
1385 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1386 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1388 get {
if ((_hasBits0 & 32) != 0) {
return variableActivityDecay_; }
else {
return VariableActivityDecayDefaultValue; } }
1391 variableActivityDecay_ = value;
1395 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1396 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1397 public bool HasVariableActivityDecay {
1398 get {
return (_hasBits0 & 32) != 0; }
1401 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1402 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1409 private readonly
static double MaxVariableActivityValueDefaultValue = 1e+100D;
1411 private double maxVariableActivityValue_;
1412 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1413 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1415 get {
if ((_hasBits0 & 64) != 0) {
return maxVariableActivityValue_; }
else {
return MaxVariableActivityValueDefaultValue; } }
1418 maxVariableActivityValue_ = value;
1422 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1423 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1424 public bool HasMaxVariableActivityValue {
1425 get {
return (_hasBits0 & 64) != 0; }
1428 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1429 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1436 private readonly
static double GlucoseMaxDecayDefaultValue = 0.95D;
1438 private double glucoseMaxDecay_;
1446 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1447 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1449 get {
if ((_hasBits0 & 512) != 0) {
return glucoseMaxDecay_; }
else {
return GlucoseMaxDecayDefaultValue; } }
1452 glucoseMaxDecay_ = value;
1456 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1457 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1458 public bool HasGlucoseMaxDecay {
1459 get {
return (_hasBits0 & 512) != 0; }
1462 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1463 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1470 private readonly
static double GlucoseDecayIncrementDefaultValue = 0.01D;
1472 private double glucoseDecayIncrement_;
1473 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1474 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1476 get {
if ((_hasBits0 & 1024) != 0) {
return glucoseDecayIncrement_; }
else {
return GlucoseDecayIncrementDefaultValue; } }
1479 glucoseDecayIncrement_ = value;
1483 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1484 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1485 public bool HasGlucoseDecayIncrement {
1486 get {
return (_hasBits0 & 1024) != 0; }
1489 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1490 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1497 private readonly
static int GlucoseDecayIncrementPeriodDefaultValue = 5000;
1499 private int glucoseDecayIncrementPeriod_;
1500 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1501 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1503 get {
if ((_hasBits0 & 2048) != 0) {
return glucoseDecayIncrementPeriod_; }
else {
return GlucoseDecayIncrementPeriodDefaultValue; } }
1506 glucoseDecayIncrementPeriod_ = value;
1510 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1511 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1512 public bool HasGlucoseDecayIncrementPeriod {
1513 get {
return (_hasBits0 & 2048) != 0; }
1516 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1517 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1524 private readonly
static double ClauseActivityDecayDefaultValue = 0.999D;
1526 private double clauseActivityDecay_;
1530 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1531 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1533 get {
if ((_hasBits0 & 128) != 0) {
return clauseActivityDecay_; }
else {
return ClauseActivityDecayDefaultValue; } }
1536 clauseActivityDecay_ = value;
1540 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1541 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1542 public bool HasClauseActivityDecay {
1543 get {
return (_hasBits0 & 128) != 0; }
1546 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1547 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1554 private readonly
static double MaxClauseActivityValueDefaultValue = 1e+20D;
1556 private double maxClauseActivityValue_;
1557 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1558 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1560 get {
if ((_hasBits0 & 256) != 0) {
return maxClauseActivityValue_; }
else {
return MaxClauseActivityValueDefaultValue; } }
1563 maxClauseActivityValue_ = value;
1567 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1568 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1569 public bool HasMaxClauseActivityValue {
1570 get {
return (_hasBits0 & 256) != 0; }
1573 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1574 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1581 private static readonly pb::FieldCodec<global::Google.OrTools.Sat.SatParameters.Types.RestartAlgorithm> _repeated_restartAlgorithms_codec
1583 private readonly pbc::RepeatedField<global::Google.OrTools.Sat.SatParameters.Types.RestartAlgorithm> restartAlgorithms_ =
new pbc::RepeatedField<global::Google.OrTools.Sat.SatParameters.Types.RestartAlgorithm>();
1595 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1596 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1597 public pbc::RepeatedField<global::Google.OrTools.Sat.SatParameters.Types.RestartAlgorithm>
RestartAlgorithms {
1598 get { return restartAlgorithms_; }
1602 public const int DefaultRestartAlgorithmsFieldNumber = 70;
1603 private readonly
static string DefaultRestartAlgorithmsDefaultValue = global::System.Text.Encoding.UTF8.GetString(global::System.Convert.FromBase64String(
"TFVCWV9SRVNUQVJULExCRF9NT1ZJTkdfQVZFUkFHRV9SRVNUQVJULERMX01PVklOR19BVkVSQUdFX1JFU1RBUlQ="), 0, 65);
1605 private string defaultRestartAlgorithms_;
1606 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1607 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1609 get { return defaultRestartAlgorithms_ ?? DefaultRestartAlgorithmsDefaultValue; }
1611 defaultRestartAlgorithms_ = pb::ProtoPreconditions.CheckNotNull(value,
"value");
1615 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1616 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1618 get {
return defaultRestartAlgorithms_ !=
null; }
1621 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1622 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1624 defaultRestartAlgorithms_ =
null;
1628 public const int RestartPeriodFieldNumber = 30;
1629 private readonly
static int RestartPeriodDefaultValue = 50;
1631 private int restartPeriod_;
1636 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1637 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1639 get {
if ((_hasBits0 & 4096) != 0) {
return restartPeriod_; }
else {
return RestartPeriodDefaultValue; } }
1642 restartPeriod_ = value;
1646 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1647 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1648 public bool HasRestartPeriod {
1649 get {
return (_hasBits0 & 4096) != 0; }
1652 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1653 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1659 public const int RestartRunningWindowSizeFieldNumber = 62;
1660 private readonly
static int RestartRunningWindowSizeDefaultValue = 50;
1662 private int restartRunningWindowSize_;
1666 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1667 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1669 get {
if ((_hasBits1 & 128) != 0) {
return restartRunningWindowSize_; }
else {
return RestartRunningWindowSizeDefaultValue; } }
1672 restartRunningWindowSize_ = value;
1676 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1677 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1678 public bool HasRestartRunningWindowSize {
1679 get {
return (_hasBits1 & 128) != 0; }
1682 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1683 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1689 public const int RestartDlAverageRatioFieldNumber = 63;
1690 private readonly
static double RestartDlAverageRatioDefaultValue = 1D;
1692 private double restartDlAverageRatio_;
1697 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1698 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1700 get {
if ((_hasBits1 & 256) != 0) {
return restartDlAverageRatio_; }
else {
return RestartDlAverageRatioDefaultValue; } }
1703 restartDlAverageRatio_ = value;
1707 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1708 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1709 public bool HasRestartDlAverageRatio {
1710 get {
return (_hasBits1 & 256) != 0; }
1713 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1714 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1720 public const int RestartLbdAverageRatioFieldNumber = 71;
1721 private readonly
static double RestartLbdAverageRatioDefaultValue = 1D;
1723 private double restartLbdAverageRatio_;
1724 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1725 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1727 get {
if ((_hasBits1 & 32768) != 0) {
return restartLbdAverageRatio_; }
else {
return RestartLbdAverageRatioDefaultValue; } }
1730 restartLbdAverageRatio_ = value;
1734 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1735 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1736 public bool HasRestartLbdAverageRatio {
1737 get {
return (_hasBits1 & 32768) != 0; }
1740 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1741 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1743 _hasBits1 &= ~32768;
1747 public const int UseBlockingRestartFieldNumber = 64;
1748 private readonly
static bool UseBlockingRestartDefaultValue =
false;
1750 private bool useBlockingRestart_;
1756 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1757 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1759 get {
if ((_hasBits1 & 512) != 0) {
return useBlockingRestart_; }
else {
return UseBlockingRestartDefaultValue; } }
1762 useBlockingRestart_ = value;
1766 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1767 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1768 public bool HasUseBlockingRestart {
1769 get {
return (_hasBits1 & 512) != 0; }
1772 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1773 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1779 public const int BlockingRestartWindowSizeFieldNumber = 65;
1780 private readonly
static int BlockingRestartWindowSizeDefaultValue = 5000;
1782 private int blockingRestartWindowSize_;
1783 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1784 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1786 get {
if ((_hasBits1 & 1024) != 0) {
return blockingRestartWindowSize_; }
else {
return BlockingRestartWindowSizeDefaultValue; } }
1789 blockingRestartWindowSize_ = value;
1793 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1794 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1795 public bool HasBlockingRestartWindowSize {
1796 get {
return (_hasBits1 & 1024) != 0; }
1799 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1800 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1806 public const int BlockingRestartMultiplierFieldNumber = 66;
1807 private readonly
static double BlockingRestartMultiplierDefaultValue = 1.4D;
1809 private double blockingRestartMultiplier_;
1810 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1811 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1813 get {
if ((_hasBits1 & 2048) != 0) {
return blockingRestartMultiplier_; }
else {
return BlockingRestartMultiplierDefaultValue; } }
1816 blockingRestartMultiplier_ = value;
1820 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1821 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1822 public bool HasBlockingRestartMultiplier {
1823 get {
return (_hasBits1 & 2048) != 0; }
1826 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1827 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1833 public const int NumConflictsBeforeStrategyChangesFieldNumber = 68;
1834 private readonly
static int NumConflictsBeforeStrategyChangesDefaultValue = 0;
1836 private int numConflictsBeforeStrategyChanges_;
1842 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1843 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1845 get {
if ((_hasBits1 & 8192) != 0) {
return numConflictsBeforeStrategyChanges_; }
else {
return NumConflictsBeforeStrategyChangesDefaultValue; } }
1848 numConflictsBeforeStrategyChanges_ = value;
1852 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1853 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1854 public bool HasNumConflictsBeforeStrategyChanges {
1855 get {
return (_hasBits1 & 8192) != 0; }
1858 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1859 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1865 public const int StrategyChangeIncreaseRatioFieldNumber = 69;
1866 private readonly
static double StrategyChangeIncreaseRatioDefaultValue = 0D;
1868 private double strategyChangeIncreaseRatio_;
1873 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1874 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1876 get {
if ((_hasBits1 & 16384) != 0) {
return strategyChangeIncreaseRatio_; }
else {
return StrategyChangeIncreaseRatioDefaultValue; } }
1879 strategyChangeIncreaseRatio_ = value;
1883 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1884 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1885 public bool HasStrategyChangeIncreaseRatio {
1886 get {
return (_hasBits1 & 16384) != 0; }
1889 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1890 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1892 _hasBits1 &= ~16384;
1896 public const int MaxTimeInSecondsFieldNumber = 36;
1897 private readonly
static double MaxTimeInSecondsDefaultValue =
double.PositiveInfinity;
1899 private double maxTimeInSeconds_;
1904 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1905 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1907 get {
if ((_hasBits0 & 131072) != 0) {
return maxTimeInSeconds_; }
else {
return MaxTimeInSecondsDefaultValue; } }
1909 _hasBits0 |= 131072;
1910 maxTimeInSeconds_ = value;
1914 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1915 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1916 public bool HasMaxTimeInSeconds {
1917 get {
return (_hasBits0 & 131072) != 0; }
1920 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1921 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1923 _hasBits0 &= ~131072;
1927 public const int MaxDeterministicTimeFieldNumber = 67;
1928 private readonly
static double MaxDeterministicTimeDefaultValue =
double.PositiveInfinity;
1930 private double maxDeterministicTime_;
1936 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1937 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1939 get {
if ((_hasBits1 & 4096) != 0) {
return maxDeterministicTime_; }
else {
return MaxDeterministicTimeDefaultValue; } }
1942 maxDeterministicTime_ = value;
1946 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1947 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1948 public bool HasMaxDeterministicTime {
1949 get {
return (_hasBits1 & 4096) != 0; }
1952 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1953 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1959 public const int MaxNumDeterministicBatchesFieldNumber = 291;
1960 private readonly
static int MaxNumDeterministicBatchesDefaultValue = 0;
1962 private int maxNumDeterministicBatches_;
1967 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1968 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1970 get {
if ((_hasBits7 & 1024) != 0) {
return maxNumDeterministicBatches_; }
else {
return MaxNumDeterministicBatchesDefaultValue; } }
1973 maxNumDeterministicBatches_ = value;
1977 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1978 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1979 public bool HasMaxNumDeterministicBatches {
1980 get {
return (_hasBits7 & 1024) != 0; }
1983 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
1984 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
1990 public const int MaxNumberOfConflictsFieldNumber = 37;
1991 private readonly
static long MaxNumberOfConflictsDefaultValue = 9223372036854775807L;
1993 private long maxNumberOfConflicts_;
2003 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2004 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2006 get {
if ((_hasBits0 & 262144) != 0) {
return maxNumberOfConflicts_; }
else {
return MaxNumberOfConflictsDefaultValue; } }
2008 _hasBits0 |= 262144;
2009 maxNumberOfConflicts_ = value;
2013 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2014 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2016 get {
return (_hasBits0 & 262144) != 0; }
2019 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2020 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2021 public void ClearMaxNumberOfConflicts() {
2022 _hasBits0 &= ~262144;
2026 public const int MaxMemoryInMbFieldNumber = 40;
2027 private readonly
static long MaxMemoryInMbDefaultValue = 10000L;
2029 private long maxMemoryInMb_;
2038 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2039 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2041 get {
if ((_hasBits0 & 524288) != 0) {
return maxMemoryInMb_; }
else {
return MaxMemoryInMbDefaultValue; } }
2043 _hasBits0 |= 524288;
2044 maxMemoryInMb_ = value;
2048 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2049 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2051 get {
return (_hasBits0 & 524288) != 0; }
2054 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2055 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2056 public void ClearMaxMemoryInMb() {
2057 _hasBits0 &= ~524288;
2061 public const int AbsoluteGapLimitFieldNumber = 159;
2062 private readonly
static double AbsoluteGapLimitDefaultValue = 0.0001D;
2064 private double absoluteGapLimit_;
2085 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2086 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2088 get {
if ((_hasBits3 & 33554432) != 0) {
return absoluteGapLimit_; }
else {
return AbsoluteGapLimitDefaultValue; } }
2090 _hasBits3 |= 33554432;
2091 absoluteGapLimit_ = value;
2095 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2096 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2097 public bool HasAbsoluteGapLimit {
2098 get {
return (_hasBits3 & 33554432) != 0; }
2101 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2102 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2103 public void ClearAbsoluteGapLimit() {
2104 _hasBits3 &= ~33554432;
2109 private readonly
static double RelativeGapLimitDefaultValue = 0D;
2111 private double relativeGapLimit_;
2112 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2113 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2115 get {
if ((_hasBits3 & 67108864) != 0) {
return relativeGapLimit_; }
else {
return RelativeGapLimitDefaultValue; } }
2117 _hasBits3 |= 67108864;
2118 relativeGapLimit_ = value;
2122 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2123 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2124 public bool HasRelativeGapLimit {
2125 get {
return (_hasBits3 & 67108864) != 0; }
2128 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2129 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2130 public void ClearRelativeGapLimit() {
2131 _hasBits3 &= ~67108864;
2136 private readonly
static int RandomSeedDefaultValue = 1;
2138 private int randomSeed_;
2148 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2149 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2151 get {
if ((_hasBits0 & 8192) != 0) {
return randomSeed_; }
else {
return RandomSeedDefaultValue; } }
2154 randomSeed_ = value;
2158 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2159 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2160 public bool HasRandomSeed {
2161 get {
return (_hasBits0 & 8192) != 0; }
2164 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2165 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2166 public void ClearRandomSeed() {
2171 public const int PermuteVariableRandomlyFieldNumber = 178;
2172 private readonly
static bool PermuteVariableRandomlyDefaultValue =
false;
2174 private bool permuteVariableRandomly_;
2181 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2182 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2184 get {
if ((_hasBits4 & 2048) != 0) {
return permuteVariableRandomly_; }
else {
return PermuteVariableRandomlyDefaultValue; } }
2187 permuteVariableRandomly_ = value;
2191 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2192 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2193 public bool HasPermuteVariableRandomly {
2194 get {
return (_hasBits4 & 2048) != 0; }
2197 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2198 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2199 public void ClearPermuteVariableRandomly() {
2204 public const int PermutePresolveConstraintOrderFieldNumber = 179;
2205 private readonly
static bool PermutePresolveConstraintOrderDefaultValue =
false;
2207 private bool permutePresolveConstraintOrder_;
2208 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2209 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2211 get {
if ((_hasBits4 & 4096) != 0) {
return permutePresolveConstraintOrder_; }
else {
return PermutePresolveConstraintOrderDefaultValue; } }
2214 permutePresolveConstraintOrder_ = value;
2218 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2219 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2220 public bool HasPermutePresolveConstraintOrder {
2221 get {
return (_hasBits4 & 4096) != 0; }
2224 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2225 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2226 public void ClearPermutePresolveConstraintOrder() {
2231 public const int UseAbslRandomFieldNumber = 180;
2232 private readonly
static bool UseAbslRandomDefaultValue =
false;
2234 private bool useAbslRandom_;
2235 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2236 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2238 get {
if ((_hasBits4 & 8192) != 0) {
return useAbslRandom_; }
else {
return UseAbslRandomDefaultValue; } }
2241 useAbslRandom_ = value;
2245 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2246 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2247 public bool HasUseAbslRandom {
2248 get {
return (_hasBits4 & 8192) != 0; }
2251 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2252 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2253 public void ClearUseAbslRandom() {
2258 public const int LogSearchProgressFieldNumber = 41;
2259 private readonly
static bool LogSearchProgressDefaultValue =
false;
2261 private bool logSearchProgress_;
2267 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2268 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2270 get {
if ((_hasBits0 & 1048576) != 0) {
return logSearchProgress_; }
else {
return LogSearchProgressDefaultValue; } }
2272 _hasBits0 |= 1048576;
2273 logSearchProgress_ = value;
2277 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2278 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2279 public bool HasLogSearchProgress {
2280 get {
return (_hasBits0 & 1048576) != 0; }
2283 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2284 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2285 public void ClearLogSearchProgress() {
2286 _hasBits0 &= ~1048576;
2290 public const int LogSubsolverStatisticsFieldNumber = 189;
2291 private readonly
static bool LogSubsolverStatisticsDefaultValue =
false;
2293 private bool logSubsolverStatistics_;
2300 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2301 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2303 get {
if ((_hasBits4 & 1048576) != 0) {
return logSubsolverStatistics_; }
else {
return LogSubsolverStatisticsDefaultValue; } }
2305 _hasBits4 |= 1048576;
2306 logSubsolverStatistics_ = value;
2310 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2311 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2312 public bool HasLogSubsolverStatistics {
2313 get {
return (_hasBits4 & 1048576) != 0; }
2316 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2317 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2318 public void ClearLogSubsolverStatistics() {
2319 _hasBits4 &= ~1048576;
2323 public const int LogPrefixFieldNumber = 185;
2324 private readonly
static string LogPrefixDefaultValue =
"";
2326 private string logPrefix_;
2330 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2331 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2333 get {
return logPrefix_ ?? LogPrefixDefaultValue; }
2335 logPrefix_ = pb::ProtoPreconditions.CheckNotNull(value,
"value");
2339 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2340 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2341 public bool HasLogPrefix {
2342 get {
return logPrefix_ !=
null; }
2345 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2346 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2352 public const int LogToStdoutFieldNumber = 186;
2353 private readonly
static bool LogToStdoutDefaultValue =
true;
2355 private bool logToStdout_;
2359 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2360 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2362 get {
if ((_hasBits4 & 131072) != 0) {
return logToStdout_; }
else {
return LogToStdoutDefaultValue; } }
2364 _hasBits4 |= 131072;
2365 logToStdout_ = value;
2369 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2370 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2371 public bool HasLogToStdout {
2372 get {
return (_hasBits4 & 131072) != 0; }
2375 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2376 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2377 public void ClearLogToStdout() {
2378 _hasBits4 &= ~131072;
2382 public const int LogToResponseFieldNumber = 187;
2383 private readonly
static bool LogToResponseDefaultValue =
false;
2385 private bool logToResponse_;
2389 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2390 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2392 get {
if ((_hasBits4 & 262144) != 0) {
return logToResponse_; }
else {
return LogToResponseDefaultValue; } }
2394 _hasBits4 |= 262144;
2395 logToResponse_ = value;
2399 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2400 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2401 public bool HasLogToResponse {
2402 get {
return (_hasBits4 & 262144) != 0; }
2405 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2406 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2407 public void ClearLogToResponse() {
2408 _hasBits4 &= ~262144;
2412 public const int UsePbResolutionFieldNumber = 43;
2413 private readonly
static bool UsePbResolutionDefaultValue =
false;
2415 private bool usePbResolution_;
2422 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2423 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2425 get {
if ((_hasBits0 & 2097152) != 0) {
return usePbResolution_; }
else {
return UsePbResolutionDefaultValue; } }
2427 _hasBits0 |= 2097152;
2428 usePbResolution_ = value;
2432 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2433 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2434 public bool HasUsePbResolution {
2435 get {
return (_hasBits0 & 2097152) != 0; }
2438 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2439 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2440 public void ClearUsePbResolution() {
2441 _hasBits0 &= ~2097152;
2445 public const int MinimizeReductionDuringPbResolutionFieldNumber = 48;
2446 private readonly
static bool MinimizeReductionDuringPbResolutionDefaultValue =
false;
2448 private bool minimizeReductionDuringPbResolution_;
2455 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2456 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2458 get {
if ((_hasBits0 & 67108864) != 0) {
return minimizeReductionDuringPbResolution_; }
else {
return MinimizeReductionDuringPbResolutionDefaultValue; } }
2460 _hasBits0 |= 67108864;
2461 minimizeReductionDuringPbResolution_ = value;
2465 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2466 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2467 public bool HasMinimizeReductionDuringPbResolution {
2468 get {
return (_hasBits0 & 67108864) != 0; }
2471 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2472 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2473 public void ClearMinimizeReductionDuringPbResolution() {
2474 _hasBits0 &= ~67108864;
2478 public const int CountAssumptionLevelsInLbdFieldNumber = 49;
2479 private readonly
static bool CountAssumptionLevelsInLbdDefaultValue =
true;
2481 private bool countAssumptionLevelsInLbd_;
2493 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2494 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2496 get {
if ((_hasBits0 & 134217728) != 0) {
return countAssumptionLevelsInLbd_; }
else {
return CountAssumptionLevelsInLbdDefaultValue; } }
2498 _hasBits0 |= 134217728;
2499 countAssumptionLevelsInLbd_ = value;
2503 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2504 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2505 public bool HasCountAssumptionLevelsInLbd {
2506 get {
return (_hasBits0 & 134217728) != 0; }
2509 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2510 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2512 _hasBits0 &= ~134217728;
2516 public const int PresolveBveThresholdFieldNumber = 54;
2517 private readonly
static int PresolveBveThresholdDefaultValue = 500;
2519 private int presolveBveThreshold_;
2525 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2526 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2528 get {
if ((_hasBits1 & 1) != 0) {
return presolveBveThreshold_; }
else {
return PresolveBveThresholdDefaultValue; } }
2531 presolveBveThreshold_ = value;
2535 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2536 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2537 public bool HasPresolveBveThreshold {
2538 get {
return (_hasBits1 & 1) != 0; }
2541 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2542 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2548 public const int FilterSatPostsolveClausesFieldNumber = 324;
2549 private readonly
static bool FilterSatPostsolveClausesDefaultValue =
false;
2551 private bool filterSatPostsolveClauses_;
2561 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2562 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2564 get {
if ((_hasBits8 & 512) != 0) {
return filterSatPostsolveClauses_; }
else {
return FilterSatPostsolveClausesDefaultValue; } }
2567 filterSatPostsolveClauses_ = value;
2571 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2572 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2573 public bool HasFilterSatPostsolveClauses {
2574 get {
return (_hasBits8 & 512) != 0; }
2577 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2578 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2584 public const int PresolveBveClauseWeightFieldNumber = 55;
2585 private readonly
static int PresolveBveClauseWeightDefaultValue = 3;
2587 private int presolveBveClauseWeight_;
2592 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2593 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2595 get {
if ((_hasBits1 & 2) != 0) {
return presolveBveClauseWeight_; }
else {
return PresolveBveClauseWeightDefaultValue; } }
2598 presolveBveClauseWeight_ = value;
2602 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2603 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2604 public bool HasPresolveBveClauseWeight {
2605 get {
return (_hasBits1 & 2) != 0; }
2608 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2609 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2615 public const int ProbingDeterministicTimeLimitFieldNumber = 226;
2616 private readonly
static double ProbingDeterministicTimeLimitDefaultValue = 1D;
2618 private double probingDeterministicTimeLimit_;
2626 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2627 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2629 get {
if ((_hasBits5 & 131072) != 0) {
return probingDeterministicTimeLimit_; }
else {
return ProbingDeterministicTimeLimitDefaultValue; } }
2631 _hasBits5 |= 131072;
2632 probingDeterministicTimeLimit_ = value;
2636 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2637 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2638 public bool HasProbingDeterministicTimeLimit {
2639 get {
return (_hasBits5 & 131072) != 0; }
2642 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2643 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2645 _hasBits5 &= ~131072;
2649 public const int PresolveProbingDeterministicTimeLimitFieldNumber = 57;
2650 private readonly
static double PresolveProbingDeterministicTimeLimitDefaultValue = 30D;
2652 private double presolveProbingDeterministicTimeLimit_;
2653 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2654 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2656 get {
if ((_hasBits1 & 8) != 0) {
return presolveProbingDeterministicTimeLimit_; }
else {
return PresolveProbingDeterministicTimeLimitDefaultValue; } }
2659 presolveProbingDeterministicTimeLimit_ = value;
2663 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2664 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2666 get {
return (_hasBits1 & 8) != 0; }
2669 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2670 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2676 public const int PresolveBlockedClauseFieldNumber = 88;
2677 private readonly
static bool PresolveBlockedClauseDefaultValue =
true;
2679 private bool presolveBlockedClause_;
2684 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2685 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2687 get {
if ((_hasBits1 & -2147483648) != 0) {
return presolveBlockedClause_; }
else {
return PresolveBlockedClauseDefaultValue; } }
2689 _hasBits1 |= -2147483648;
2690 presolveBlockedClause_ = value;
2694 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2695 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2696 public bool HasPresolveBlockedClause {
2697 get {
return (_hasBits1 & -2147483648) != 0; }
2700 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2701 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2703 _hasBits1 &= ~-2147483648;
2707 public const int PresolveUseBvaFieldNumber = 72;
2708 private readonly
static bool PresolveUseBvaDefaultValue =
true;
2710 private bool presolveUseBva_;
2714 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2715 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2717 get {
if ((_hasBits1 & 65536) != 0) {
return presolveUseBva_; }
else {
return PresolveUseBvaDefaultValue; } }
2720 presolveUseBva_ = value;
2724 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2725 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2726 public bool HasPresolveUseBva {
2727 get {
return (_hasBits1 & 65536) != 0; }
2730 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2731 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2733 _hasBits1 &= ~65536;
2737 public const int PresolveBvaThresholdFieldNumber = 73;
2738 private readonly
static int PresolveBvaThresholdDefaultValue = 1;
2740 private int presolveBvaThreshold_;
2747 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2748 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2750 get {
if ((_hasBits1 & 131072) != 0) {
return presolveBvaThreshold_; }
else {
return PresolveBvaThresholdDefaultValue; } }
2752 _hasBits1 |= 131072;
2753 presolveBvaThreshold_ = value;
2757 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2758 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2759 public bool HasPresolveBvaThreshold {
2760 get {
return (_hasBits1 & 131072) != 0; }
2763 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2764 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2766 _hasBits1 &= ~131072;
2770 public const int MaxPresolveIterationsFieldNumber = 138;
2771 private readonly
static int MaxPresolveIterationsDefaultValue = 3;
2773 private int maxPresolveIterations_;
2779 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2780 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2782 get {
if ((_hasBits3 & 2048) != 0) {
return maxPresolveIterations_; }
else {
return MaxPresolveIterationsDefaultValue; } }
2785 maxPresolveIterations_ = value;
2789 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2790 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2791 public bool HasMaxPresolveIterations {
2792 get {
return (_hasBits3 & 2048) != 0; }
2795 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2796 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2802 public const int CpModelPresolveFieldNumber = 86;
2803 private readonly
static bool CpModelPresolveDefaultValue =
true;
2805 private bool cpModelPresolve_;
2809 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2810 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2812 get {
if ((_hasBits1 & 536870912) != 0) {
return cpModelPresolve_; }
else {
return CpModelPresolveDefaultValue; } }
2814 _hasBits1 |= 536870912;
2815 cpModelPresolve_ = value;
2819 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2820 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2821 public bool HasCpModelPresolve {
2822 get {
return (_hasBits1 & 536870912) != 0; }
2825 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2826 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2828 _hasBits1 &= ~536870912;
2832 public const int CpModelProbingLevelFieldNumber = 110;
2833 private readonly
static int CpModelProbingLevelDefaultValue = 2;
2835 private int cpModelProbingLevel_;
2839 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2840 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2842 get {
if ((_hasBits2 & 131072) != 0) {
return cpModelProbingLevel_; }
else {
return CpModelProbingLevelDefaultValue; } }
2844 _hasBits2 |= 131072;
2845 cpModelProbingLevel_ = value;
2849 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2850 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2851 public bool HasCpModelProbingLevel {
2852 get {
return (_hasBits2 & 131072) != 0; }
2855 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2856 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2858 _hasBits2 &= ~131072;
2862 public const int CpModelUseSatPresolveFieldNumber = 93;
2863 private readonly
static bool CpModelUseSatPresolveDefaultValue =
true;
2865 private bool cpModelUseSatPresolve_;
2869 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2870 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2872 get {
if ((_hasBits2 & 16) != 0) {
return cpModelUseSatPresolve_; }
else {
return CpModelUseSatPresolveDefaultValue; } }
2875 cpModelUseSatPresolve_ = value;
2879 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2880 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2881 public bool HasCpModelUseSatPresolve {
2882 get {
return (_hasBits2 & 16) != 0; }
2885 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2886 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2892 public const int RemoveFixedVariablesEarlyFieldNumber = 310;
2893 private readonly
static bool RemoveFixedVariablesEarlyDefaultValue =
true;
2895 private bool removeFixedVariablesEarly_;
2902 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2903 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2905 get {
if ((_hasBits7 & 268435456) != 0) {
return removeFixedVariablesEarly_; }
else {
return RemoveFixedVariablesEarlyDefaultValue; } }
2907 _hasBits7 |= 268435456;
2908 removeFixedVariablesEarly_ = value;
2912 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2913 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2914 public bool HasRemoveFixedVariablesEarly {
2915 get {
return (_hasBits7 & 268435456) != 0; }
2918 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2919 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2921 _hasBits7 &= ~268435456;
2925 public const int DetectTableWithCostFieldNumber = 216;
2926 private readonly
static bool DetectTableWithCostDefaultValue =
false;
2928 private bool detectTableWithCost_;
2937 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2938 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2940 get {
if ((_hasBits5 & 512) != 0) {
return detectTableWithCost_; }
else {
return DetectTableWithCostDefaultValue; } }
2943 detectTableWithCost_ = value;
2947 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2948 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2949 public bool HasDetectTableWithCost {
2950 get {
return (_hasBits5 & 512) != 0; }
2953 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2954 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2960 public const int TableCompressionLevelFieldNumber = 217;
2961 private readonly
static int TableCompressionLevelDefaultValue = 2;
2963 private int tableCompressionLevel_;
2970 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2971 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2973 get {
if ((_hasBits5 & 1024) != 0) {
return tableCompressionLevel_; }
else {
return TableCompressionLevelDefaultValue; } }
2976 tableCompressionLevel_ = value;
2980 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2981 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2982 public bool HasTableCompressionLevel {
2983 get {
return (_hasBits5 & 1024) != 0; }
2986 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
2987 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
2993 public const int ExpandAlldiffConstraintsFieldNumber = 170;
2994 private readonly
static bool ExpandAlldiffConstraintsDefaultValue =
false;
2996 private bool expandAlldiffConstraints_;
3001 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3002 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3004 get {
if ((_hasBits4 & 16) != 0) {
return expandAlldiffConstraints_; }
else {
return ExpandAlldiffConstraintsDefaultValue; } }
3007 expandAlldiffConstraints_ = value;
3011 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3012 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3013 public bool HasExpandAlldiffConstraints {
3014 get {
return (_hasBits4 & 16) != 0; }
3017 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3018 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3024 public const int MaxAlldiffDomainSizeFieldNumber = 320;
3025 private readonly
static int MaxAlldiffDomainSizeDefaultValue = 256;
3027 private int maxAlldiffDomainSize_;
3031 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3032 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3034 get {
if ((_hasBits8 & 32) != 0) {
return maxAlldiffDomainSize_; }
else {
return MaxAlldiffDomainSizeDefaultValue; } }
3037 maxAlldiffDomainSize_ = value;
3041 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3042 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3043 public bool HasMaxAlldiffDomainSize {
3044 get {
return (_hasBits8 & 32) != 0; }
3047 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3048 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3054 public const int ExpandReservoirConstraintsFieldNumber = 182;
3055 private readonly
static bool ExpandReservoirConstraintsDefaultValue =
true;
3057 private bool expandReservoirConstraints_;
3062 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3063 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3065 get {
if ((_hasBits4 & 32768) != 0) {
return expandReservoirConstraints_; }
else {
return ExpandReservoirConstraintsDefaultValue; } }
3068 expandReservoirConstraints_ = value;
3072 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3073 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3074 public bool HasExpandReservoirConstraints {
3075 get {
return (_hasBits4 & 32768) != 0; }
3078 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3079 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3081 _hasBits4 &= ~32768;
3085 public const int ExpandReservoirUsingCircuitFieldNumber = 288;
3086 private readonly
static bool ExpandReservoirUsingCircuitDefaultValue =
false;
3088 private bool expandReservoirUsingCircuit_;
3105 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3106 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3108 get {
if ((_hasBits7 & 128) != 0) {
return expandReservoirUsingCircuit_; }
else {
return ExpandReservoirUsingCircuitDefaultValue; } }
3111 expandReservoirUsingCircuit_ = value;
3115 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3116 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3117 public bool HasExpandReservoirUsingCircuit {
3118 get {
return (_hasBits7 & 128) != 0; }
3121 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3122 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3123 public void ClearExpandReservoirUsingCircuit() {
3128 public const int EncodeCumulativeAsReservoirFieldNumber = 287;
3129 private readonly
static bool EncodeCumulativeAsReservoirDefaultValue =
false;
3131 private bool encodeCumulativeAsReservoir_;
3137 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3138 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3140 get {
if ((_hasBits7 & 64) != 0) {
return encodeCumulativeAsReservoir_; }
else {
return EncodeCumulativeAsReservoirDefaultValue; } }
3143 encodeCumulativeAsReservoir_ = value;
3147 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3148 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3149 public bool HasEncodeCumulativeAsReservoir {
3150 get {
return (_hasBits7 & 64) != 0; }
3153 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3154 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3155 public void ClearEncodeCumulativeAsReservoir() {
3160 public const int MaxLinMaxSizeForExpansionFieldNumber = 280;
3161 private readonly
static int MaxLinMaxSizeForExpansionDefaultValue = 0;
3163 private int maxLinMaxSizeForExpansion_;
3171 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3172 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3174 get {
if ((_hasBits6 & -2147483648) != 0) {
return maxLinMaxSizeForExpansion_; }
else {
return MaxLinMaxSizeForExpansionDefaultValue; } }
3176 _hasBits6 |= -2147483648;
3177 maxLinMaxSizeForExpansion_ = value;
3181 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3182 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3183 public bool HasMaxLinMaxSizeForExpansion {
3184 get {
return (_hasBits6 & -2147483648) != 0; }
3187 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3188 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3189 public void ClearMaxLinMaxSizeForExpansion() {
3190 _hasBits6 &= ~-2147483648;
3194 public const int DisableConstraintExpansionFieldNumber = 181;
3195 private readonly
static bool DisableConstraintExpansionDefaultValue =
false;
3197 private bool disableConstraintExpansion_;
3202 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3203 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3205 get {
if ((_hasBits4 & 16384) != 0) {
return disableConstraintExpansion_; }
else {
return DisableConstraintExpansionDefaultValue; } }
3208 disableConstraintExpansion_ = value;
3212 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3213 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3215 get {
return (_hasBits4 & 16384) != 0; }
3218 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3219 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3220 public void ClearDisableConstraintExpansion() {
3221 _hasBits4 &= ~16384;
3225 public const int EncodeComplexLinearConstraintWithIntegerFieldNumber = 223;
3226 private readonly
static bool EncodeComplexLinearConstraintWithIntegerDefaultValue =
false;
3228 private bool encodeComplexLinearConstraintWithInteger_;
3233 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3234 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3236 get {
if ((_hasBits5 & 16384) != 0) {
return encodeComplexLinearConstraintWithInteger_; }
else {
return EncodeComplexLinearConstraintWithIntegerDefaultValue; } }
3239 encodeComplexLinearConstraintWithInteger_ = value;
3243 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3244 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3246 get {
return (_hasBits5 & 16384) != 0; }
3249 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3250 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3251 public void ClearEncodeComplexLinearConstraintWithInteger() {
3252 _hasBits5 &= ~16384;
3256 public const int MergeNoOverlapWorkLimitFieldNumber = 145;
3257 private readonly
static double MergeNoOverlapWorkLimitDefaultValue = 1e+12D;
3259 private double mergeNoOverlapWorkLimit_;
3267 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3268 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3270 get {
if ((_hasBits3 & 8192) != 0) {
return mergeNoOverlapWorkLimit_; }
else {
return MergeNoOverlapWorkLimitDefaultValue; } }
3273 mergeNoOverlapWorkLimit_ = value;
3277 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3278 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3279 public bool HasMergeNoOverlapWorkLimit {
3280 get {
return (_hasBits3 & 8192) != 0; }
3283 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3284 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3285 public void ClearMergeNoOverlapWorkLimit() {
3290 public const int MergeAtMostOneWorkLimitFieldNumber = 146;
3291 private readonly
static double MergeAtMostOneWorkLimitDefaultValue = 1e+08D;
3293 private double mergeAtMostOneWorkLimit_;
3294 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3295 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3296 public double MergeAtMostOneWorkLimit {
3297 get {
if ((_hasBits3 & 16384) != 0) {
return mergeAtMostOneWorkLimit_; }
else {
return MergeAtMostOneWorkLimitDefaultValue; } }
3300 mergeAtMostOneWorkLimit_ = value;
3304 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3305 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3307 get {
return (_hasBits3 & 16384) != 0; }
3310 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3311 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3312 public void ClearMergeAtMostOneWorkLimit() {
3313 _hasBits3 &= ~16384;
3317 public const int PresolveSubstitutionLevelFieldNumber = 147;
3318 private readonly
static int PresolveSubstitutionLevelDefaultValue = 1;
3320 private int presolveSubstitutionLevel_;
3327 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3328 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3330 get {
if ((_hasBits3 & 32768) != 0) {
return presolveSubstitutionLevel_; }
else {
return PresolveSubstitutionLevelDefaultValue; } }
3333 presolveSubstitutionLevel_ = value;
3337 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3338 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3339 public bool HasPresolveSubstitutionLevel {
3340 get {
return (_hasBits3 & 32768) != 0; }
3343 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3344 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3345 public void ClearPresolveSubstitutionLevel() {
3346 _hasBits3 &= ~32768;
3350 public const int PresolveExtractIntegerEnforcementFieldNumber = 174;
3351 private readonly
static bool PresolveExtractIntegerEnforcementDefaultValue =
false;
3353 private bool presolveExtractIntegerEnforcement_;
3362 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3363 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3365 get {
if ((_hasBits4 & 128) != 0) {
return presolveExtractIntegerEnforcement_; }
else {
return PresolveExtractIntegerEnforcementDefaultValue; } }
3368 presolveExtractIntegerEnforcement_ = value;
3372 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3373 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3374 public bool HasPresolveExtractIntegerEnforcement {
3375 get {
return (_hasBits4 & 128) != 0; }
3378 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3379 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3380 public void ClearPresolveExtractIntegerEnforcement() {
3385 public const int PresolveInclusionWorkLimitFieldNumber = 201;
3386 private readonly
static long PresolveInclusionWorkLimitDefaultValue = 100000000L;
3388 private long presolveInclusionWorkLimit_;
3398 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3399 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3401 get {
if ((_hasBits5 & 1) != 0) {
return presolveInclusionWorkLimit_; }
else {
return PresolveInclusionWorkLimitDefaultValue; } }
3404 presolveInclusionWorkLimit_ = value;
3408 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3409 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3410 public bool HasPresolveInclusionWorkLimit {
3411 get {
return (_hasBits5 & 1) != 0; }
3414 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3415 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3416 public void ClearPresolveInclusionWorkLimit() {
3422 private readonly
static bool IgnoreNamesDefaultValue =
true;
3424 private bool ignoreNames_;
3428 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3429 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3431 get {
if ((_hasBits5 & 2) != 0) {
return ignoreNames_; }
else {
return IgnoreNamesDefaultValue; } }
3434 ignoreNames_ = value;
3438 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3439 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3441 get {
return (_hasBits5 & 2) != 0; }
3444 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3445 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3446 public void ClearIgnoreNames() {
3452 private readonly
static bool InferAllDiffsDefaultValue =
true;
3454 private bool inferAllDiffs_;
3465 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3466 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3468 get {
if ((_hasBits5 & 8388608) != 0) {
return inferAllDiffs_; }
else {
return InferAllDiffsDefaultValue; } }
3470 _hasBits5 |= 8388608;
3471 inferAllDiffs_ = value;
3475 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3476 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3477 public bool HasInferAllDiffs {
3478 get {
return (_hasBits5 & 8388608) != 0; }
3481 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3482 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3483 public void ClearInferAllDiffs() {
3484 _hasBits5 &= ~8388608;
3489 private readonly
static bool FindBigLinearOverlapDefaultValue =
true;
3491 private bool findBigLinearOverlap_;
3498 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3499 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3501 get {
if ((_hasBits5 & 16777216) != 0) {
return findBigLinearOverlap_; }
else {
return FindBigLinearOverlapDefaultValue; } }
3503 _hasBits5 |= 16777216;
3504 findBigLinearOverlap_ = value;
3508 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3509 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3511 get {
return (_hasBits5 & 16777216) != 0; }
3514 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3515 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3516 public void ClearFindBigLinearOverlap() {
3517 _hasBits5 &= ~16777216;
3522 private readonly
static bool UseSatInprocessingDefaultValue =
true;
3524 private bool useSatInprocessing_;
3529 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3530 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3532 get {
if ((_hasBits3 & 536870912) != 0) {
return useSatInprocessing_; }
else {
return UseSatInprocessingDefaultValue; } }
3534 _hasBits3 |= 536870912;
3535 useSatInprocessing_ = value;
3539 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3540 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3542 get {
return (_hasBits3 & 536870912) != 0; }
3545 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3546 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3547 public void ClearUseSatInprocessing() {
3548 _hasBits3 &= ~536870912;
3553 private readonly
static double InprocessingDtimeRatioDefaultValue = 0.2D;
3555 private double inprocessingDtimeRatio_;
3561 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3562 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3564 get {
if ((_hasBits6 & 16777216) != 0) {
return inprocessingDtimeRatio_; }
else {
return InprocessingDtimeRatioDefaultValue; } }
3566 _hasBits6 |= 16777216;
3567 inprocessingDtimeRatio_ = value;
3571 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3572 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3574 get {
return (_hasBits6 & 16777216) != 0; }
3577 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3578 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3579 public void ClearInprocessingDtimeRatio() {
3580 _hasBits6 &= ~16777216;
3585 private readonly
static double InprocessingProbingDtimeDefaultValue = 1D;
3587 private double inprocessingProbingDtime_;
3591 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3592 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3594 get {
if ((_hasBits6 & 33554432) != 0) {
return inprocessingProbingDtime_; }
else {
return InprocessingProbingDtimeDefaultValue; } }
3596 _hasBits6 |= 33554432;
3597 inprocessingProbingDtime_ = value;
3601 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3602 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3603 public bool HasInprocessingProbingDtime {
3604 get {
return (_hasBits6 & 33554432) != 0; }
3607 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3608 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3609 public void ClearInprocessingProbingDtime() {
3610 _hasBits6 &= ~33554432;
3615 private readonly
static double InprocessingMinimizationDtimeDefaultValue = 1D;
3617 private double inprocessingMinimizationDtime_;
3630 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3631 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3633 get {
if ((_hasBits6 & 67108864) != 0) {
return inprocessingMinimizationDtime_; }
else {
return InprocessingMinimizationDtimeDefaultValue; } }
3635 _hasBits6 |= 67108864;
3636 inprocessingMinimizationDtime_ = value;
3640 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3641 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3642 public bool HasInprocessingMinimizationDtime {
3643 get {
return (_hasBits6 & 67108864) != 0; }
3646 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3647 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3648 public void ClearInprocessingMinimizationDtime() {
3649 _hasBits6 &= ~67108864;
3653 public const int InprocessingMinimizationUseConflictAnalysisFieldNumber = 297;
3654 private readonly
static bool InprocessingMinimizationUseConflictAnalysisDefaultValue =
true;
3656 private bool inprocessingMinimizationUseConflictAnalysis_;
3657 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3658 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3660 get {
if ((_hasBits7 & 32768) != 0) {
return inprocessingMinimizationUseConflictAnalysis_; }
else {
return InprocessingMinimizationUseConflictAnalysisDefaultValue; } }
3663 inprocessingMinimizationUseConflictAnalysis_ = value;
3667 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3668 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3669 public bool HasInprocessingMinimizationUseConflictAnalysis {
3670 get {
return (_hasBits7 & 32768) != 0; }
3673 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3674 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3676 _hasBits7 &= ~32768;
3680 public const int InprocessingMinimizationUseAllOrderingsFieldNumber = 298;
3681 private readonly
static bool InprocessingMinimizationUseAllOrderingsDefaultValue =
false;
3683 private bool inprocessingMinimizationUseAllOrderings_;
3684 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3685 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3687 get {
if ((_hasBits7 & 65536) != 0) {
return inprocessingMinimizationUseAllOrderings_; }
else {
return InprocessingMinimizationUseAllOrderingsDefaultValue; } }
3690 inprocessingMinimizationUseAllOrderings_ = value;
3694 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3695 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3696 public bool HasInprocessingMinimizationUseAllOrderings {
3697 get {
return (_hasBits7 & 65536) != 0; }
3700 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3701 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3703 _hasBits7 &= ~65536;
3707 public const int NumWorkersFieldNumber = 206;
3708 private readonly
static int NumWorkersDefaultValue = 0;
3710 private int numWorkers_;
3727 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3728 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3730 get {
if ((_hasBits5 & 32) != 0) {
return numWorkers_; }
else {
return NumWorkersDefaultValue; } }
3733 numWorkers_ = value;
3737 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3738 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3739 public bool HasNumWorkers {
3740 get {
return (_hasBits5 & 32) != 0; }
3743 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3744 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3745 public void ClearNumWorkers() {
3750 public const int NumSearchWorkersFieldNumber = 100;
3751 private readonly
static int NumSearchWorkersDefaultValue = 0;
3753 private int numSearchWorkers_;
3754 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3755 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3757 get {
if ((_hasBits2 & 512) != 0) {
return numSearchWorkers_; }
else {
return NumSearchWorkersDefaultValue; } }
3760 numSearchWorkers_ = value;
3764 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3765 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3767 get {
return (_hasBits2 & 512) != 0; }
3770 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3771 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3778 private readonly
static int NumFullSubsolversDefaultValue = 0;
3780 private int numFullSubsolvers_;
3788 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3789 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3791 get {
if ((_hasBits7 & 4096) != 0) {
return numFullSubsolvers_; }
else {
return NumFullSubsolversDefaultValue; } }
3794 numFullSubsolvers_ = value;
3798 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3799 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3801 get {
return (_hasBits7 & 4096) != 0; }
3804 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3805 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3806 public void ClearNumFullSubsolvers() {
3811 public const int SubsolversFieldNumber = 207;
3812 private static readonly pb::FieldCodec<string> _repeated_subsolvers_codec
3813 = pb::FieldCodec.ForString(1658);
3814 private readonly pbc::RepeatedField<string> subsolvers_ =
new pbc::RepeatedField<string>();
3842 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3843 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3844 public pbc::RepeatedField<string>
Subsolvers {
3845 get {
return subsolvers_; }
3849 public const int ExtraSubsolversFieldNumber = 219;
3850 private static readonly pb::FieldCodec<string> _repeated_extraSubsolvers_codec
3851 = pb::FieldCodec.ForString(1754);
3852 private readonly pbc::RepeatedField<string> extraSubsolvers_ =
new pbc::RepeatedField<string>();
3857 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3858 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3859 public pbc::RepeatedField<string> ExtraSubsolvers {
3860 get {
return extraSubsolvers_; }
3864 public const int IgnoreSubsolversFieldNumber = 209;
3865 private static readonly pb::FieldCodec<string> _repeated_ignoreSubsolvers_codec
3866 = pb::FieldCodec.ForString(1674);
3867 private readonly pbc::RepeatedField<string> ignoreSubsolvers_ =
new pbc::RepeatedField<string>();
3879 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3880 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3882 get {
return ignoreSubsolvers_; }
3886 public const int FilterSubsolversFieldNumber = 293;
3887 private static readonly pb::FieldCodec<string> _repeated_filterSubsolvers_codec
3888 = pb::FieldCodec.ForString(2346);
3889 private readonly pbc::RepeatedField<string> filterSubsolvers_ =
new pbc::RepeatedField<string>();
3890 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3891 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3893 get {
return filterSubsolvers_; }
3897 public const int SubsolverParamsFieldNumber = 210;
3898 private static readonly pb::FieldCodec<global::Google.OrTools.Sat.SatParameters> _repeated_subsolverParams_codec
3900 private readonly pbc::RepeatedField<global::Google.OrTools.Sat.SatParameters> subsolverParams_ =
new pbc::RepeatedField<global::Google.OrTools.Sat.SatParameters>();
3908 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3909 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3911 get {
return subsolverParams_; }
3916 private readonly
static bool InterleaveSearchDefaultValue =
false;
3918 private bool interleaveSearch_;
3927 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3928 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3930 get {
if ((_hasBits3 & 512) != 0) {
return interleaveSearch_; }
else {
return InterleaveSearchDefaultValue; } }
3933 interleaveSearch_ = value;
3937 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3938 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3940 get {
return (_hasBits3 & 512) != 0; }
3943 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3944 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3950 public const int InterleaveBatchSizeFieldNumber = 134;
3951 private readonly
static int InterleaveBatchSizeDefaultValue = 0;
3953 private int interleaveBatchSize_;
3954 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3955 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3956 public int InterleaveBatchSize {
3957 get {
if ((_hasBits3 & 128) != 0) {
return interleaveBatchSize_; }
else {
return InterleaveBatchSizeDefaultValue; } }
3960 interleaveBatchSize_ = value;
3964 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3965 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3966 public bool HasInterleaveBatchSize {
3967 get {
return (_hasBits3 & 128) != 0; }
3970 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3971 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3978 private readonly
static bool ShareObjectiveBoundsDefaultValue =
true;
3980 private bool shareObjectiveBounds_;
3984 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3985 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3987 get {
if ((_hasBits2 & 524288) != 0) {
return shareObjectiveBounds_; }
else {
return ShareObjectiveBoundsDefaultValue; } }
3989 _hasBits2 |= 524288;
3990 shareObjectiveBounds_ = value;
3994 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
3995 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
3997 get {
return (_hasBits2 & 524288) != 0; }
4000 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4001 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4003 _hasBits2 &= ~524288;
4008 private readonly
static bool ShareLevelZeroBoundsDefaultValue =
true;
4010 private bool shareLevelZeroBounds_;
4014 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4015 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4017 get {
if ((_hasBits2 & 1048576) != 0) {
return shareLevelZeroBounds_; }
else {
return ShareLevelZeroBoundsDefaultValue; } }
4019 _hasBits2 |= 1048576;
4020 shareLevelZeroBounds_ = value;
4024 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4025 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4027 get {
return (_hasBits2 & 1048576) != 0; }
4030 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4031 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4033 _hasBits2 &= ~1048576;
4038 private readonly
static bool ShareBinaryClausesDefaultValue =
true;
4040 private bool shareBinaryClauses_;
4044 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4045 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4047 get {
if ((_hasBits5 & 4) != 0) {
return shareBinaryClauses_; }
else {
return ShareBinaryClausesDefaultValue; } }
4050 shareBinaryClauses_ = value;
4054 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4055 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4057 get {
return (_hasBits5 & 4) != 0; }
4060 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4061 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4068 private readonly
static bool ShareGlueClausesDefaultValue =
false;
4070 private bool shareGlueClauses_;
4075 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4076 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4078 get {
if ((_hasBits7 & 16) != 0) {
return shareGlueClauses_; }
else {
return ShareGlueClausesDefaultValue; } }
4081 shareGlueClauses_ = value;
4085 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4086 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4088 get {
return (_hasBits7 & 16) != 0; }
4091 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4092 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4099 private readonly
static bool MinimizeSharedClausesDefaultValue =
true;
4101 private bool minimizeSharedClauses_;
4106 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4107 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4109 get {
if ((_hasBits7 & 262144) != 0) {
return minimizeSharedClauses_; }
else {
return MinimizeSharedClausesDefaultValue; } }
4111 _hasBits7 |= 262144;
4112 minimizeSharedClauses_ = value;
4116 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4117 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4119 get {
return (_hasBits7 & 262144) != 0; }
4122 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4123 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4125 _hasBits7 &= ~262144;
4130 private readonly
static double ShareGlueClausesDtimeDefaultValue = 1D;
4132 private double shareGlueClausesDtime_;
4136 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4137 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4139 get {
if ((_hasBits8 & 128) != 0) {
return shareGlueClausesDtime_; }
else {
return ShareGlueClausesDtimeDefaultValue; } }
4142 shareGlueClausesDtime_ = value;
4146 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4147 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4149 get {
return (_hasBits8 & 128) != 0; }
4152 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4153 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4160 private readonly
static bool DebugPostsolveWithFullSolverDefaultValue =
false;
4162 private bool debugPostsolveWithFullSolver_;
4168 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4169 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4171 get {
if ((_hasBits3 & 268435456) != 0) {
return debugPostsolveWithFullSolver_; }
else {
return DebugPostsolveWithFullSolverDefaultValue; } }
4173 _hasBits3 |= 268435456;
4174 debugPostsolveWithFullSolver_ = value;
4178 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4179 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4181 get {
return (_hasBits3 & 268435456) != 0; }
4184 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4185 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4187 _hasBits3 &= ~268435456;
4192 private readonly
static int DebugMaxNumPresolveOperationsDefaultValue = 0;
4194 private int debugMaxNumPresolveOperations_;
4199 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4200 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4202 get {
if ((_hasBits3 & 262144) != 0) {
return debugMaxNumPresolveOperations_; }
else {
return DebugMaxNumPresolveOperationsDefaultValue; } }
4204 _hasBits3 |= 262144;
4205 debugMaxNumPresolveOperations_ = value;
4209 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4210 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4212 get {
return (_hasBits3 & 262144) != 0; }
4215 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4216 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4218 _hasBits3 &= ~262144;
4223 private readonly
static bool DebugCrashOnBadHintDefaultValue =
false;
4225 private bool debugCrashOnBadHint_;
4229 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4230 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4232 get {
if ((_hasBits4 & 67108864) != 0) {
return debugCrashOnBadHint_; }
else {
return DebugCrashOnBadHintDefaultValue; } }
4234 _hasBits4 |= 67108864;
4235 debugCrashOnBadHint_ = value;
4239 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4240 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4242 get {
return (_hasBits4 & 67108864) != 0; }
4245 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4246 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4248 _hasBits4 &= ~67108864;
4253 private readonly
static bool DebugCrashIfPresolveBreaksHintDefaultValue =
false;
4255 private bool debugCrashIfPresolveBreaksHint_;
4259 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4260 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4262 get {
if ((_hasBits7 & 16777216) != 0) {
return debugCrashIfPresolveBreaksHint_; }
else {
return DebugCrashIfPresolveBreaksHintDefaultValue; } }
4264 _hasBits7 |= 16777216;
4265 debugCrashIfPresolveBreaksHint_ = value;
4269 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4270 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4272 get {
return (_hasBits7 & 16777216) != 0; }
4275 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4276 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4278 _hasBits7 &= ~16777216;
4283 private readonly
static bool UseOptimizationHintsDefaultValue =
true;
4285 private bool useOptimizationHints_;
4292 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4293 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4295 get {
if ((_hasBits0 & 65536) != 0) {
return useOptimizationHints_; }
else {
return UseOptimizationHintsDefaultValue; } }
4298 useOptimizationHints_ = value;
4302 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4303 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4305 get {
return (_hasBits0 & 65536) != 0; }
4308 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4309 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4311 _hasBits0 &= ~65536;
4315 public const int CoreMinimizationLevelFieldNumber = 50;
4316 private readonly
static int CoreMinimizationLevelDefaultValue = 2;
4318 private int coreMinimizationLevel_;
4325 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4326 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4328 get {
if ((_hasBits0 & 268435456) != 0) {
return coreMinimizationLevel_; }
else {
return CoreMinimizationLevelDefaultValue; } }
4330 _hasBits0 |= 268435456;
4331 coreMinimizationLevel_ = value;
4335 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4336 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4338 get {
return (_hasBits0 & 268435456) != 0; }
4341 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4342 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4344 _hasBits0 &= ~268435456;
4348 public const int FindMultipleCoresFieldNumber = 84;
4349 private readonly
static bool FindMultipleCoresDefaultValue =
true;
4351 private bool findMultipleCores_;
4356 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4357 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4359 get {
if ((_hasBits1 & 134217728) != 0) {
return findMultipleCores_; }
else {
return FindMultipleCoresDefaultValue; } }
4361 _hasBits1 |= 134217728;
4362 findMultipleCores_ = value;
4366 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4367 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4369 get {
return (_hasBits1 & 134217728) != 0; }
4372 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4373 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4375 _hasBits1 &= ~134217728;
4380 private readonly
static bool CoverOptimizationDefaultValue =
true;
4382 private bool coverOptimization_;
4388 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4389 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4391 get {
if ((_hasBits2 & 1) != 0) {
return coverOptimization_; }
else {
return CoverOptimizationDefaultValue; } }
4394 coverOptimization_ = value;
4398 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4399 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4401 get {
return (_hasBits2 & 1) != 0; }
4404 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4405 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4412 private readonly
static global::Google.OrTools.Sat.SatParameters.Types.MaxSatAssumptionOrder MaxSatAssumptionOrderDefaultValue = global::Google.OrTools.Sat.SatParameters.Types.MaxSatAssumptionOrder.DefaultAssumptionOrder;
4414 private global::Google.OrTools.Sat.SatParameters.Types.MaxSatAssumptionOrder maxSatAssumptionOrder_;
4415 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4416 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4418 get {
if ((_hasBits0 & 536870912) != 0) {
return maxSatAssumptionOrder_; }
else {
return MaxSatAssumptionOrderDefaultValue; } }
4420 _hasBits0 |= 536870912;
4421 maxSatAssumptionOrder_ = value;
4425 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4426 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4427 public bool HasMaxSatAssumptionOrder {
4428 get {
return (_hasBits0 & 536870912) != 0; }
4431 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4432 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4434 _hasBits0 &= ~536870912;
4439 private readonly
static bool MaxSatReverseAssumptionOrderDefaultValue =
false;
4441 private bool maxSatReverseAssumptionOrder_;
4446 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4447 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4449 get {
if ((_hasBits0 & 1073741824) != 0) {
return maxSatReverseAssumptionOrder_; }
else {
return MaxSatReverseAssumptionOrderDefaultValue; } }
4451 _hasBits0 |= 1073741824;
4452 maxSatReverseAssumptionOrder_ = value;
4456 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4457 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4459 get {
return (_hasBits0 & 1073741824) != 0; }
4462 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4463 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4465 _hasBits0 &= ~1073741824;
4470 private readonly
static global::Google.OrTools.Sat.SatParameters.Types.MaxSatStratificationAlgorithm MaxSatStratificationDefaultValue = global::Google.OrTools.Sat.SatParameters.Types.MaxSatStratificationAlgorithm.StratificationDescent;
4472 private global::Google.OrTools.Sat.SatParameters.Types.MaxSatStratificationAlgorithm maxSatStratification_;
4473 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4474 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4475 public global::Google.OrTools.Sat.SatParameters.Types.MaxSatStratificationAlgorithm
MaxSatStratification {
4476 get {
if ((_hasBits0 & -2147483648) != 0) {
return maxSatStratification_; }
else {
return MaxSatStratificationDefaultValue; } }
4478 _hasBits0 |= -2147483648;
4479 maxSatStratification_ = value;
4483 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4484 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4485 public bool HasMaxSatStratification {
4486 get {
return (_hasBits0 & -2147483648) != 0; }
4489 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4490 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4492 _hasBits0 &= ~-2147483648;
4497 private readonly
static double PropagationLoopDetectionFactorDefaultValue = 10D;
4499 private double propagationLoopDetectionFactor_;
4511 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4512 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4514 get {
if ((_hasBits5 & 4096) != 0) {
return propagationLoopDetectionFactor_; }
else {
return PropagationLoopDetectionFactorDefaultValue; } }
4517 propagationLoopDetectionFactor_ = value;
4521 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4522 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4524 get {
return (_hasBits5 & 4096) != 0; }
4527 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4528 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4534 public const int UsePrecedencesInDisjunctiveConstraintFieldNumber = 74;
4535 private readonly
static bool UsePrecedencesInDisjunctiveConstraintDefaultValue =
true;
4537 private bool usePrecedencesInDisjunctiveConstraint_;
4549 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4550 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4552 get {
if ((_hasBits1 & 262144) != 0) {
return usePrecedencesInDisjunctiveConstraint_; }
else {
return UsePrecedencesInDisjunctiveConstraintDefaultValue; } }
4554 _hasBits1 |= 262144;
4555 usePrecedencesInDisjunctiveConstraint_ = value;
4559 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4560 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4562 get {
return (_hasBits1 & 262144) != 0; }
4565 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4566 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4568 _hasBits1 &= ~262144;
4572 public const int MaxSizeToCreatePrecedenceLiteralsInDisjunctiveFieldNumber = 229;
4573 private readonly
static int MaxSizeToCreatePrecedenceLiteralsInDisjunctiveDefaultValue = 60;
4575 private int maxSizeToCreatePrecedenceLiteralsInDisjunctive_;
4583 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4584 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4586 get {
if ((_hasBits5 & 1048576) != 0) {
return maxSizeToCreatePrecedenceLiteralsInDisjunctive_; }
else {
return MaxSizeToCreatePrecedenceLiteralsInDisjunctiveDefaultValue; } }
4588 _hasBits5 |= 1048576;
4589 maxSizeToCreatePrecedenceLiteralsInDisjunctive_ = value;
4593 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4594 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4596 get {
return (_hasBits5 & 1048576) != 0; }
4599 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4600 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4602 _hasBits5 &= ~1048576;
4607 private readonly
static bool UseStrongPropagationInDisjunctiveDefaultValue =
false;
4609 private bool useStrongPropagationInDisjunctive_;
4613 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4614 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4616 get {
if ((_hasBits5 & 2097152) != 0) {
return useStrongPropagationInDisjunctive_; }
else {
return UseStrongPropagationInDisjunctiveDefaultValue; } }
4618 _hasBits5 |= 2097152;
4619 useStrongPropagationInDisjunctive_ = value;
4623 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4624 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4625 public bool HasUseStrongPropagationInDisjunctive {
4626 get {
return (_hasBits5 & 2097152) != 0; }
4629 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4630 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4631 public void ClearUseStrongPropagationInDisjunctive() {
4632 _hasBits5 &= ~2097152;
4636 public const int UseDynamicPrecedenceInDisjunctiveFieldNumber = 263;
4637 private readonly
static bool UseDynamicPrecedenceInDisjunctiveDefaultValue =
false;
4639 private bool useDynamicPrecedenceInDisjunctive_;
4648 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4649 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4651 get {
if ((_hasBits6 & 16384) != 0) {
return useDynamicPrecedenceInDisjunctive_; }
else {
return UseDynamicPrecedenceInDisjunctiveDefaultValue; } }
4654 useDynamicPrecedenceInDisjunctive_ = value;
4658 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4659 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4661 get {
return (_hasBits6 & 16384) != 0; }
4664 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4665 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4667 _hasBits6 &= ~16384;
4671 public const int UseDynamicPrecedenceInCumulativeFieldNumber = 268;
4672 private readonly
static bool UseDynamicPrecedenceInCumulativeDefaultValue =
false;
4674 private bool useDynamicPrecedenceInCumulative_;
4675 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4676 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4677 public bool UseDynamicPrecedenceInCumulative {
4678 get {
if ((_hasBits6 & 524288) != 0) {
return useDynamicPrecedenceInCumulative_; }
else {
return UseDynamicPrecedenceInCumulativeDefaultValue; } }
4680 _hasBits6 |= 524288;
4681 useDynamicPrecedenceInCumulative_ = value;
4685 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4686 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4687 public bool HasUseDynamicPrecedenceInCumulative {
4688 get {
return (_hasBits6 & 524288) != 0; }
4691 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4692 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4694 _hasBits6 &= ~524288;
4698 public const int UseOverloadCheckerInCumulativeFieldNumber = 78;
4699 private readonly
static bool UseOverloadCheckerInCumulativeDefaultValue =
false;
4701 private bool useOverloadCheckerInCumulative_;
4711 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4712 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4714 get {
if ((_hasBits1 & 4194304) != 0) {
return useOverloadCheckerInCumulative_; }
else {
return UseOverloadCheckerInCumulativeDefaultValue; } }
4716 _hasBits1 |= 4194304;
4717 useOverloadCheckerInCumulative_ = value;
4721 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4722 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4724 get {
return (_hasBits1 & 4194304) != 0; }
4727 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4728 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4730 _hasBits1 &= ~4194304;
4734 public const int UseConservativeScaleOverloadCheckerFieldNumber = 286;
4735 private readonly
static bool UseConservativeScaleOverloadCheckerDefaultValue =
false;
4737 private bool useConservativeScaleOverloadChecker_;
4747 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4748 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4750 get {
if ((_hasBits7 & 32) != 0) {
return useConservativeScaleOverloadChecker_; }
else {
return UseConservativeScaleOverloadCheckerDefaultValue; } }
4753 useConservativeScaleOverloadChecker_ = value;
4757 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4758 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4760 get {
return (_hasBits7 & 32) != 0; }
4763 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4764 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4771 private readonly
static bool UseTimetableEdgeFindingInCumulativeDefaultValue =
false;
4773 private bool useTimetableEdgeFindingInCumulative_;
4783 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4784 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4786 get {
if ((_hasBits1 & 8388608) != 0) {
return useTimetableEdgeFindingInCumulative_; }
else {
return UseTimetableEdgeFindingInCumulativeDefaultValue; } }
4788 _hasBits1 |= 8388608;
4789 useTimetableEdgeFindingInCumulative_ = value;
4793 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4794 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4796 get {
return (_hasBits1 & 8388608) != 0; }
4799 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4800 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4802 _hasBits1 &= ~8388608;
4807 private readonly
static int MaxNumIntervalsForTimetableEdgeFindingDefaultValue = 100;
4809 private int maxNumIntervalsForTimetableEdgeFinding_;
4814 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4815 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4817 get {
if ((_hasBits6 & 2048) != 0) {
return maxNumIntervalsForTimetableEdgeFinding_; }
else {
return MaxNumIntervalsForTimetableEdgeFindingDefaultValue; } }
4820 maxNumIntervalsForTimetableEdgeFinding_ = value;
4824 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4825 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4826 public bool HasMaxNumIntervalsForTimetableEdgeFinding {
4827 get {
return (_hasBits6 & 2048) != 0; }
4830 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4831 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4838 private readonly
static bool UseHardPrecedencesInCumulativeDefaultValue =
false;
4840 private bool useHardPrecedencesInCumulative_;
4849 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4850 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4852 get {
if ((_hasBits5 & 256) != 0) {
return useHardPrecedencesInCumulative_; }
else {
return UseHardPrecedencesInCumulativeDefaultValue; } }
4855 useHardPrecedencesInCumulative_ = value;
4859 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4860 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4861 public bool HasUseHardPrecedencesInCumulative {
4862 get {
return (_hasBits5 & 256) != 0; }
4865 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4866 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4867 public void ClearUseHardPrecedencesInCumulative() {
4872 public const int ExploitAllPrecedencesFieldNumber = 220;
4873 private readonly
static bool ExploitAllPrecedencesDefaultValue =
false;
4875 private bool exploitAllPrecedences_;
4876 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4877 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4879 get {
if ((_hasBits5 & 2048) != 0) {
return exploitAllPrecedences_; }
else {
return ExploitAllPrecedencesDefaultValue; } }
4882 exploitAllPrecedences_ = value;
4886 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4887 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4889 get {
return (_hasBits5 & 2048) != 0; }
4892 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4893 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4894 public void ClearExploitAllPrecedences() {
4900 private readonly
static bool UseDisjunctiveConstraintInCumulativeDefaultValue =
true;
4902 private bool useDisjunctiveConstraintInCumulative_;
4915 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4916 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4918 get {
if ((_hasBits1 & 16777216) != 0) {
return useDisjunctiveConstraintInCumulative_; }
else {
return UseDisjunctiveConstraintInCumulativeDefaultValue; } }
4920 _hasBits1 |= 16777216;
4921 useDisjunctiveConstraintInCumulative_ = value;
4925 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4926 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4928 get {
return (_hasBits1 & 16777216) != 0; }
4931 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4932 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4934 _hasBits1 &= ~16777216;
4939 private readonly
static int NoOverlap2DBooleanRelationsLimitDefaultValue = 10;
4941 private int noOverlap2DBooleanRelationsLimit_;
4957 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4958 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4960 get {
if ((_hasBits8 & 64) != 0) {
return noOverlap2DBooleanRelationsLimit_; }
else {
return NoOverlap2DBooleanRelationsLimitDefaultValue; } }
4963 noOverlap2DBooleanRelationsLimit_ = value;
4967 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4968 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4970 get {
return (_hasBits8 & 64) != 0; }
4973 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4974 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4980 public const int UseTimetablingInNoOverlap2DFieldNumber = 200;
4981 private readonly
static bool UseTimetablingInNoOverlap2DDefaultValue =
false;
4983 private bool useTimetablingInNoOverlap2D_;
4991 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
4992 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
4993 public bool UseTimetablingInNoOverlap2D {
4994 get {
if ((_hasBits4 & -2147483648) != 0) {
return useTimetablingInNoOverlap2D_; }
else {
return UseTimetablingInNoOverlap2DDefaultValue; } }
4996 _hasBits4 |= -2147483648;
4997 useTimetablingInNoOverlap2D_ = value;
5001 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5002 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5004 get {
return (_hasBits4 & -2147483648) != 0; }
5007 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5008 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5009 public void ClearUseTimetablingInNoOverlap2D() {
5010 _hasBits4 &= ~-2147483648;
5014 public const int UseEnergeticReasoningInNoOverlap2DFieldNumber = 213;
5015 private readonly
static bool UseEnergeticReasoningInNoOverlap2DDefaultValue =
false;
5017 private bool useEnergeticReasoningInNoOverlap2D_;
5023 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5024 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5026 get {
if ((_hasBits5 & 64) != 0) {
return useEnergeticReasoningInNoOverlap2D_; }
else {
return UseEnergeticReasoningInNoOverlap2DDefaultValue; } }
5029 useEnergeticReasoningInNoOverlap2D_ = value;
5033 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5034 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5036 get {
return (_hasBits5 & 64) != 0; }
5039 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5040 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5041 public void ClearUseEnergeticReasoningInNoOverlap2D() {
5047 private readonly
static bool UseAreaEnergeticReasoningInNoOverlap2DDefaultValue =
false;
5049 private bool useAreaEnergeticReasoningInNoOverlap2D_;
5055 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5056 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5058 get {
if ((_hasBits6 & 4194304) != 0) {
return useAreaEnergeticReasoningInNoOverlap2D_; }
else {
return UseAreaEnergeticReasoningInNoOverlap2DDefaultValue; } }
5060 _hasBits6 |= 4194304;
5061 useAreaEnergeticReasoningInNoOverlap2D_ = value;
5065 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5066 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5068 get {
return (_hasBits6 & 4194304) != 0; }
5071 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5072 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5073 public void ClearUseAreaEnergeticReasoningInNoOverlap2D() {
5074 _hasBits6 &= ~4194304;
5079 private readonly
static bool UseTryEdgeReasoningInNoOverlap2DDefaultValue =
false;
5081 private bool useTryEdgeReasoningInNoOverlap2D_;
5082 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5083 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5085 get {
if ((_hasBits7 & 131072) != 0) {
return useTryEdgeReasoningInNoOverlap2D_; }
else {
return UseTryEdgeReasoningInNoOverlap2DDefaultValue; } }
5087 _hasBits7 |= 131072;
5088 useTryEdgeReasoningInNoOverlap2D_ = value;
5092 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5093 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5094 public bool HasUseTryEdgeReasoningInNoOverlap2D {
5095 get {
return (_hasBits7 & 131072) != 0; }
5098 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5099 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5101 _hasBits7 &= ~131072;
5105 public const int MaxPairsPairwiseReasoningInNoOverlap2DFieldNumber = 276;
5106 private readonly
static int MaxPairsPairwiseReasoningInNoOverlap2DDefaultValue = 1250;
5108 private int maxPairsPairwiseReasoningInNoOverlap2D_;
5114 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5115 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5117 get {
if ((_hasBits6 & 134217728) != 0) {
return maxPairsPairwiseReasoningInNoOverlap2D_; }
else {
return MaxPairsPairwiseReasoningInNoOverlap2DDefaultValue; } }
5119 _hasBits6 |= 134217728;
5120 maxPairsPairwiseReasoningInNoOverlap2D_ = value;
5124 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5125 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5127 get {
return (_hasBits6 & 134217728) != 0; }
5130 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5131 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5132 public void ClearMaxPairsPairwiseReasoningInNoOverlap2D() {
5133 _hasBits6 &= ~134217728;
5138 private readonly
static int MaximumRegionsToSplitInDisconnectedNoOverlap2DDefaultValue = 0;
5140 private int maximumRegionsToSplitInDisconnectedNoOverlap2D_;
5153 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5154 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5156 get {
if ((_hasBits8 & 2) != 0) {
return maximumRegionsToSplitInDisconnectedNoOverlap2D_; }
else {
return MaximumRegionsToSplitInDisconnectedNoOverlap2DDefaultValue; } }
5159 maximumRegionsToSplitInDisconnectedNoOverlap2D_ = value;
5163 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5164 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5165 public bool HasMaximumRegionsToSplitInDisconnectedNoOverlap2D {
5166 get {
return (_hasBits8 & 2) != 0; }
5169 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5170 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5171 public void ClearMaximumRegionsToSplitInDisconnectedNoOverlap2D() {
5176 public const int UseLinear3ForNoOverlap2DPrecedencesFieldNumber = 323;
5177 private readonly
static bool UseLinear3ForNoOverlap2DPrecedencesDefaultValue =
true;
5179 private bool useLinear3ForNoOverlap2DPrecedences_;
5188 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5189 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5191 get {
if ((_hasBits8 & 256) != 0) {
return useLinear3ForNoOverlap2DPrecedences_; }
else {
return UseLinear3ForNoOverlap2DPrecedencesDefaultValue; } }
5194 useLinear3ForNoOverlap2DPrecedences_ = value;
5198 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5199 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5200 public bool HasUseLinear3ForNoOverlap2DPrecedences {
5201 get {
return (_hasBits8 & 256) != 0; }
5204 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5205 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5211 public const int UseDualSchedulingHeuristicsFieldNumber = 214;
5212 private readonly
static bool UseDualSchedulingHeuristicsDefaultValue =
true;
5214 private bool useDualSchedulingHeuristics_;
5220 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5221 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5223 get {
if ((_hasBits5 & 128) != 0) {
return useDualSchedulingHeuristics_; }
else {
return UseDualSchedulingHeuristicsDefaultValue; } }
5226 useDualSchedulingHeuristics_ = value;
5230 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5231 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5233 get {
return (_hasBits5 & 128) != 0; }
5236 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5237 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5238 public void ClearUseDualSchedulingHeuristics() {
5244 private readonly
static bool UseAllDifferentForCircuitDefaultValue =
false;
5246 private bool useAllDifferentForCircuit_;
5251 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5252 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5254 get {
if ((_hasBits7 & 536870912) != 0) {
return useAllDifferentForCircuit_; }
else {
return UseAllDifferentForCircuitDefaultValue; } }
5256 _hasBits7 |= 536870912;
5257 useAllDifferentForCircuit_ = value;
5261 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5262 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5264 get {
return (_hasBits7 & 536870912) != 0; }
5267 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5268 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5269 public void ClearUseAllDifferentForCircuit() {
5270 _hasBits7 &= ~536870912;
5275 private readonly
static int RoutingCutSubsetSizeForBinaryRelationBoundDefaultValue = 0;
5277 private int routingCutSubsetSizeForBinaryRelationBound_;
5288 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5289 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5291 get {
if ((_hasBits7 & 1073741824) != 0) {
return routingCutSubsetSizeForBinaryRelationBound_; }
else {
return RoutingCutSubsetSizeForBinaryRelationBoundDefaultValue; } }
5293 _hasBits7 |= 1073741824;
5294 routingCutSubsetSizeForBinaryRelationBound_ = value;
5298 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5299 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5300 public bool HasRoutingCutSubsetSizeForBinaryRelationBound {
5301 get {
return (_hasBits7 & 1073741824) != 0; }
5304 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5305 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5307 _hasBits7 &= ~1073741824;
5312 private readonly
static int RoutingCutSubsetSizeForTightBinaryRelationBoundDefaultValue = 0;
5314 private int routingCutSubsetSizeForTightBinaryRelationBound_;
5320 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5321 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5323 get {
if ((_hasBits7 & -2147483648) != 0) {
return routingCutSubsetSizeForTightBinaryRelationBound_; }
else {
return RoutingCutSubsetSizeForTightBinaryRelationBoundDefaultValue; } }
5325 _hasBits7 |= -2147483648;
5326 routingCutSubsetSizeForTightBinaryRelationBound_ = value;
5330 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5331 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5333 get {
return (_hasBits7 & -2147483648) != 0; }
5336 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5337 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5338 public void ClearRoutingCutSubsetSizeForTightBinaryRelationBound() {
5339 _hasBits7 &= ~-2147483648;
5344 private readonly
static int RoutingCutSubsetSizeForExactBinaryRelationBoundDefaultValue = 8;
5346 private int routingCutSubsetSizeForExactBinaryRelationBound_;
5352 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5353 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5355 get {
if ((_hasBits8 & 4) != 0) {
return routingCutSubsetSizeForExactBinaryRelationBound_; }
else {
return RoutingCutSubsetSizeForExactBinaryRelationBoundDefaultValue; } }
5358 routingCutSubsetSizeForExactBinaryRelationBound_ = value;
5362 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5363 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5365 get {
return (_hasBits8 & 4) != 0; }
5368 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5369 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5370 public void ClearRoutingCutSubsetSizeForExactBinaryRelationBound() {
5376 private readonly
static int RoutingCutSubsetSizeForShortestPathsBoundDefaultValue = 8;
5378 private int routingCutSubsetSizeForShortestPathsBound_;
5385 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5386 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5388 get {
if ((_hasBits8 & 16) != 0) {
return routingCutSubsetSizeForShortestPathsBound_; }
else {
return RoutingCutSubsetSizeForShortestPathsBoundDefaultValue; } }
5391 routingCutSubsetSizeForShortestPathsBound_ = value;
5395 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5396 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5398 get {
return (_hasBits8 & 16) != 0; }
5401 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5402 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5403 public void ClearRoutingCutSubsetSizeForShortestPathsBound() {
5408 public const int RoutingCutDpEffortFieldNumber = 314;
5409 private readonly
static double RoutingCutDpEffortDefaultValue = 1e+07D;
5411 private double routingCutDpEffort_;
5418 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5419 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5421 get {
if ((_hasBits8 & 1) != 0) {
return routingCutDpEffort_; }
else {
return RoutingCutDpEffortDefaultValue; } }
5424 routingCutDpEffort_ = value;
5428 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5429 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5431 get {
return (_hasBits8 & 1) != 0; }
5434 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5435 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5436 public void ClearRoutingCutDpEffort() {
5441 public const int RoutingCutMaxInfeasiblePathLengthFieldNumber = 317;
5442 private readonly
static int RoutingCutMaxInfeasiblePathLengthDefaultValue = 6;
5444 private int routingCutMaxInfeasiblePathLength_;
5449 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5450 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5452 get {
if ((_hasBits8 & 8) != 0) {
return routingCutMaxInfeasiblePathLength_; }
else {
return RoutingCutMaxInfeasiblePathLengthDefaultValue; } }
5455 routingCutMaxInfeasiblePathLength_ = value;
5459 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5460 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5462 get {
return (_hasBits8 & 8) != 0; }
5465 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5466 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5467 public void ClearRoutingCutMaxInfeasiblePathLength() {
5473 private readonly
static global::Google.OrTools.Sat.SatParameters.Types.SearchBranching SearchBranchingDefaultValue = global::Google.OrTools.Sat.SatParameters.Types.SearchBranching.AutomaticSearch;
5475 private global::Google.OrTools.Sat.SatParameters.Types.SearchBranching searchBranching_;
5476 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5477 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5478 public global::Google.OrTools.Sat.SatParameters.Types.SearchBranching
SearchBranching {
5479 get {
if ((_hasBits1 & 33554432) != 0) {
return searchBranching_; }
else {
return SearchBranchingDefaultValue; } }
5481 _hasBits1 |= 33554432;
5482 searchBranching_ = value;
5486 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5487 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5488 public bool HasSearchBranching {
5489 get {
return (_hasBits1 & 33554432) != 0; }
5492 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5493 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5495 _hasBits1 &= ~33554432;
5499 public const int HintConflictLimitFieldNumber = 153;
5500 private readonly
static int HintConflictLimitDefaultValue = 10;
5502 private int hintConflictLimit_;
5506 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5507 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5509 get {
if ((_hasBits3 & 1048576) != 0) {
return hintConflictLimit_; }
else {
return HintConflictLimitDefaultValue; } }
5511 _hasBits3 |= 1048576;
5512 hintConflictLimit_ = value;
5516 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5517 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5518 public bool HasHintConflictLimit {
5519 get {
return (_hasBits3 & 1048576) != 0; }
5522 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5523 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5524 public void ClearHintConflictLimit() {
5525 _hasBits3 &= ~1048576;
5530 private readonly
static bool RepairHintDefaultValue =
false;
5532 private bool repairHint_;
5539 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5540 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5542 get {
if ((_hasBits4 & 2) != 0) {
return repairHint_; }
else {
return RepairHintDefaultValue; } }
5545 repairHint_ = value;
5549 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5550 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5552 get {
return (_hasBits4 & 2) != 0; }
5555 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5556 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5557 public void ClearRepairHint() {
5562 public const int FixVariablesToTheirHintedValueFieldNumber = 192;
5563 private readonly
static bool FixVariablesToTheirHintedValueDefaultValue =
false;
5565 private bool fixVariablesToTheirHintedValue_;
5570 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5571 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5573 get {
if ((_hasBits4 & 8388608) != 0) {
return fixVariablesToTheirHintedValue_; }
else {
return FixVariablesToTheirHintedValueDefaultValue; } }
5575 _hasBits4 |= 8388608;
5576 fixVariablesToTheirHintedValue_ = value;
5580 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5581 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5583 get {
return (_hasBits4 & 8388608) != 0; }
5586 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5587 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5588 public void ClearFixVariablesToTheirHintedValue() {
5589 _hasBits4 &= ~8388608;
5594 private readonly
static bool UseProbingSearchDefaultValue =
false;
5596 private bool useProbingSearch_;
5602 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5603 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5605 get {
if ((_hasBits4 & 512) != 0) {
return useProbingSearch_; }
else {
return UseProbingSearchDefaultValue; } }
5608 useProbingSearch_ = value;
5612 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5613 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5615 get {
return (_hasBits4 & 512) != 0; }
5618 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5619 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5620 public void ClearUseProbingSearch() {
5626 private readonly
static bool UseExtendedProbingDefaultValue =
true;
5628 private bool useExtendedProbing_;
5632 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5633 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5635 get {
if ((_hasBits6 & 1048576) != 0) {
return useExtendedProbing_; }
else {
return UseExtendedProbingDefaultValue; } }
5637 _hasBits6 |= 1048576;
5638 useExtendedProbing_ = value;
5642 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5643 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5644 public bool HasUseExtendedProbing {
5645 get {
return (_hasBits6 & 1048576) != 0; }
5648 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5649 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5650 public void ClearUseExtendedProbing() {
5651 _hasBits6 &= ~1048576;
5656 private readonly
static int ProbingNumCombinationsLimitDefaultValue = 20000;
5658 private int probingNumCombinationsLimit_;
5662 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5663 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5665 get {
if ((_hasBits6 & 8388608) != 0) {
return probingNumCombinationsLimit_; }
else {
return ProbingNumCombinationsLimitDefaultValue; } }
5667 _hasBits6 |= 8388608;
5668 probingNumCombinationsLimit_ = value;
5672 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5673 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5674 public bool HasProbingNumCombinationsLimit {
5675 get {
return (_hasBits6 & 8388608) != 0; }
5678 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5679 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5680 public void ClearProbingNumCombinationsLimit() {
5681 _hasBits6 &= ~8388608;
5686 private readonly
static double ShavingDeterministicTimeInProbingSearchDefaultValue = 0.001D;
5688 private double shavingDeterministicTimeInProbingSearch_;
5694 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5695 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5697 get {
if ((_hasBits5 & 8) != 0) {
return shavingDeterministicTimeInProbingSearch_; }
else {
return ShavingDeterministicTimeInProbingSearchDefaultValue; } }
5700 shavingDeterministicTimeInProbingSearch_ = value;
5704 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5705 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5707 get {
return (_hasBits5 & 8) != 0; }
5710 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5711 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5712 public void ClearShavingDeterministicTimeInProbingSearch() {
5718 private readonly
static double ShavingSearchDeterministicTimeDefaultValue = 0.1D;
5720 private double shavingSearchDeterministicTime_;
5725 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5726 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5728 get {
if ((_hasBits5 & 16) != 0) {
return shavingSearchDeterministicTime_; }
else {
return ShavingSearchDeterministicTimeDefaultValue; } }
5731 shavingSearchDeterministicTime_ = value;
5735 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5736 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5738 get {
return (_hasBits5 & 16) != 0; }
5741 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5742 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5743 public void ClearShavingSearchDeterministicTime() {
5749 private readonly
static long ShavingSearchThresholdDefaultValue = 64L;
5751 private long shavingSearchThreshold_;
5758 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5759 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5761 get {
if ((_hasBits7 & 512) != 0) {
return shavingSearchThreshold_; }
else {
return ShavingSearchThresholdDefaultValue; } }
5764 shavingSearchThreshold_ = value;
5768 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5769 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5771 get {
return (_hasBits7 & 512) != 0; }
5774 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5775 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5776 public void ClearShavingSearchThreshold() {
5781 public const int UseObjectiveLbSearchFieldNumber = 228;
5782 private readonly
static bool UseObjectiveLbSearchDefaultValue =
false;
5784 private bool useObjectiveLbSearch_;
5789 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5790 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5792 get {
if ((_hasBits5 & 524288) != 0) {
return useObjectiveLbSearch_; }
else {
return UseObjectiveLbSearchDefaultValue; } }
5794 _hasBits5 |= 524288;
5795 useObjectiveLbSearch_ = value;
5799 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5800 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5802 get {
return (_hasBits5 & 524288) != 0; }
5805 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5806 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5807 public void ClearUseObjectiveLbSearch() {
5808 _hasBits5 &= ~524288;
5813 private readonly
static bool UseObjectiveShavingSearchDefaultValue =
false;
5815 private bool useObjectiveShavingSearch_;
5821 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5822 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5824 get {
if ((_hasBits6 & 32) != 0) {
return useObjectiveShavingSearch_; }
else {
return UseObjectiveShavingSearchDefaultValue; } }
5827 useObjectiveShavingSearch_ = value;
5831 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5832 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5834 get {
return (_hasBits6 & 32) != 0; }
5837 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5838 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5839 public void ClearUseObjectiveShavingSearch() {
5845 private readonly
static int VariablesShavingLevelDefaultValue = -1;
5847 private int variablesShavingLevel_;
5853 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5854 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5856 get {
if ((_hasBits7 & 256) != 0) {
return variablesShavingLevel_; }
else {
return VariablesShavingLevelDefaultValue; } }
5859 variablesShavingLevel_ = value;
5863 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5864 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5866 get {
return (_hasBits7 & 256) != 0; }
5869 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5870 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5871 public void ClearVariablesShavingLevel() {
5877 private readonly
static long PseudoCostReliabilityThresholdDefaultValue = 100L;
5879 private long pseudoCostReliabilityThreshold_;
5884 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5885 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5887 get {
if ((_hasBits2 & 268435456) != 0) {
return pseudoCostReliabilityThreshold_; }
else {
return PseudoCostReliabilityThresholdDefaultValue; } }
5889 _hasBits2 |= 268435456;
5890 pseudoCostReliabilityThreshold_ = value;
5894 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5895 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5897 get {
return (_hasBits2 & 268435456) != 0; }
5900 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5901 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5902 public void ClearPseudoCostReliabilityThreshold() {
5903 _hasBits2 &= ~268435456;
5908 private readonly
static bool OptimizeWithCoreDefaultValue =
false;
5910 private bool optimizeWithCore_;
5917 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5918 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5920 get {
if ((_hasBits1 & 67108864) != 0) {
return optimizeWithCore_; }
else {
return OptimizeWithCoreDefaultValue; } }
5922 _hasBits1 |= 67108864;
5923 optimizeWithCore_ = value;
5927 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5928 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5930 get {
return (_hasBits1 & 67108864) != 0; }
5933 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5934 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5935 public void ClearOptimizeWithCore() {
5936 _hasBits1 &= ~67108864;
5940 public const int OptimizeWithLbTreeSearchFieldNumber = 188;
5941 private readonly
static bool OptimizeWithLbTreeSearchDefaultValue =
false;
5943 private bool optimizeWithLbTreeSearch_;
5951 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5952 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5954 get {
if ((_hasBits4 & 524288) != 0) {
return optimizeWithLbTreeSearch_; }
else {
return OptimizeWithLbTreeSearchDefaultValue; } }
5956 _hasBits4 |= 524288;
5957 optimizeWithLbTreeSearch_ = value;
5961 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5962 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5964 get {
return (_hasBits4 & 524288) != 0; }
5967 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5968 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5969 public void ClearOptimizeWithLbTreeSearch() {
5970 _hasBits4 &= ~524288;
5974 public const int SaveLpBasisInLbTreeSearchFieldNumber = 284;
5975 private readonly
static bool SaveLpBasisInLbTreeSearchDefaultValue =
false;
5977 private bool saveLpBasisInLbTreeSearch_;
5986 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5987 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5989 get {
if ((_hasBits7 & 8) != 0) {
return saveLpBasisInLbTreeSearch_; }
else {
return SaveLpBasisInLbTreeSearchDefaultValue; } }
5992 saveLpBasisInLbTreeSearch_ = value;
5996 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
5997 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
5998 public bool HasSaveLpBasisInLbTreeSearch {
5999 get {
return (_hasBits7 & 8) != 0; }
6002 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6003 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6009 public const int BinarySearchNumConflictsFieldNumber = 99;
6010 private readonly
static int BinarySearchNumConflictsDefaultValue = -1;
6012 private int binarySearchNumConflicts_;
6019 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6020 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6022 get {
if ((_hasBits2 & 256) != 0) {
return binarySearchNumConflicts_; }
else {
return BinarySearchNumConflictsDefaultValue; } }
6025 binarySearchNumConflicts_ = value;
6029 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6030 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6032 get {
return (_hasBits2 & 256) != 0; }
6035 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6036 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6037 public void ClearBinarySearchNumConflicts() {
6043 private readonly
static bool OptimizeWithMaxHsDefaultValue =
false;
6045 private bool optimizeWithMaxHs_;
6054 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6055 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6057 get {
if ((_hasBits1 & 268435456) != 0) {
return optimizeWithMaxHs_; }
else {
return OptimizeWithMaxHsDefaultValue; } }
6059 _hasBits1 |= 268435456;
6060 optimizeWithMaxHs_ = value;
6064 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6065 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6067 get {
return (_hasBits1 & 268435456) != 0; }
6070 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6071 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6072 public void ClearOptimizeWithMaxHs() {
6073 _hasBits1 &= ~268435456;
6077 public const int UseFeasibilityJumpFieldNumber = 265;
6078 private readonly
static bool UseFeasibilityJumpDefaultValue =
true;
6080 private bool useFeasibilityJump_;
6086 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6087 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6089 get {
if ((_hasBits6 & 65536) != 0) {
return useFeasibilityJump_; }
else {
return UseFeasibilityJumpDefaultValue; } }
6092 useFeasibilityJump_ = value;
6096 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6097 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6099 get {
return (_hasBits6 & 65536) != 0; }
6102 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6103 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6104 public void ClearUseFeasibilityJump() {
6105 _hasBits6 &= ~65536;
6110 private readonly
static bool UseLsOnlyDefaultValue =
false;
6112 private bool useLsOnly_;
6117 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6118 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6120 get {
if ((_hasBits5 & 536870912) != 0) {
return useLsOnly_; }
else {
return UseLsOnlyDefaultValue; } }
6122 _hasBits5 |= 536870912;
6127 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6128 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6129 public bool HasUseLsOnly {
6130 get {
return (_hasBits5 & 536870912) != 0; }
6133 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6134 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6135 public void ClearUseLsOnly() {
6136 _hasBits5 &= ~536870912;
6141 private readonly
static double FeasibilityJumpDecayDefaultValue = 0.95D;
6143 private double feasibilityJumpDecay_;
6148 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6149 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6151 get {
if ((_hasBits5 & 1073741824) != 0) {
return feasibilityJumpDecay_; }
else {
return FeasibilityJumpDecayDefaultValue; } }
6153 _hasBits5 |= 1073741824;
6154 feasibilityJumpDecay_ = value;
6158 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6159 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6160 public bool HasFeasibilityJumpDecay {
6161 get {
return (_hasBits5 & 1073741824) != 0; }
6164 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6165 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6166 public void ClearFeasibilityJumpDecay() {
6167 _hasBits5 &= ~1073741824;
6172 private readonly
static int FeasibilityJumpLinearizationLevelDefaultValue = 2;
6174 private int feasibilityJumpLinearizationLevel_;
6178 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6179 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6181 get {
if ((_hasBits6 & 256) != 0) {
return feasibilityJumpLinearizationLevel_; }
else {
return FeasibilityJumpLinearizationLevelDefaultValue; } }
6184 feasibilityJumpLinearizationLevel_ = value;
6188 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6189 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6190 public bool HasFeasibilityJumpLinearizationLevel {
6191 get {
return (_hasBits6 & 256) != 0; }
6194 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6195 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6196 public void ClearFeasibilityJumpLinearizationLevel() {
6201 public const int FeasibilityJumpRestartFactorFieldNumber = 258;
6202 private readonly
static int FeasibilityJumpRestartFactorDefaultValue = 1;
6204 private int feasibilityJumpRestartFactor_;
6209 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6210 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6212 get {
if ((_hasBits6 & 512) != 0) {
return feasibilityJumpRestartFactor_; }
else {
return FeasibilityJumpRestartFactorDefaultValue; } }
6215 feasibilityJumpRestartFactor_ = value;
6219 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6220 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6221 public bool HasFeasibilityJumpRestartFactor {
6222 get {
return (_hasBits6 & 512) != 0; }
6225 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6226 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6227 public void ClearFeasibilityJumpRestartFactor() {
6233 private readonly
static double FeasibilityJumpBatchDtimeDefaultValue = 0.1D;
6235 private double feasibilityJumpBatchDtime_;
6239 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6240 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6242 get {
if ((_hasBits7 & 2048) != 0) {
return feasibilityJumpBatchDtime_; }
else {
return FeasibilityJumpBatchDtimeDefaultValue; } }
6245 feasibilityJumpBatchDtime_ = value;
6249 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6250 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6251 public bool HasFeasibilityJumpBatchDtime {
6252 get {
return (_hasBits7 & 2048) != 0; }
6255 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6256 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6257 public void ClearFeasibilityJumpBatchDtime() {
6262 public const int FeasibilityJumpVarRandomizationProbabilityFieldNumber = 247;
6263 private readonly
static double FeasibilityJumpVarRandomizationProbabilityDefaultValue = 0.05D;
6265 private double feasibilityJumpVarRandomizationProbability_;
6270 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6271 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6273 get {
if ((_hasBits6 & 1) != 0) {
return feasibilityJumpVarRandomizationProbability_; }
else {
return FeasibilityJumpVarRandomizationProbabilityDefaultValue; } }
6276 feasibilityJumpVarRandomizationProbability_ = value;
6280 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6281 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6282 public bool HasFeasibilityJumpVarRandomizationProbability {
6283 get {
return (_hasBits6 & 1) != 0; }
6286 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6287 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6288 public void ClearFeasibilityJumpVarRandomizationProbability() {
6294 private readonly
static double FeasibilityJumpVarPerburbationRangeRatioDefaultValue = 0.2D;
6296 private double feasibilityJumpVarPerburbationRangeRatio_;
6301 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6302 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6304 get {
if ((_hasBits6 & 2) != 0) {
return feasibilityJumpVarPerburbationRangeRatio_; }
else {
return FeasibilityJumpVarPerburbationRangeRatioDefaultValue; } }
6307 feasibilityJumpVarPerburbationRangeRatio_ = value;
6311 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6312 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6313 public bool HasFeasibilityJumpVarPerburbationRangeRatio {
6314 get {
return (_hasBits6 & 2) != 0; }
6317 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6318 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6319 public void ClearFeasibilityJumpVarPerburbationRangeRatio() {
6325 private readonly
static bool FeasibilityJumpEnableRestartsDefaultValue =
true;
6327 private bool feasibilityJumpEnableRestarts_;
6333 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6334 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6336 get {
if ((_hasBits6 & 8) != 0) {
return feasibilityJumpEnableRestarts_; }
else {
return FeasibilityJumpEnableRestartsDefaultValue; } }
6339 feasibilityJumpEnableRestarts_ = value;
6343 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6344 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6346 get {
return (_hasBits6 & 8) != 0; }
6349 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6350 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6351 public void ClearFeasibilityJumpEnableRestarts() {
6357 private readonly
static int FeasibilityJumpMaxExpandedConstraintSizeDefaultValue = 500;
6359 private int feasibilityJumpMaxExpandedConstraintSize_;
6366 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6367 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6369 get {
if ((_hasBits6 & 32768) != 0) {
return feasibilityJumpMaxExpandedConstraintSize_; }
else {
return FeasibilityJumpMaxExpandedConstraintSizeDefaultValue; } }
6372 feasibilityJumpMaxExpandedConstraintSize_ = value;
6376 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6377 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6379 get {
return (_hasBits6 & 32768) != 0; }
6382 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6383 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6384 public void ClearFeasibilityJumpMaxExpandedConstraintSize() {
6385 _hasBits6 &= ~32768;
6390 private readonly
static int NumViolationLsDefaultValue = 0;
6392 private int numViolationLs_;
6398 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6399 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6401 get {
if ((_hasBits5 & -2147483648) != 0) {
return numViolationLs_; }
else {
return NumViolationLsDefaultValue; } }
6403 _hasBits5 |= -2147483648;
6404 numViolationLs_ = value;
6408 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6409 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6411 get {
return (_hasBits5 & -2147483648) != 0; }
6414 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6415 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6416 public void ClearNumViolationLs() {
6417 _hasBits5 &= ~-2147483648;
6422 private readonly
static int ViolationLsPerturbationPeriodDefaultValue = 100;
6424 private int violationLsPerturbationPeriod_;
6428 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6429 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6431 get {
if ((_hasBits6 & 4) != 0) {
return violationLsPerturbationPeriod_; }
else {
return ViolationLsPerturbationPeriodDefaultValue; } }
6434 violationLsPerturbationPeriod_ = value;
6438 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6439 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6440 public bool HasViolationLsPerturbationPeriod {
6441 get {
return (_hasBits6 & 4) != 0; }
6444 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6445 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6446 public void ClearViolationLsPerturbationPeriod() {
6451 public const int ViolationLsCompoundMoveProbabilityFieldNumber = 259;
6452 private readonly
static double ViolationLsCompoundMoveProbabilityDefaultValue = 0.5D;
6454 private double violationLsCompoundMoveProbability_;
6459 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6460 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6462 get {
if ((_hasBits6 & 1024) != 0) {
return violationLsCompoundMoveProbability_; }
else {
return ViolationLsCompoundMoveProbabilityDefaultValue; } }
6465 violationLsCompoundMoveProbability_ = value;
6469 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6470 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6471 public bool HasViolationLsCompoundMoveProbability {
6472 get {
return (_hasBits6 & 1024) != 0; }
6475 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6476 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6477 public void ClearViolationLsCompoundMoveProbability() {
6483 private readonly
static int SharedTreeNumWorkersDefaultValue = 0;
6485 private int sharedTreeNumWorkers_;
6495 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6496 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6498 get {
if ((_hasBits5 & 33554432) != 0) {
return sharedTreeNumWorkers_; }
else {
return SharedTreeNumWorkersDefaultValue; } }
6500 _hasBits5 |= 33554432;
6501 sharedTreeNumWorkers_ = value;
6505 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6506 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6507 public bool HasSharedTreeNumWorkers {
6508 get {
return (_hasBits5 & 33554432) != 0; }
6511 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6512 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6514 _hasBits5 &= ~33554432;
6518 public const int UseSharedTreeSearchFieldNumber = 236;
6519 private readonly
static bool UseSharedTreeSearchDefaultValue =
false;
6521 private bool useSharedTreeSearch_;
6525 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6526 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6528 get {
if ((_hasBits5 & 67108864) != 0) {
return useSharedTreeSearch_; }
else {
return UseSharedTreeSearchDefaultValue; } }
6530 _hasBits5 |= 67108864;
6531 useSharedTreeSearch_ = value;
6535 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6536 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6537 public bool HasUseSharedTreeSearch {
6538 get {
return (_hasBits5 & 67108864) != 0; }
6541 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6542 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6543 public void ClearUseSharedTreeSearch() {
6544 _hasBits5 &= ~67108864;
6548 public const int SharedTreeWorkerMinRestartsPerSubtreeFieldNumber = 282;
6549 private readonly
static int SharedTreeWorkerMinRestartsPerSubtreeDefaultValue = 1;
6551 private int sharedTreeWorkerMinRestartsPerSubtree_;
6556 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6557 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6559 get {
if ((_hasBits7 & 2) != 0) {
return sharedTreeWorkerMinRestartsPerSubtree_; }
else {
return SharedTreeWorkerMinRestartsPerSubtreeDefaultValue; } }
6562 sharedTreeWorkerMinRestartsPerSubtree_ = value;
6566 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6567 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6568 public bool HasSharedTreeWorkerMinRestartsPerSubtree {
6569 get {
return (_hasBits7 & 2) != 0; }
6572 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6573 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6574 public void ClearSharedTreeWorkerMinRestartsPerSubtree() {
6580 private readonly
static bool SharedTreeWorkerEnableTrailSharingDefaultValue =
true;
6582 private bool sharedTreeWorkerEnableTrailSharing_;
6587 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6588 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6590 get {
if ((_hasBits7 & 8192) != 0) {
return sharedTreeWorkerEnableTrailSharing_; }
else {
return SharedTreeWorkerEnableTrailSharingDefaultValue; } }
6593 sharedTreeWorkerEnableTrailSharing_ = value;
6597 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6598 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6599 public bool HasSharedTreeWorkerEnableTrailSharing {
6600 get {
return (_hasBits7 & 8192) != 0; }
6603 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6604 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6605 public void ClearSharedTreeWorkerEnableTrailSharing() {
6611 private readonly
static bool SharedTreeWorkerEnablePhaseSharingDefaultValue =
true;
6613 private bool sharedTreeWorkerEnablePhaseSharing_;
6618 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6619 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6621 get {
if ((_hasBits7 & 4194304) != 0) {
return sharedTreeWorkerEnablePhaseSharing_; }
else {
return SharedTreeWorkerEnablePhaseSharingDefaultValue; } }
6623 _hasBits7 |= 4194304;
6624 sharedTreeWorkerEnablePhaseSharing_ = value;
6628 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6629 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6630 public bool HasSharedTreeWorkerEnablePhaseSharing {
6631 get {
return (_hasBits7 & 4194304) != 0; }
6634 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6635 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6636 public void ClearSharedTreeWorkerEnablePhaseSharing() {
6637 _hasBits7 &= ~4194304;
6642 private readonly
static double SharedTreeOpenLeavesPerWorkerDefaultValue = 2D;
6644 private double sharedTreeOpenLeavesPerWorker_;
6648 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6649 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6651 get {
if ((_hasBits7 & 1) != 0) {
return sharedTreeOpenLeavesPerWorker_; }
else {
return SharedTreeOpenLeavesPerWorkerDefaultValue; } }
6654 sharedTreeOpenLeavesPerWorker_ = value;
6658 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6659 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6660 public bool HasSharedTreeOpenLeavesPerWorker {
6661 get {
return (_hasBits7 & 1) != 0; }
6664 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6665 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6666 public void ClearSharedTreeOpenLeavesPerWorker() {
6671 public const int SharedTreeMaxNodesPerWorkerFieldNumber = 238;
6672 private readonly
static int SharedTreeMaxNodesPerWorkerDefaultValue = 10000;
6674 private int sharedTreeMaxNodesPerWorker_;
6681 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6682 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6684 get {
if ((_hasBits5 & 134217728) != 0) {
return sharedTreeMaxNodesPerWorker_; }
else {
return SharedTreeMaxNodesPerWorkerDefaultValue; } }
6686 _hasBits5 |= 134217728;
6687 sharedTreeMaxNodesPerWorker_ = value;
6691 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6692 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6694 get {
return (_hasBits5 & 134217728) != 0; }
6697 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6698 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6699 public void ClearSharedTreeMaxNodesPerWorker() {
6700 _hasBits5 &= ~134217728;
6705 private readonly
static global::Google.OrTools.Sat.SatParameters.Types.SharedTreeSplitStrategy SharedTreeSplitStrategyDefaultValue = global::Google.OrTools.Sat.SatParameters.Types.SharedTreeSplitStrategy.SplitStrategyAuto;
6707 private global::Google.OrTools.Sat.SatParameters.Types.SharedTreeSplitStrategy sharedTreeSplitStrategy_;
6708 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6709 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6711 get {
if ((_hasBits5 & 268435456) != 0) {
return sharedTreeSplitStrategy_; }
else {
return SharedTreeSplitStrategyDefaultValue; } }
6713 _hasBits5 |= 268435456;
6714 sharedTreeSplitStrategy_ = value;
6718 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6719 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6720 public bool HasSharedTreeSplitStrategy {
6721 get {
return (_hasBits5 & 268435456) != 0; }
6724 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6725 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6727 _hasBits5 &= ~268435456;
6731 public const int SharedTreeBalanceToleranceFieldNumber = 305;
6732 private readonly
static int SharedTreeBalanceToleranceDefaultValue = 1;
6734 private int sharedTreeBalanceTolerance_;
6744 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6745 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6747 get {
if ((_hasBits7 & 8388608) != 0) {
return sharedTreeBalanceTolerance_; }
else {
return SharedTreeBalanceToleranceDefaultValue; } }
6749 _hasBits7 |= 8388608;
6750 sharedTreeBalanceTolerance_ = value;
6754 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6755 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6756 public bool HasSharedTreeBalanceTolerance {
6757 get {
return (_hasBits7 & 8388608) != 0; }
6760 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6761 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6763 _hasBits7 &= ~8388608;
6767 public const int EnumerateAllSolutionsFieldNumber = 87;
6768 private readonly
static bool EnumerateAllSolutionsDefaultValue =
false;
6770 private bool enumerateAllSolutions_;
6780 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6781 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6783 get {
if ((_hasBits1 & 1073741824) != 0) {
return enumerateAllSolutions_; }
else {
return EnumerateAllSolutionsDefaultValue; } }
6785 _hasBits1 |= 1073741824;
6786 enumerateAllSolutions_ = value;
6790 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6791 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6792 public bool HasEnumerateAllSolutions {
6793 get {
return (_hasBits1 & 1073741824) != 0; }
6796 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6797 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6799 _hasBits1 &= ~1073741824;
6803 public const int KeepAllFeasibleSolutionsInPresolveFieldNumber = 173;
6804 private readonly
static bool KeepAllFeasibleSolutionsInPresolveDefaultValue =
false;
6806 private bool keepAllFeasibleSolutionsInPresolve_;
6817 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6818 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6820 get {
if ((_hasBits4 & 64) != 0) {
return keepAllFeasibleSolutionsInPresolve_; }
else {
return KeepAllFeasibleSolutionsInPresolveDefaultValue; } }
6823 keepAllFeasibleSolutionsInPresolve_ = value;
6827 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6828 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6829 public bool HasKeepAllFeasibleSolutionsInPresolve {
6830 get {
return (_hasBits4 & 64) != 0; }
6833 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6834 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6840 public const int FillTightenedDomainsInResponseFieldNumber = 132;
6841 private readonly
static bool FillTightenedDomainsInResponseDefaultValue =
false;
6843 private bool fillTightenedDomainsInResponse_;
6851 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6852 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6854 get {
if ((_hasBits3 & 32) != 0) {
return fillTightenedDomainsInResponse_; }
else {
return FillTightenedDomainsInResponseDefaultValue; } }
6857 fillTightenedDomainsInResponse_ = value;
6861 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6862 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6864 get {
return (_hasBits3 & 32) != 0; }
6867 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6868 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6869 public void ClearFillTightenedDomainsInResponse() {
6875 private readonly
static bool FillAdditionalSolutionsInResponseDefaultValue =
false;
6877 private bool fillAdditionalSolutionsInResponse_;
6890 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6891 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6893 get {
if ((_hasBits4 & 33554432) != 0) {
return fillAdditionalSolutionsInResponse_; }
else {
return FillAdditionalSolutionsInResponseDefaultValue; } }
6895 _hasBits4 |= 33554432;
6896 fillAdditionalSolutionsInResponse_ = value;
6900 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6901 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6902 public bool HasFillAdditionalSolutionsInResponse {
6903 get {
return (_hasBits4 & 33554432) != 0; }
6906 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6907 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6909 _hasBits4 &= ~33554432;
6914 private readonly
static bool InstantiateAllVariablesDefaultValue =
true;
6916 private bool instantiateAllVariables_;
6923 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6924 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6926 get {
if ((_hasBits2 & 8192) != 0) {
return instantiateAllVariables_; }
else {
return InstantiateAllVariablesDefaultValue; } }
6929 instantiateAllVariables_ = value;
6933 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6934 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6935 public bool HasInstantiateAllVariables {
6936 get {
return (_hasBits2 & 8192) != 0; }
6939 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6940 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6946 public const int AutoDetectGreaterThanAtLeastOneOfFieldNumber = 95;
6947 private readonly
static bool AutoDetectGreaterThanAtLeastOneOfDefaultValue =
true;
6949 private bool autoDetectGreaterThanAtLeastOneOf_;
6956 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6957 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6959 get {
if ((_hasBits2 & 64) != 0) {
return autoDetectGreaterThanAtLeastOneOf_; }
else {
return AutoDetectGreaterThanAtLeastOneOfDefaultValue; } }
6962 autoDetectGreaterThanAtLeastOneOf_ = value;
6966 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6967 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6968 public bool HasAutoDetectGreaterThanAtLeastOneOf {
6969 get {
return (_hasBits2 & 64) != 0; }
6972 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6973 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6979 public const int StopAfterFirstSolutionFieldNumber = 98;
6980 private readonly
static bool StopAfterFirstSolutionDefaultValue =
false;
6982 private bool stopAfterFirstSolution_;
6986 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6987 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6989 get {
if ((_hasBits2 & 128) != 0) {
return stopAfterFirstSolution_; }
else {
return StopAfterFirstSolutionDefaultValue; } }
6992 stopAfterFirstSolution_ = value;
6996 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
6997 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
6998 public bool HasStopAfterFirstSolution {
6999 get {
return (_hasBits2 & 128) != 0; }
7002 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7003 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7009 public const int StopAfterPresolveFieldNumber = 149;
7010 private readonly
static bool StopAfterPresolveDefaultValue =
false;
7012 private bool stopAfterPresolve_;
7017 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7018 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7020 get {
if ((_hasBits3 & 131072) != 0) {
return stopAfterPresolve_; }
else {
return StopAfterPresolveDefaultValue; } }
7022 _hasBits3 |= 131072;
7023 stopAfterPresolve_ = value;
7027 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7028 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7029 public bool HasStopAfterPresolve {
7030 get {
return (_hasBits3 & 131072) != 0; }
7033 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7034 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7036 _hasBits3 &= ~131072;
7040 public const int StopAfterRootPropagationFieldNumber = 252;
7041 private readonly
static bool StopAfterRootPropagationDefaultValue =
false;
7043 private bool stopAfterRootPropagation_;
7044 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7045 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7047 get {
if ((_hasBits6 & 16) != 0) {
return stopAfterRootPropagation_; }
else {
return StopAfterRootPropagationDefaultValue; } }
7050 stopAfterRootPropagation_ = value;
7054 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7055 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7057 get {
return (_hasBits6 & 16) != 0; }
7060 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7061 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7062 public void ClearStopAfterRootPropagation() {
7068 private readonly
static double LnsInitialDifficultyDefaultValue = 0.5D;
7070 private double lnsInitialDifficulty_;
7074 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7075 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7077 get {
if ((_hasBits7 & 33554432) != 0) {
return lnsInitialDifficulty_; }
else {
return LnsInitialDifficultyDefaultValue; } }
7079 _hasBits7 |= 33554432;
7080 lnsInitialDifficulty_ = value;
7084 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7085 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7087 get {
return (_hasBits7 & 33554432) != 0; }
7090 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7091 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7093 _hasBits7 &= ~33554432;
7097 public const int LnsInitialDeterministicLimitFieldNumber = 308;
7098 private readonly
static double LnsInitialDeterministicLimitDefaultValue = 0.1D;
7100 private double lnsInitialDeterministicLimit_;
7101 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7102 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7104 get {
if ((_hasBits7 & 67108864) != 0) {
return lnsInitialDeterministicLimit_; }
else {
return LnsInitialDeterministicLimitDefaultValue; } }
7106 _hasBits7 |= 67108864;
7107 lnsInitialDeterministicLimit_ = value;
7111 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7112 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7114 get {
return (_hasBits7 & 67108864) != 0; }
7117 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7118 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7119 public void ClearLnsInitialDeterministicLimit() {
7120 _hasBits7 &= ~67108864;
7125 private readonly
static bool UseLnsDefaultValue =
true;
7127 private bool useLns_;
7131 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7132 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7134 get {
if ((_hasBits7 & 4) != 0) {
return useLns_; }
else {
return UseLnsDefaultValue; } }
7141 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7142 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7144 get {
return (_hasBits7 & 4) != 0; }
7147 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7148 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7154 public const int UseLnsOnlyFieldNumber = 101;
7155 private readonly
static bool UseLnsOnlyDefaultValue =
false;
7157 private bool useLnsOnly_;
7161 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7162 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7164 get {
if ((_hasBits2 & 1024) != 0) {
return useLnsOnly_; }
else {
return UseLnsOnlyDefaultValue; } }
7167 useLnsOnly_ = value;
7171 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7172 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7174 get {
return (_hasBits2 & 1024) != 0; }
7177 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7178 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7184 public const int SolutionPoolSizeFieldNumber = 193;
7185 private readonly
static int SolutionPoolSizeDefaultValue = 3;
7187 private int solutionPoolSize_;
7193 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7194 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7196 get {
if ((_hasBits4 & 16777216) != 0) {
return solutionPoolSize_; }
else {
return SolutionPoolSizeDefaultValue; } }
7198 _hasBits4 |= 16777216;
7199 solutionPoolSize_ = value;
7203 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7204 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7205 public bool HasSolutionPoolSize {
7206 get {
return (_hasBits4 & 16777216) != 0; }
7209 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7210 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7212 _hasBits4 &= ~16777216;
7216 public const int UseRinsLnsFieldNumber = 129;
7217 private readonly
static bool UseRinsLnsDefaultValue =
true;
7219 private bool useRinsLns_;
7223 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7224 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7226 get {
if ((_hasBits3 & 4) != 0) {
return useRinsLns_; }
else {
return UseRinsLnsDefaultValue; } }
7229 useRinsLns_ = value;
7233 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7234 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7235 public bool HasUseRinsLns {
7236 get {
return (_hasBits3 & 4) != 0; }
7239 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7240 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7246 public const int UseFeasibilityPumpFieldNumber = 164;
7247 private readonly
static bool UseFeasibilityPumpDefaultValue =
true;
7249 private bool useFeasibilityPump_;
7253 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7254 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7256 get {
if ((_hasBits3 & 1073741824) != 0) {
return useFeasibilityPump_; }
else {
return UseFeasibilityPumpDefaultValue; } }
7258 _hasBits3 |= 1073741824;
7259 useFeasibilityPump_ = value;
7263 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7264 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7266 get {
return (_hasBits3 & 1073741824) != 0; }
7269 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7270 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7272 _hasBits3 &= ~1073741824;
7276 public const int UseLbRelaxLnsFieldNumber = 255;
7277 private readonly
static bool UseLbRelaxLnsDefaultValue =
true;
7279 private bool useLbRelaxLns_;
7285 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7286 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7288 get {
if ((_hasBits6 & 64) != 0) {
return useLbRelaxLns_; }
else {
return UseLbRelaxLnsDefaultValue; } }
7291 useLbRelaxLns_ = value;
7295 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7296 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7297 public bool HasUseLbRelaxLns {
7298 get {
return (_hasBits6 & 64) != 0; }
7301 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7302 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7308 public const int LbRelaxNumWorkersThresholdFieldNumber = 296;
7309 private readonly
static int LbRelaxNumWorkersThresholdDefaultValue = 16;
7311 private int lbRelaxNumWorkersThreshold_;
7315 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7316 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7318 get {
if ((_hasBits7 & 16384) != 0) {
return lbRelaxNumWorkersThreshold_; }
else {
return LbRelaxNumWorkersThresholdDefaultValue; } }
7321 lbRelaxNumWorkersThreshold_ = value;
7325 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7326 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7327 public bool HasLbRelaxNumWorkersThreshold {
7328 get {
return (_hasBits7 & 16384) != 0; }
7331 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7332 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7334 _hasBits7 &= ~16384;
7338 public const int FpRoundingFieldNumber = 165;
7339 private readonly
static global::Google.OrTools.Sat.SatParameters.Types.FPRoundingMethod FpRoundingDefaultValue = global::Google.OrTools.Sat.SatParameters.Types.FPRoundingMethod.PropagationAssisted;
7341 private global::Google.OrTools.Sat.SatParameters.Types.FPRoundingMethod fpRounding_;
7342 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7343 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7344 public global::Google.OrTools.Sat.SatParameters.Types.FPRoundingMethod
FpRounding {
7345 get {
if ((_hasBits3 & -2147483648) != 0) {
return fpRounding_; }
else {
return FpRoundingDefaultValue; } }
7347 _hasBits3 |= -2147483648;
7348 fpRounding_ = value;
7352 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7353 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7355 get {
return (_hasBits3 & -2147483648) != 0; }
7358 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7359 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7360 public void ClearFpRounding() {
7361 _hasBits3 &= ~-2147483648;
7366 private readonly
static bool DiversifyLnsParamsDefaultValue =
false;
7368 private bool diversifyLnsParams_;
7372 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7373 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7375 get {
if ((_hasBits3 & 1024) != 0) {
return diversifyLnsParams_; }
else {
return DiversifyLnsParamsDefaultValue; } }
7378 diversifyLnsParams_ = value;
7382 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7383 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7385 get {
return (_hasBits3 & 1024) != 0; }
7388 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7389 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7395 public const int RandomizeSearchFieldNumber = 103;
7396 private readonly
static bool RandomizeSearchDefaultValue =
false;
7398 private bool randomizeSearch_;
7402 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7403 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7405 get {
if ((_hasBits2 & 2048) != 0) {
return randomizeSearch_; }
else {
return RandomizeSearchDefaultValue; } }
7408 randomizeSearch_ = value;
7412 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7413 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7415 get {
return (_hasBits2 & 2048) != 0; }
7418 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7419 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7425 public const int SearchRandomVariablePoolSizeFieldNumber = 104;
7426 private readonly
static long SearchRandomVariablePoolSizeDefaultValue = 0L;
7428 private long searchRandomVariablePoolSize_;
7434 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7435 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7437 get {
if ((_hasBits2 & 4096) != 0) {
return searchRandomVariablePoolSize_; }
else {
return SearchRandomVariablePoolSizeDefaultValue; } }
7440 searchRandomVariablePoolSize_ = value;
7444 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7445 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7446 public bool HasSearchRandomVariablePoolSize {
7447 get {
return (_hasBits2 & 4096) != 0; }
7450 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7451 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7457 public const int PushAllTasksTowardStartFieldNumber = 262;
7458 private readonly
static bool PushAllTasksTowardStartDefaultValue =
false;
7460 private bool pushAllTasksTowardStart_;
7465 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7466 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7468 get {
if ((_hasBits6 & 8192) != 0) {
return pushAllTasksTowardStart_; }
else {
return PushAllTasksTowardStartDefaultValue; } }
7471 pushAllTasksTowardStart_ = value;
7475 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7476 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7477 public bool HasPushAllTasksTowardStart {
7478 get {
return (_hasBits6 & 8192) != 0; }
7481 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7482 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7488 public const int UseOptionalVariablesFieldNumber = 108;
7489 private readonly
static bool UseOptionalVariablesDefaultValue =
false;
7491 private bool useOptionalVariables_;
7500 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7501 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7503 get {
if ((_hasBits2 & 32768) != 0) {
return useOptionalVariables_; }
else {
return UseOptionalVariablesDefaultValue; } }
7506 useOptionalVariables_ = value;
7510 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7511 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7512 public bool HasUseOptionalVariables {
7513 get {
return (_hasBits2 & 32768) != 0; }
7516 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7517 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7518 public void ClearUseOptionalVariables() {
7519 _hasBits2 &= ~32768;
7524 private readonly
static bool UseExactLpReasonDefaultValue =
true;
7526 private bool useExactLpReason_;
7533 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7534 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7536 get {
if ((_hasBits2 & 65536) != 0) {
return useExactLpReason_; }
else {
return UseExactLpReasonDefaultValue; } }
7539 useExactLpReason_ = value;
7543 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7544 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7545 public bool HasUseExactLpReason {
7546 get {
return (_hasBits2 & 65536) != 0; }
7549 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7550 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7552 _hasBits2 &= ~65536;
7556 public const int UseCombinedNoOverlapFieldNumber = 133;
7557 private readonly
static bool UseCombinedNoOverlapDefaultValue =
false;
7559 private bool useCombinedNoOverlap_;
7565 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7566 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7568 get {
if ((_hasBits3 & 64) != 0) {
return useCombinedNoOverlap_; }
else {
return UseCombinedNoOverlapDefaultValue; } }
7571 useCombinedNoOverlap_ = value;
7575 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7576 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7577 public bool HasUseCombinedNoOverlap {
7578 get {
return (_hasBits3 & 64) != 0; }
7581 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7582 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7588 public const int AtMostOneMaxExpansionSizeFieldNumber = 270;
7589 private readonly
static int AtMostOneMaxExpansionSizeDefaultValue = 3;
7591 private int atMostOneMaxExpansionSize_;
7596 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7597 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7599 get {
if ((_hasBits6 & 2097152) != 0) {
return atMostOneMaxExpansionSize_; }
else {
return AtMostOneMaxExpansionSizeDefaultValue; } }
7601 _hasBits6 |= 2097152;
7602 atMostOneMaxExpansionSize_ = value;
7606 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7607 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7608 public bool HasAtMostOneMaxExpansionSize {
7609 get {
return (_hasBits6 & 2097152) != 0; }
7612 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7613 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7615 _hasBits6 &= ~2097152;
7619 public const int CatchSigintSignalFieldNumber = 135;
7620 private readonly
static bool CatchSigintSignalDefaultValue =
true;
7622 private bool catchSigintSignal_;
7628 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7629 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7631 get {
if ((_hasBits3 & 256) != 0) {
return catchSigintSignal_; }
else {
return CatchSigintSignalDefaultValue; } }
7634 catchSigintSignal_ = value;
7638 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7639 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7640 public bool HasCatchSigintSignal {
7641 get {
return (_hasBits3 & 256) != 0; }
7644 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7645 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7651 public const int UseImpliedBoundsFieldNumber = 144;
7652 private readonly
static bool UseImpliedBoundsDefaultValue =
true;
7654 private bool useImpliedBounds_;
7660 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7661 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7663 get {
if ((_hasBits3 & 4096) != 0) {
return useImpliedBounds_; }
else {
return UseImpliedBoundsDefaultValue; } }
7666 useImpliedBounds_ = value;
7670 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7671 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7672 public bool HasUseImpliedBounds {
7673 get {
return (_hasBits3 & 4096) != 0; }
7676 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7677 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7683 public const int PolishLpSolutionFieldNumber = 175;
7684 private readonly
static bool PolishLpSolutionDefaultValue =
false;
7686 private bool polishLpSolution_;
7693 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7694 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7696 get {
if ((_hasBits4 & 256) != 0) {
return polishLpSolution_; }
else {
return PolishLpSolutionDefaultValue; } }
7699 polishLpSolution_ = value;
7703 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7704 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7705 public bool HasPolishLpSolution {
7706 get {
return (_hasBits4 & 256) != 0; }
7709 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7710 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7716 public const int LpPrimalToleranceFieldNumber = 266;
7717 private readonly
static double LpPrimalToleranceDefaultValue = 1e-07D;
7719 private double lpPrimalTolerance_;
7727 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7728 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7730 get {
if ((_hasBits6 & 131072) != 0) {
return lpPrimalTolerance_; }
else {
return LpPrimalToleranceDefaultValue; } }
7732 _hasBits6 |= 131072;
7733 lpPrimalTolerance_ = value;
7737 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7738 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7739 public bool HasLpPrimalTolerance {
7740 get {
return (_hasBits6 & 131072) != 0; }
7743 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7744 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7746 _hasBits6 &= ~131072;
7750 public const int LpDualToleranceFieldNumber = 267;
7751 private readonly
static double LpDualToleranceDefaultValue = 1e-07D;
7753 private double lpDualTolerance_;
7754 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7755 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7757 get {
if ((_hasBits6 & 262144) != 0) {
return lpDualTolerance_; }
else {
return LpDualToleranceDefaultValue; } }
7759 _hasBits6 |= 262144;
7760 lpDualTolerance_ = value;
7764 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7765 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7767 get {
return (_hasBits6 & 262144) != 0; }
7770 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7771 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7772 public void ClearLpDualTolerance() {
7773 _hasBits6 &= ~262144;
7778 private readonly
static bool ConvertIntervalsDefaultValue =
true;
7780 private bool convertIntervals_;
7786 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7787 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7789 get {
if ((_hasBits4 & 1024) != 0) {
return convertIntervals_; }
else {
return ConvertIntervalsDefaultValue; } }
7792 convertIntervals_ = value;
7796 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7797 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7799 get {
return (_hasBits4 & 1024) != 0; }
7802 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7803 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7809 public const int SymmetryLevelFieldNumber = 183;
7810 private readonly
static int SymmetryLevelDefaultValue = 2;
7812 private int symmetryLevel_;
7821 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7822 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7824 get {
if ((_hasBits4 & 65536) != 0) {
return symmetryLevel_; }
else {
return SymmetryLevelDefaultValue; } }
7827 symmetryLevel_ = value;
7831 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7832 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7833 public bool HasSymmetryLevel {
7834 get {
return (_hasBits4 & 65536) != 0; }
7837 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7838 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7839 public void ClearSymmetryLevel() {
7840 _hasBits4 &= ~65536;
7844 public const int UseSymmetryInLpFieldNumber = 301;
7845 private readonly
static bool UseSymmetryInLpDefaultValue =
false;
7847 private bool useSymmetryInLp_;
7855 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7856 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7858 get {
if ((_hasBits7 & 524288) != 0) {
return useSymmetryInLp_; }
else {
return UseSymmetryInLpDefaultValue; } }
7860 _hasBits7 |= 524288;
7861 useSymmetryInLp_ = value;
7865 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7866 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7867 public bool HasUseSymmetryInLp {
7868 get {
return (_hasBits7 & 524288) != 0; }
7871 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7872 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7874 _hasBits7 &= ~524288;
7878 public const int KeepSymmetryInPresolveFieldNumber = 303;
7879 private readonly
static bool KeepSymmetryInPresolveDefaultValue =
false;
7881 private bool keepSymmetryInPresolve_;
7888 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7889 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7891 get {
if ((_hasBits7 & 2097152) != 0) {
return keepSymmetryInPresolve_; }
else {
return KeepSymmetryInPresolveDefaultValue; } }
7893 _hasBits7 |= 2097152;
7894 keepSymmetryInPresolve_ = value;
7898 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7899 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7900 public bool HasKeepSymmetryInPresolve {
7901 get {
return (_hasBits7 & 2097152) != 0; }
7904 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7905 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7907 _hasBits7 &= ~2097152;
7911 public const int SymmetryDetectionDeterministicTimeLimitFieldNumber = 302;
7912 private readonly
static double SymmetryDetectionDeterministicTimeLimitDefaultValue = 1D;
7914 private double symmetryDetectionDeterministicTimeLimit_;
7918 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7919 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7921 get {
if ((_hasBits7 & 1048576) != 0) {
return symmetryDetectionDeterministicTimeLimit_; }
else {
return SymmetryDetectionDeterministicTimeLimitDefaultValue; } }
7923 _hasBits7 |= 1048576;
7924 symmetryDetectionDeterministicTimeLimit_ = value;
7928 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7929 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7930 public bool HasSymmetryDetectionDeterministicTimeLimit {
7931 get {
return (_hasBits7 & 1048576) != 0; }
7934 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7935 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7936 public void ClearSymmetryDetectionDeterministicTimeLimit() {
7937 _hasBits7 &= ~1048576;
7941 public const int NewLinearPropagationFieldNumber = 224;
7942 private readonly
static bool NewLinearPropagationDefaultValue =
true;
7944 private bool newLinearPropagation_;
7950 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7951 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7953 get {
if ((_hasBits5 & 32768) != 0) {
return newLinearPropagation_; }
else {
return NewLinearPropagationDefaultValue; } }
7956 newLinearPropagation_ = value;
7960 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7961 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7962 public bool HasNewLinearPropagation {
7963 get {
return (_hasBits5 & 32768) != 0; }
7966 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7967 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7969 _hasBits5 &= ~32768;
7973 public const int LinearSplitSizeFieldNumber = 256;
7974 private readonly
static int LinearSplitSizeDefaultValue = 100;
7976 private int linearSplitSize_;
7982 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7983 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7985 get {
if ((_hasBits6 & 128) != 0) {
return linearSplitSize_; }
else {
return LinearSplitSizeDefaultValue; } }
7988 linearSplitSize_ = value;
7992 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7993 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
7994 public bool HasLinearSplitSize {
7995 get {
return (_hasBits6 & 128) != 0; }
7998 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
7999 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8005 public const int LinearizationLevelFieldNumber = 90;
8006 private readonly
static int LinearizationLevelDefaultValue = 1;
8008 private int linearizationLevel_;
8015 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8016 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8018 get {
if ((_hasBits2 & 2) != 0) {
return linearizationLevel_; }
else {
return LinearizationLevelDefaultValue; } }
8021 linearizationLevel_ = value;
8025 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8026 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8027 public bool HasLinearizationLevel {
8028 get {
return (_hasBits2 & 2) != 0; }
8031 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8032 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8038 public const int BooleanEncodingLevelFieldNumber = 107;
8039 private readonly
static int BooleanEncodingLevelDefaultValue = 1;
8041 private int booleanEncodingLevel_;
8046 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8047 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8049 get {
if ((_hasBits2 & 16384) != 0) {
return booleanEncodingLevel_; }
else {
return BooleanEncodingLevelDefaultValue; } }
8052 booleanEncodingLevel_ = value;
8056 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8057 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8058 public bool HasBooleanEncodingLevel {
8059 get {
return (_hasBits2 & 16384) != 0; }
8062 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8063 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8065 _hasBits2 &= ~16384;
8069 public const int MaxDomainSizeWhenEncodingEqNeqConstraintsFieldNumber = 191;
8070 private readonly
static int MaxDomainSizeWhenEncodingEqNeqConstraintsDefaultValue = 16;
8072 private int maxDomainSizeWhenEncodingEqNeqConstraints_;
8079 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8080 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8082 get {
if ((_hasBits4 & 4194304) != 0) {
return maxDomainSizeWhenEncodingEqNeqConstraints_; }
else {
return MaxDomainSizeWhenEncodingEqNeqConstraintsDefaultValue; } }
8084 _hasBits4 |= 4194304;
8085 maxDomainSizeWhenEncodingEqNeqConstraints_ = value;
8089 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8090 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8091 public bool HasMaxDomainSizeWhenEncodingEqNeqConstraints {
8092 get {
return (_hasBits4 & 4194304) != 0; }
8095 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8096 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8098 _hasBits4 &= ~4194304;
8102 public const int MaxNumCutsFieldNumber = 91;
8103 private readonly
static int MaxNumCutsDefaultValue = 10000;
8105 private int maxNumCuts_;
8113 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8114 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8116 get {
if ((_hasBits2 & 4) != 0) {
return maxNumCuts_; }
else {
return MaxNumCutsDefaultValue; } }
8119 maxNumCuts_ = value;
8123 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8124 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8125 public bool HasMaxNumCuts {
8126 get {
return (_hasBits2 & 4) != 0; }
8129 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8130 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8136 public const int CutLevelFieldNumber = 196;
8137 private readonly
static int CutLevelDefaultValue = 1;
8139 private int cutLevel_;
8145 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8146 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8148 get {
if ((_hasBits4 & 134217728) != 0) {
return cutLevel_; }
else {
return CutLevelDefaultValue; } }
8150 _hasBits4 |= 134217728;
8155 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8156 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8157 public bool HasCutLevel {
8158 get {
return (_hasBits4 & 134217728) != 0; }
8161 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8162 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8164 _hasBits4 &= ~134217728;
8168 public const int OnlyAddCutsAtLevelZeroFieldNumber = 92;
8169 private readonly
static bool OnlyAddCutsAtLevelZeroDefaultValue =
false;
8171 private bool onlyAddCutsAtLevelZero_;
8176 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8177 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8179 get {
if ((_hasBits2 & 8) != 0) {
return onlyAddCutsAtLevelZero_; }
else {
return OnlyAddCutsAtLevelZeroDefaultValue; } }
8182 onlyAddCutsAtLevelZero_ = value;
8186 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8187 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8188 public bool HasOnlyAddCutsAtLevelZero {
8189 get {
return (_hasBits2 & 8) != 0; }
8192 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8193 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8194 public void ClearOnlyAddCutsAtLevelZero() {
8199 public const int AddObjectiveCutFieldNumber = 197;
8200 private readonly
static bool AddObjectiveCutDefaultValue =
false;
8202 private bool addObjectiveCut_;
8210 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8211 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8213 get {
if ((_hasBits4 & 268435456) != 0) {
return addObjectiveCut_; }
else {
return AddObjectiveCutDefaultValue; } }
8215 _hasBits4 |= 268435456;
8216 addObjectiveCut_ = value;
8220 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8221 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8222 public bool HasAddObjectiveCut {
8223 get {
return (_hasBits4 & 268435456) != 0; }
8226 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8227 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8229 _hasBits4 &= ~268435456;
8233 public const int AddCgCutsFieldNumber = 117;
8234 private readonly
static bool AddCgCutsDefaultValue =
true;
8236 private bool addCgCuts_;
8241 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8242 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8244 get {
if ((_hasBits2 & 8388608) != 0) {
return addCgCuts_; }
else {
return AddCgCutsDefaultValue; } }
8246 _hasBits2 |= 8388608;
8251 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8252 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8253 public bool HasAddCgCuts {
8254 get {
return (_hasBits2 & 8388608) != 0; }
8257 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8258 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8259 public void ClearAddCgCuts() {
8260 _hasBits2 &= ~8388608;
8264 public const int AddMirCutsFieldNumber = 120;
8265 private readonly
static bool AddMirCutsDefaultValue =
true;
8267 private bool addMirCuts_;
8272 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8273 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8275 get {
if ((_hasBits2 & 33554432) != 0) {
return addMirCuts_; }
else {
return AddMirCutsDefaultValue; } }
8277 _hasBits2 |= 33554432;
8278 addMirCuts_ = value;
8282 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8283 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8285 get {
return (_hasBits2 & 33554432) != 0; }
8288 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8289 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8290 public void ClearAddMirCuts() {
8291 _hasBits2 &= ~33554432;
8295 public const int AddZeroHalfCutsFieldNumber = 169;
8296 private readonly
static bool AddZeroHalfCutsDefaultValue =
true;
8298 private bool addZeroHalfCuts_;
8303 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8304 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8306 get {
if ((_hasBits4 & 8) != 0) {
return addZeroHalfCuts_; }
else {
return AddZeroHalfCutsDefaultValue; } }
8309 addZeroHalfCuts_ = value;
8313 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8314 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8316 get {
return (_hasBits4 & 8) != 0; }
8319 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8320 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8321 public void ClearAddZeroHalfCuts() {
8326 public const int AddCliqueCutsFieldNumber = 172;
8327 private readonly
static bool AddCliqueCutsDefaultValue =
true;
8329 private bool addCliqueCuts_;
8335 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8336 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8338 get {
if ((_hasBits4 & 32) != 0) {
return addCliqueCuts_; }
else {
return AddCliqueCutsDefaultValue; } }
8341 addCliqueCuts_ = value;
8345 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8346 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8347 public bool HasAddCliqueCuts {
8348 get {
return (_hasBits4 & 32) != 0; }
8351 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8352 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8358 public const int AddRltCutsFieldNumber = 279;
8359 private readonly
static bool AddRltCutsDefaultValue =
true;
8361 private bool addRltCuts_;
8366 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8367 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8369 get {
if ((_hasBits6 & 1073741824) != 0) {
return addRltCuts_; }
else {
return AddRltCutsDefaultValue; } }
8371 _hasBits6 |= 1073741824;
8372 addRltCuts_ = value;
8376 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8377 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8378 public bool HasAddRltCuts {
8379 get {
return (_hasBits6 & 1073741824) != 0; }
8382 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8383 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8384 public void ClearAddRltCuts() {
8385 _hasBits6 &= ~1073741824;
8389 public const int MaxAllDiffCutSizeFieldNumber = 148;
8390 private readonly
static int MaxAllDiffCutSizeDefaultValue = 64;
8392 private int maxAllDiffCutSize_;
8398 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8399 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8401 get {
if ((_hasBits3 & 65536) != 0) {
return maxAllDiffCutSize_; }
else {
return MaxAllDiffCutSizeDefaultValue; } }
8404 maxAllDiffCutSize_ = value;
8408 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8409 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8410 public bool HasMaxAllDiffCutSize {
8411 get {
return (_hasBits3 & 65536) != 0; }
8414 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8415 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8417 _hasBits3 &= ~65536;
8421 public const int AddLinMaxCutsFieldNumber = 152;
8422 private readonly
static bool AddLinMaxCutsDefaultValue =
true;
8424 private bool addLinMaxCuts_;
8430 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8431 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8433 get {
if ((_hasBits3 & 524288) != 0) {
return addLinMaxCuts_; }
else {
return AddLinMaxCutsDefaultValue; } }
8435 _hasBits3 |= 524288;
8436 addLinMaxCuts_ = value;
8440 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8441 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8442 public bool HasAddLinMaxCuts {
8443 get {
return (_hasBits3 & 524288) != 0; }
8446 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8447 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8449 _hasBits3 &= ~524288;
8453 public const int MaxIntegerRoundingScalingFieldNumber = 119;
8454 private readonly
static int MaxIntegerRoundingScalingDefaultValue = 600;
8456 private int maxIntegerRoundingScaling_;
8467 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8468 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8470 get {
if ((_hasBits2 & 16777216) != 0) {
return maxIntegerRoundingScaling_; }
else {
return MaxIntegerRoundingScalingDefaultValue; } }
8472 _hasBits2 |= 16777216;
8473 maxIntegerRoundingScaling_ = value;
8477 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8478 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8479 public bool HasMaxIntegerRoundingScaling {
8480 get {
return (_hasBits2 & 16777216) != 0; }
8483 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8484 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8485 public void ClearMaxIntegerRoundingScaling() {
8486 _hasBits2 &= ~16777216;
8491 private readonly
static bool AddLpConstraintsLazilyDefaultValue =
true;
8493 private bool addLpConstraintsLazily_;
8500 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8501 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8503 get {
if ((_hasBits2 & 262144) != 0) {
return addLpConstraintsLazily_; }
else {
return AddLpConstraintsLazilyDefaultValue; } }
8505 _hasBits2 |= 262144;
8506 addLpConstraintsLazily_ = value;
8510 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8511 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8512 public bool HasAddLpConstraintsLazily {
8513 get {
return (_hasBits2 & 262144) != 0; }
8516 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8517 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8519 _hasBits2 &= ~262144;
8523 public const int RootLpIterationsFieldNumber = 227;
8524 private readonly
static int RootLpIterationsDefaultValue = 2000;
8526 private int rootLpIterations_;
8533 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8534 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8536 get {
if ((_hasBits5 & 262144) != 0) {
return rootLpIterations_; }
else {
return RootLpIterationsDefaultValue; } }
8538 _hasBits5 |= 262144;
8539 rootLpIterations_ = value;
8543 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8544 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8545 public bool HasRootLpIterations {
8546 get {
return (_hasBits5 & 262144) != 0; }
8549 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8550 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8552 _hasBits5 &= ~262144;
8556 public const int MinOrthogonalityForLpConstraintsFieldNumber = 115;
8557 private readonly
static double MinOrthogonalityForLpConstraintsDefaultValue = 0.05D;
8559 private double minOrthogonalityForLpConstraints_;
8567 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8568 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8570 get {
if ((_hasBits2 & 2097152) != 0) {
return minOrthogonalityForLpConstraints_; }
else {
return MinOrthogonalityForLpConstraintsDefaultValue; } }
8572 _hasBits2 |= 2097152;
8573 minOrthogonalityForLpConstraints_ = value;
8577 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8578 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8579 public bool HasMinOrthogonalityForLpConstraints {
8580 get {
return (_hasBits2 & 2097152) != 0; }
8583 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8584 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8586 _hasBits2 &= ~2097152;
8590 public const int MaxCutRoundsAtLevelZeroFieldNumber = 154;
8591 private readonly
static int MaxCutRoundsAtLevelZeroDefaultValue = 1;
8593 private int maxCutRoundsAtLevelZero_;
8597 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8598 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8600 get {
if ((_hasBits3 & 2097152) != 0) {
return maxCutRoundsAtLevelZero_; }
else {
return MaxCutRoundsAtLevelZeroDefaultValue; } }
8602 _hasBits3 |= 2097152;
8603 maxCutRoundsAtLevelZero_ = value;
8607 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8608 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8609 public bool HasMaxCutRoundsAtLevelZero {
8610 get {
return (_hasBits3 & 2097152) != 0; }
8613 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8614 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8615 public void ClearMaxCutRoundsAtLevelZero() {
8616 _hasBits3 &= ~2097152;
8621 private readonly
static int MaxConsecutiveInactiveCountDefaultValue = 100;
8623 private int maxConsecutiveInactiveCount_;
8629 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8630 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8632 get {
if ((_hasBits2 & 67108864) != 0) {
return maxConsecutiveInactiveCount_; }
else {
return MaxConsecutiveInactiveCountDefaultValue; } }
8634 _hasBits2 |= 67108864;
8635 maxConsecutiveInactiveCount_ = value;
8639 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8640 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8642 get {
return (_hasBits2 & 67108864) != 0; }
8645 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8646 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8647 public void ClearMaxConsecutiveInactiveCount() {
8648 _hasBits2 &= ~67108864;
8652 public const int CutMaxActiveCountValueFieldNumber = 155;
8653 private readonly
static double CutMaxActiveCountValueDefaultValue = 1e+10D;
8655 private double cutMaxActiveCountValue_;
8661 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8662 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8664 get {
if ((_hasBits3 & 4194304) != 0) {
return cutMaxActiveCountValue_; }
else {
return CutMaxActiveCountValueDefaultValue; } }
8666 _hasBits3 |= 4194304;
8667 cutMaxActiveCountValue_ = value;
8671 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8672 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8673 public bool HasCutMaxActiveCountValue {
8674 get {
return (_hasBits3 & 4194304) != 0; }
8677 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8678 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8679 public void ClearCutMaxActiveCountValue() {
8680 _hasBits3 &= ~4194304;
8684 public const int CutActiveCountDecayFieldNumber = 156;
8685 private readonly
static double CutActiveCountDecayDefaultValue = 0.8D;
8687 private double cutActiveCountDecay_;
8688 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8689 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8691 get {
if ((_hasBits3 & 8388608) != 0) {
return cutActiveCountDecay_; }
else {
return CutActiveCountDecayDefaultValue; } }
8693 _hasBits3 |= 8388608;
8694 cutActiveCountDecay_ = value;
8698 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8699 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8700 public bool HasCutActiveCountDecay {
8701 get {
return (_hasBits3 & 8388608) != 0; }
8704 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8705 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8706 public void ClearCutActiveCountDecay() {
8707 _hasBits3 &= ~8388608;
8711 public const int CutCleanupTargetFieldNumber = 157;
8712 private readonly
static int CutCleanupTargetDefaultValue = 1000;
8714 private int cutCleanupTarget_;
8718 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8719 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8721 get {
if ((_hasBits3 & 16777216) != 0) {
return cutCleanupTarget_; }
else {
return CutCleanupTargetDefaultValue; } }
8723 _hasBits3 |= 16777216;
8724 cutCleanupTarget_ = value;
8728 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8729 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8731 get {
return (_hasBits3 & 16777216) != 0; }
8734 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8735 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8737 _hasBits3 &= ~16777216;
8742 private readonly
static int NewConstraintsBatchSizeDefaultValue = 50;
8744 private int newConstraintsBatchSize_;
8749 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8750 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8752 get {
if ((_hasBits2 & 134217728) != 0) {
return newConstraintsBatchSize_; }
else {
return NewConstraintsBatchSizeDefaultValue; } }
8754 _hasBits2 |= 134217728;
8755 newConstraintsBatchSize_ = value;
8759 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8760 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8762 get {
return (_hasBits2 & 134217728) != 0; }
8765 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8766 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8767 public void ClearNewConstraintsBatchSize() {
8768 _hasBits2 &= ~134217728;
8772 public const int ExploitIntegerLpSolutionFieldNumber = 94;
8773 private readonly
static bool ExploitIntegerLpSolutionDefaultValue =
true;
8775 private bool exploitIntegerLpSolution_;
8782 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8783 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8785 get {
if ((_hasBits2 & 32) != 0) {
return exploitIntegerLpSolution_; }
else {
return ExploitIntegerLpSolutionDefaultValue; } }
8788 exploitIntegerLpSolution_ = value;
8792 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8793 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8794 public bool HasExploitIntegerLpSolution {
8795 get {
return (_hasBits2 & 32) != 0; }
8798 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8799 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8805 public const int ExploitAllLpSolutionFieldNumber = 116;
8806 private readonly
static bool ExploitAllLpSolutionDefaultValue =
true;
8808 private bool exploitAllLpSolution_;
8814 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8815 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8817 get {
if ((_hasBits2 & 4194304) != 0) {
return exploitAllLpSolution_; }
else {
return ExploitAllLpSolutionDefaultValue; } }
8819 _hasBits2 |= 4194304;
8820 exploitAllLpSolution_ = value;
8824 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8825 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8826 public bool HasExploitAllLpSolution {
8827 get {
return (_hasBits2 & 4194304) != 0; }
8830 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8831 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8832 public void ClearExploitAllLpSolution() {
8833 _hasBits2 &= ~4194304;
8837 public const int ExploitBestSolutionFieldNumber = 130;
8838 private readonly
static bool ExploitBestSolutionDefaultValue =
false;
8840 private bool exploitBestSolution_;
8844 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8845 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8847 get {
if ((_hasBits3 & 8) != 0) {
return exploitBestSolution_; }
else {
return ExploitBestSolutionDefaultValue; } }
8850 exploitBestSolution_ = value;
8854 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8855 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8857 get {
return (_hasBits3 & 8) != 0; }
8860 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8861 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8862 public void ClearExploitBestSolution() {
8868 private readonly
static bool ExploitRelaxationSolutionDefaultValue =
false;
8870 private bool exploitRelaxationSolution_;
8876 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8877 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8879 get {
if ((_hasBits3 & 134217728) != 0) {
return exploitRelaxationSolution_; }
else {
return ExploitRelaxationSolutionDefaultValue; } }
8881 _hasBits3 |= 134217728;
8882 exploitRelaxationSolution_ = value;
8886 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8887 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8889 get {
return (_hasBits3 & 134217728) != 0; }
8892 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8893 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8894 public void ClearExploitRelaxationSolution() {
8895 _hasBits3 &= ~134217728;
8899 public const int ExploitObjectiveFieldNumber = 131;
8900 private readonly
static bool ExploitObjectiveDefaultValue =
true;
8902 private bool exploitObjective_;
8907 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8908 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8910 get {
if ((_hasBits3 & 16) != 0) {
return exploitObjective_; }
else {
return ExploitObjectiveDefaultValue; } }
8913 exploitObjective_ = value;
8917 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8918 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8920 get {
return (_hasBits3 & 16) != 0; }
8923 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8924 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8925 public void ClearExploitObjective() {
8930 public const int DetectLinearizedProductFieldNumber = 277;
8931 private readonly
static bool DetectLinearizedProductDefaultValue =
false;
8933 private bool detectLinearizedProduct_;
8939 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8940 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8942 get {
if ((_hasBits6 & 268435456) != 0) {
return detectLinearizedProduct_; }
else {
return DetectLinearizedProductDefaultValue; } }
8944 _hasBits6 |= 268435456;
8945 detectLinearizedProduct_ = value;
8949 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8950 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8952 get {
return (_hasBits6 & 268435456) != 0; }
8955 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8956 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8957 public void ClearDetectLinearizedProduct() {
8958 _hasBits6 &= ~268435456;
8962 public const int MipMaxBoundFieldNumber = 124;
8963 private readonly
static double MipMaxBoundDefaultValue = 1e+07D;
8965 private double mipMaxBound_;
8971 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8972 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8974 get {
if ((_hasBits2 & 536870912) != 0) {
return mipMaxBound_; }
else {
return MipMaxBoundDefaultValue; } }
8976 _hasBits2 |= 536870912;
8977 mipMaxBound_ = value;
8981 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8982 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8983 public bool HasMipMaxBound {
8984 get {
return (_hasBits2 & 536870912) != 0; }
8987 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
8988 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
8989 public void ClearMipMaxBound() {
8990 _hasBits2 &= ~536870912;
8994 public const int MipVarScalingFieldNumber = 125;
8995 private readonly
static double MipVarScalingDefaultValue = 1D;
8997 private double mipVarScaling_;
9003 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
9004 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
9006 get {
if ((_hasBits2 & 1073741824) != 0) {
return mipVarScaling_; }
else {
return MipVarScalingDefaultValue; } }
9008 _hasBits2 |= 1073741824;
9009 mipVarScaling_ = value;
9013 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
9014 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
9015 public bool HasMipVarScaling {
9016 get {
return (_hasBits2 & 1073741824) != 0; }
9019 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
9020 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
9021 public void ClearMipVarScaling() {
9022 _hasBits2 &= ~1073741824;
9026 public const int MipScaleLargeDomainFieldNumber = 225;
9027 private readonly
static bool MipScaleLargeDomainDefaultValue =
false;
9029 private bool mipScaleLargeDomain_;
9035 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
9036 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
9038 get {
if ((_hasBits5 & 65536) != 0) {
return mipScaleLargeDomain_; }
else {
return MipScaleLargeDomainDefaultValue; } }
9041 mipScaleLargeDomain_ = value;
9045 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
9046 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
9047 public bool HasMipScaleLargeDomain {
9048 get {
return (_hasBits5 & 65536) != 0; }
9051 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
9052 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
9053 public void ClearMipScaleLargeDomain() {
9054 _hasBits5 &= ~65536;
9058 public const int MipAutomaticallyScaleVariablesFieldNumber = 166;
9059 private readonly
static bool MipAutomaticallyScaleVariablesDefaultValue =
true;
9061 private bool mipAutomaticallyScaleVariables_;
9069 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
9070 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
9072 get {
if ((_hasBits4 & 1) != 0) {
return mipAutomaticallyScaleVariables_; }
else {
return MipAutomaticallyScaleVariablesDefaultValue; } }
9075 mipAutomaticallyScaleVariables_ = value;
9079 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
9080 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
9081 public bool HasMipAutomaticallyScaleVariables {
9082 get {
return (_hasBits4 & 1) != 0; }
9085 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
9086 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
9092 public const int OnlySolveIpFieldNumber = 222;
9093 private readonly
static bool OnlySolveIpDefaultValue =
false;
9095 private bool onlySolveIp_;
9110 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
9111 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
9113 get {
if ((_hasBits5 & 8192) != 0) {
return onlySolveIp_; }
else {
return OnlySolveIpDefaultValue; } }
9116 onlySolveIp_ = value;
9120 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
9121 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
9123 get {
return (_hasBits5 & 8192) != 0; }
9126 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
9127 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
9128 public void ClearOnlySolveIp() {
9133 public const int MipWantedPrecisionFieldNumber = 126;
9134 private readonly
static double MipWantedPrecisionDefaultValue = 1e-06D;
9136 private double mipWantedPrecision_;
9156 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
9157 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
9159 get {
if ((_hasBits2 & -2147483648) != 0) {
return mipWantedPrecision_; }
else {
return MipWantedPrecisionDefaultValue; } }
9161 _hasBits2 |= -2147483648;
9162 mipWantedPrecision_ = value;
9166 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
9167 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
9168 public bool HasMipWantedPrecision {
9169 get {
return (_hasBits2 & -2147483648) != 0; }
9172 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
9173 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
9175 _hasBits2 &= ~-2147483648;
9180 private readonly
static int MipMaxActivityExponentDefaultValue = 53;
9182 private int mipMaxActivityExponent_;
9193 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
9194 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
9196 get {
if ((_hasBits3 & 1) != 0) {
return mipMaxActivityExponent_; }
else {
return MipMaxActivityExponentDefaultValue; } }
9199 mipMaxActivityExponent_ = value;
9203 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
9204 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
9205 public bool HasMipMaxActivityExponent {
9206 get {
return (_hasBits3 & 1) != 0; }
9209 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
9210 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
9211 public void ClearMipMaxActivityExponent() {
9216 public const int MipCheckPrecisionFieldNumber = 128;
9217 private readonly
static double MipCheckPrecisionDefaultValue = 0.0001D;
9219 private double mipCheckPrecision_;
9225 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
9226 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
9228 get {
if ((_hasBits3 & 2) != 0) {
return mipCheckPrecision_; }
else {
return MipCheckPrecisionDefaultValue; } }
9231 mipCheckPrecision_ = value;
9235 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
9236 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
9237 public bool HasMipCheckPrecision {
9238 get {
return (_hasBits3 & 2) != 0; }
9241 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
9242 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
9243 public void ClearMipCheckPrecision() {
9248 public const int MipComputeTrueObjectiveBoundFieldNumber = 198;
9249 private readonly
static bool MipComputeTrueObjectiveBoundDefaultValue =
true;
9251 private bool mipComputeTrueObjectiveBound_;
9259 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
9260 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
9262 get {
if ((_hasBits4 & 536870912) != 0) {
return mipComputeTrueObjectiveBound_; }
else {
return MipComputeTrueObjectiveBoundDefaultValue; } }
9264 _hasBits4 |= 536870912;
9265 mipComputeTrueObjectiveBound_ = value;
9269 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
9270 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
9272 get {
return (_hasBits4 & 536870912) != 0; }
9275 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
9276 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
9277 public void ClearMipComputeTrueObjectiveBound() {
9278 _hasBits4 &= ~536870912;
9283 private readonly
static double MipMaxValidMagnitudeDefaultValue = 1e+20D;
9285 private double mipMaxValidMagnitude_;
9293 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
9294 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
9296 get {
if ((_hasBits4 & 1073741824) != 0) {
return mipMaxValidMagnitude_; }
else {
return MipMaxValidMagnitudeDefaultValue; } }
9298 _hasBits4 |= 1073741824;
9299 mipMaxValidMagnitude_ = value;
9303 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
9304 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
9306 get {
return (_hasBits4 & 1073741824) != 0; }
9309 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
9310 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
9311 public void ClearMipMaxValidMagnitude() {
9312 _hasBits4 &= ~1073741824;
9317 private readonly
static bool MipTreatHighMagnitudeBoundsAsInfinityDefaultValue =
false;
9319 private bool mipTreatHighMagnitudeBoundsAsInfinity_;
9328 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
9329 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
9331 get {
if ((_hasBits6 & 536870912) != 0) {
return mipTreatHighMagnitudeBoundsAsInfinity_; }
else {
return MipTreatHighMagnitudeBoundsAsInfinityDefaultValue; } }
9333 _hasBits6 |= 536870912;
9334 mipTreatHighMagnitudeBoundsAsInfinity_ = value;
9338 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
9339 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
9341 get {
return (_hasBits6 & 536870912) != 0; }
9344 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
9345 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
9346 public void ClearMipTreatHighMagnitudeBoundsAsInfinity() {
9347 _hasBits6 &= ~536870912;
9352 private readonly
static double MipDropToleranceDefaultValue = 1e-16D;
9354 private double mipDropTolerance_;
9359 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
9360 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
9362 get {
if ((_hasBits5 & 4194304) != 0) {
return mipDropTolerance_; }
else {
return MipDropToleranceDefaultValue; } }
9364 _hasBits5 |= 4194304;
9365 mipDropTolerance_ = value;
9369 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
9370 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
9372 get {
return (_hasBits5 & 4194304) != 0; }
9375 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
9376 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
9377 public void ClearMipDropTolerance() {
9378 _hasBits5 &= ~4194304;
9382 public const int MipPresolveLevelFieldNumber = 261;
9383 private readonly
static int MipPresolveLevelDefaultValue = 2;
9385 private int mipPresolveLevel_;
9392 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
9393 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
9395 get {
if ((_hasBits6 & 4096) != 0) {
return mipPresolveLevel_; }
else {
return MipPresolveLevelDefaultValue; } }
9398 mipPresolveLevel_ = value;
9402 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
9403 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
9405 get {
return (_hasBits6 & 4096) != 0; }
9408 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
9409 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
9414 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
9415 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
9416 public override bool Equals(
object other) {
9420 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
9421 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
9423 if (ReferenceEquals(other,
null)) {
9426 if (ReferenceEquals(other,
this)) {
9429 if (Name != other.
Name)
return false;
9458 if(!restartAlgorithms_.Equals(other.restartAlgorithms_))
return false;
9528 if(!subsolvers_.Equals(other.subsolvers_))
return false;
9529 if(!extraSubsolvers_.Equals(other.extraSubsolvers_))
return false;
9530 if(!ignoreSubsolvers_.Equals(other.ignoreSubsolvers_))
return false;
9531 if(!filterSubsolvers_.Equals(other.filterSubsolvers_))
return false;
9532 if(!subsolverParams_.Equals(other.subsolverParams_))
return false;
9691 if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(
MipMaxBound, other.
MipMaxBound))
return false;
9704 return Equals(_unknownFields, other._unknownFields);
9707 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
9708 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
9709 public override int GetHashCode() {
9711 if (HasName) hash ^= Name.GetHashCode();
9712 if (HasPreferredVariableOrder) hash ^= PreferredVariableOrder.GetHashCode();
9713 if (HasInitialPolarity) hash ^= InitialPolarity.GetHashCode();
9714 if (HasUsePhaseSaving) hash ^= UsePhaseSaving.GetHashCode();
9715 if (HasPolarityRephaseIncrement) hash ^= PolarityRephaseIncrement.GetHashCode();
9716 if (HasPolarityExploitLsHints) hash ^= PolarityExploitLsHints.GetHashCode();
9717 if (HasRandomPolarityRatio) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(RandomPolarityRatio);
9718 if (HasRandomBranchesRatio) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(RandomBranchesRatio);
9719 if (HasUseErwaHeuristic) hash ^= UseErwaHeuristic.GetHashCode();
9720 if (HasInitialVariablesActivity) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(InitialVariablesActivity);
9721 if (HasAlsoBumpVariablesInConflictReasons) hash ^= AlsoBumpVariablesInConflictReasons.GetHashCode();
9722 if (HasMinimizationAlgorithm) hash ^= MinimizationAlgorithm.GetHashCode();
9723 if (HasBinaryMinimizationAlgorithm) hash ^= BinaryMinimizationAlgorithm.GetHashCode();
9724 if (HasSubsumptionDuringConflictAnalysis) hash ^= SubsumptionDuringConflictAnalysis.GetHashCode();
9725 if (HasClauseCleanupPeriod) hash ^= ClauseCleanupPeriod.GetHashCode();
9726 if (HasClauseCleanupTarget) hash ^= ClauseCleanupTarget.GetHashCode();
9727 if (HasClauseCleanupRatio) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(ClauseCleanupRatio);
9728 if (HasClauseCleanupProtection) hash ^= ClauseCleanupProtection.GetHashCode();
9729 if (HasClauseCleanupLbdBound) hash ^= ClauseCleanupLbdBound.GetHashCode();
9730 if (HasClauseCleanupOrdering) hash ^= ClauseCleanupOrdering.GetHashCode();
9731 if (HasPbCleanupIncrement) hash ^= PbCleanupIncrement.GetHashCode();
9732 if (HasPbCleanupRatio) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(PbCleanupRatio);
9733 if (HasVariableActivityDecay) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(VariableActivityDecay);
9734 if (HasMaxVariableActivityValue) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(MaxVariableActivityValue);
9735 if (HasGlucoseMaxDecay) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(GlucoseMaxDecay);
9736 if (HasGlucoseDecayIncrement) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(GlucoseDecayIncrement);
9737 if (HasGlucoseDecayIncrementPeriod) hash ^= GlucoseDecayIncrementPeriod.GetHashCode();
9738 if (HasClauseActivityDecay) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(ClauseActivityDecay);
9739 if (HasMaxClauseActivityValue) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(MaxClauseActivityValue);
9740 hash ^= restartAlgorithms_.GetHashCode();
9741 if (HasDefaultRestartAlgorithms) hash ^= DefaultRestartAlgorithms.GetHashCode();
9742 if (HasRestartPeriod) hash ^= RestartPeriod.GetHashCode();
9743 if (HasRestartRunningWindowSize) hash ^= RestartRunningWindowSize.GetHashCode();
9744 if (HasRestartDlAverageRatio) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(RestartDlAverageRatio);
9745 if (HasRestartLbdAverageRatio) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(RestartLbdAverageRatio);
9746 if (HasUseBlockingRestart) hash ^= UseBlockingRestart.GetHashCode();
9747 if (HasBlockingRestartWindowSize) hash ^= BlockingRestartWindowSize.GetHashCode();
9748 if (HasBlockingRestartMultiplier) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(BlockingRestartMultiplier);
9749 if (HasNumConflictsBeforeStrategyChanges) hash ^= NumConflictsBeforeStrategyChanges.GetHashCode();
9750 if (HasStrategyChangeIncreaseRatio) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(StrategyChangeIncreaseRatio);
9751 if (HasMaxTimeInSeconds) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(MaxTimeInSeconds);
9752 if (HasMaxDeterministicTime) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(MaxDeterministicTime);
9753 if (HasMaxNumDeterministicBatches) hash ^= MaxNumDeterministicBatches.GetHashCode();
9754 if (HasMaxNumberOfConflicts) hash ^= MaxNumberOfConflicts.GetHashCode();
9755 if (HasMaxMemoryInMb) hash ^= MaxMemoryInMb.GetHashCode();
9756 if (HasAbsoluteGapLimit) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(AbsoluteGapLimit);
9757 if (HasRelativeGapLimit) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(RelativeGapLimit);
9758 if (HasRandomSeed) hash ^= RandomSeed.GetHashCode();
9759 if (HasPermuteVariableRandomly) hash ^= PermuteVariableRandomly.GetHashCode();
9760 if (HasPermutePresolveConstraintOrder) hash ^= PermutePresolveConstraintOrder.GetHashCode();
9761 if (HasUseAbslRandom) hash ^= UseAbslRandom.GetHashCode();
9762 if (HasLogSearchProgress) hash ^= LogSearchProgress.GetHashCode();
9763 if (HasLogSubsolverStatistics) hash ^= LogSubsolverStatistics.GetHashCode();
9764 if (HasLogPrefix) hash ^= LogPrefix.GetHashCode();
9810 hash ^= subsolvers_.GetHashCode();
9811 hash ^= extraSubsolvers_.GetHashCode();
9812 hash ^= ignoreSubsolvers_.GetHashCode();
9813 hash ^= filterSubsolvers_.GetHashCode();
9814 hash ^= subsolverParams_.GetHashCode();
9986 if (_unknownFields !=
null) {
9987 hash ^= _unknownFields.GetHashCode();
9992 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
9993 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
9994 public override string ToString() {
9995 return pb::JsonFormatter.ToDiagnosticString(
this);
9998 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
9999 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
10000 public void WriteTo(pb::CodedOutputStream output) {
10001 #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
10002 output.WriteRawMessage(
this);
10004 if (HasPreferredVariableOrder) {
10005 output.WriteRawTag(8);
10006 output.WriteEnum((
int) PreferredVariableOrder);
10008 if (HasInitialPolarity) {
10009 output.WriteRawTag(16);
10010 output.WriteEnum((
int) InitialPolarity);
10012 if (HasMinimizationAlgorithm) {
10013 output.WriteRawTag(32);
10014 output.WriteEnum((
int) MinimizationAlgorithm);
10016 if (HasClauseCleanupPeriod) {
10017 output.WriteRawTag(88);
10018 output.WriteInt32(ClauseCleanupPeriod);
10020 if (HasClauseCleanupTarget) {
10021 output.WriteRawTag(104);
10022 output.WriteInt32(ClauseCleanupTarget);
10024 if (HasVariableActivityDecay) {
10025 output.WriteRawTag(121);
10026 output.WriteDouble(VariableActivityDecay);
10028 if (HasMaxVariableActivityValue) {
10029 output.WriteRawTag(129, 1);
10030 output.WriteDouble(MaxVariableActivityValue);
10032 if (HasClauseActivityDecay) {
10033 output.WriteRawTag(137, 1);
10034 output.WriteDouble(ClauseActivityDecay);
10036 if (HasMaxClauseActivityValue) {
10037 output.WriteRawTag(145, 1);
10038 output.WriteDouble(MaxClauseActivityValue);
10040 if (HasGlucoseMaxDecay) {
10041 output.WriteRawTag(177, 1);
10042 output.WriteDouble(GlucoseMaxDecay);
10044 if (HasGlucoseDecayIncrement) {
10045 output.WriteRawTag(185, 1);
10046 output.WriteDouble(GlucoseDecayIncrement);
10048 if (HasGlucoseDecayIncrementPeriod) {
10049 output.WriteRawTag(192, 1);
10052 if (HasRestartPeriod) {
10053 output.WriteRawTag(240, 1);
10054 output.WriteInt32(RestartPeriod);
10057 output.WriteRawTag(248, 1);
10060 if (HasRandomBranchesRatio) {
10061 output.WriteRawTag(129, 2);
10062 output.WriteDouble(RandomBranchesRatio);
10064 if (HasBinaryMinimizationAlgorithm) {
10065 output.WriteRawTag(144, 2);
10066 output.WriteEnum((
int) BinaryMinimizationAlgorithm);
10068 if (HasUseOptimizationHints) {
10069 output.WriteRawTag(152, 2);
10070 output.WriteBool(UseOptimizationHints);
10072 if (HasMaxTimeInSeconds) {
10073 output.WriteRawTag(161, 2);
10074 output.WriteDouble(MaxTimeInSeconds);
10076 if (HasMaxNumberOfConflicts) {
10077 output.WriteRawTag(168, 2);
10078 output.WriteInt64(MaxNumberOfConflicts);
10080 if (HasMaxMemoryInMb) {
10081 output.WriteRawTag(192, 2);
10082 output.WriteInt64(MaxMemoryInMb);
10084 if (HasLogSearchProgress) {
10085 output.WriteRawTag(200, 2);
10086 output.WriteBool(LogSearchProgress);
10088 if (HasUsePbResolution) {
10089 output.WriteRawTag(216, 2);
10090 output.WriteBool(UsePbResolution);
10092 if (HasUsePhaseSaving) {
10093 output.WriteRawTag(224, 2);
10094 output.WriteBool(UsePhaseSaving);
10096 if (HasRandomPolarityRatio) {
10097 output.WriteRawTag(233, 2);
10098 output.WriteDouble(RandomPolarityRatio);
10100 if (HasPbCleanupIncrement) {
10101 output.WriteRawTag(240, 2);
10102 output.WriteInt32(PbCleanupIncrement);
10104 if (HasPbCleanupRatio) {
10105 output.WriteRawTag(249, 2);
10106 output.WriteDouble(PbCleanupRatio);
10108 if (HasMinimizeReductionDuringPbResolution) {
10109 output.WriteRawTag(128, 3);
10110 output.WriteBool(MinimizeReductionDuringPbResolution);
10112 if (HasCountAssumptionLevelsInLbd) {
10113 output.WriteRawTag(136, 3);
10114 output.WriteBool(CountAssumptionLevelsInLbd);
10116 if (HasCoreMinimizationLevel) {
10117 output.WriteRawTag(144, 3);
10118 output.WriteInt32(CoreMinimizationLevel);
10120 if (HasMaxSatAssumptionOrder) {
10121 output.WriteRawTag(152, 3);
10122 output.WriteEnum((
int) MaxSatAssumptionOrder);
10124 if (HasMaxSatReverseAssumptionOrder) {
10125 output.WriteRawTag(160, 3);
10126 output.WriteBool(MaxSatReverseAssumptionOrder);
10128 if (HasMaxSatStratification) {
10129 output.WriteRawTag(168, 3);
10130 output.WriteEnum((
int) MaxSatStratification);
10132 if (HasPresolveBveThreshold) {
10133 output.WriteRawTag(176, 3);
10134 output.WriteInt32(PresolveBveThreshold);
10136 if (HasPresolveBveClauseWeight) {
10137 output.WriteRawTag(184, 3);
10138 output.WriteInt32(PresolveBveClauseWeight);
10140 if (HasSubsumptionDuringConflictAnalysis) {
10141 output.WriteRawTag(192, 3);
10142 output.WriteBool(SubsumptionDuringConflictAnalysis);
10144 if (HasPresolveProbingDeterministicTimeLimit) {
10145 output.WriteRawTag(201, 3);
10146 output.WriteDouble(PresolveProbingDeterministicTimeLimit);
10148 if (HasClauseCleanupProtection) {
10149 output.WriteRawTag(208, 3);
10150 output.WriteEnum((
int) ClauseCleanupProtection);
10152 if (HasClauseCleanupLbdBound) {
10153 output.WriteRawTag(216, 3);
10154 output.WriteInt32(ClauseCleanupLbdBound);
10156 if (HasClauseCleanupOrdering) {
10157 output.WriteRawTag(224, 3);
10158 output.WriteEnum((
int) ClauseCleanupOrdering);
10160 restartAlgorithms_.WriteTo(output, _repeated_restartAlgorithms_codec);
10161 if (HasRestartRunningWindowSize) {
10162 output.WriteRawTag(240, 3);
10163 output.WriteInt32(RestartRunningWindowSize);
10165 if (HasRestartDlAverageRatio) {
10166 output.WriteRawTag(249, 3);
10167 output.WriteDouble(RestartDlAverageRatio);
10169 if (HasUseBlockingRestart) {
10170 output.WriteRawTag(128, 4);
10171 output.WriteBool(UseBlockingRestart);
10173 if (HasBlockingRestartWindowSize) {
10174 output.WriteRawTag(136, 4);
10175 output.WriteInt32(BlockingRestartWindowSize);
10177 if (HasBlockingRestartMultiplier) {
10178 output.WriteRawTag(145, 4);
10179 output.WriteDouble(BlockingRestartMultiplier);
10181 if (HasMaxDeterministicTime) {
10182 output.WriteRawTag(153, 4);
10183 output.WriteDouble(MaxDeterministicTime);
10185 if (HasNumConflictsBeforeStrategyChanges) {
10186 output.WriteRawTag(160, 4);
10187 output.WriteInt32(NumConflictsBeforeStrategyChanges);
10189 if (HasStrategyChangeIncreaseRatio) {
10190 output.WriteRawTag(169, 4);
10191 output.WriteDouble(StrategyChangeIncreaseRatio);
10193 if (HasDefaultRestartAlgorithms) {
10194 output.WriteRawTag(178, 4);
10195 output.WriteString(DefaultRestartAlgorithms);
10197 if (HasRestartLbdAverageRatio) {
10198 output.WriteRawTag(185, 4);
10199 output.WriteDouble(RestartLbdAverageRatio);
10201 if (HasPresolveUseBva) {
10202 output.WriteRawTag(192, 4);
10203 output.WriteBool(PresolveUseBva);
10205 if (HasPresolveBvaThreshold) {
10206 output.WriteRawTag(200, 4);
10207 output.WriteInt32(PresolveBvaThreshold);
10209 if (HasUsePrecedencesInDisjunctiveConstraint) {
10210 output.WriteRawTag(208, 4);
10211 output.WriteBool(UsePrecedencesInDisjunctiveConstraint);
10213 if (HasUseErwaHeuristic) {
10214 output.WriteRawTag(216, 4);
10215 output.WriteBool(UseErwaHeuristic);
10217 if (HasInitialVariablesActivity) {
10218 output.WriteRawTag(225, 4);
10219 output.WriteDouble(InitialVariablesActivity);
10221 if (HasAlsoBumpVariablesInConflictReasons) {
10222 output.WriteRawTag(232, 4);
10223 output.WriteBool(AlsoBumpVariablesInConflictReasons);
10225 if (HasUseOverloadCheckerInCumulative) {
10226 output.WriteRawTag(240, 4);
10227 output.WriteBool(UseOverloadCheckerInCumulative);
10229 if (HasUseTimetableEdgeFindingInCumulative) {
10230 output.WriteRawTag(248, 4);
10231 output.WriteBool(UseTimetableEdgeFindingInCumulative);
10233 if (HasUseDisjunctiveConstraintInCumulative) {
10234 output.WriteRawTag(128, 5);
10235 output.WriteBool(UseDisjunctiveConstraintInCumulative);
10237 if (HasSearchBranching) {
10238 output.WriteRawTag(144, 5);
10239 output.WriteEnum((
int) SearchBranching);
10241 if (HasOptimizeWithCore) {
10242 output.WriteRawTag(152, 5);
10243 output.WriteBool(OptimizeWithCore);
10245 if (HasFindMultipleCores) {
10246 output.WriteRawTag(160, 5);
10247 output.WriteBool(FindMultipleCores);
10249 if (HasOptimizeWithMaxHs) {
10250 output.WriteRawTag(168, 5);
10251 output.WriteBool(OptimizeWithMaxHs);
10253 if (HasCpModelPresolve) {
10254 output.WriteRawTag(176, 5);
10255 output.WriteBool(CpModelPresolve);
10257 if (HasEnumerateAllSolutions) {
10258 output.WriteRawTag(184, 5);
10259 output.WriteBool(EnumerateAllSolutions);
10261 if (HasPresolveBlockedClause) {
10262 output.WriteRawTag(192, 5);
10263 output.WriteBool(PresolveBlockedClause);
10265 if (HasCoverOptimization) {
10266 output.WriteRawTag(200, 5);
10267 output.WriteBool(CoverOptimization);
10269 if (HasLinearizationLevel) {
10270 output.WriteRawTag(208, 5);
10271 output.WriteInt32(LinearizationLevel);
10273 if (HasMaxNumCuts) {
10274 output.WriteRawTag(216, 5);
10275 output.WriteInt32(MaxNumCuts);
10277 if (HasOnlyAddCutsAtLevelZero) {
10278 output.WriteRawTag(224, 5);
10279 output.WriteBool(OnlyAddCutsAtLevelZero);
10281 if (HasCpModelUseSatPresolve) {
10282 output.WriteRawTag(232, 5);
10283 output.WriteBool(CpModelUseSatPresolve);
10285 if (HasExploitIntegerLpSolution) {
10286 output.WriteRawTag(240, 5);
10287 output.WriteBool(ExploitIntegerLpSolution);
10289 if (HasAutoDetectGreaterThanAtLeastOneOf) {
10290 output.WriteRawTag(248, 5);
10291 output.WriteBool(AutoDetectGreaterThanAtLeastOneOf);
10293 if (HasStopAfterFirstSolution) {
10294 output.WriteRawTag(144, 6);
10295 output.WriteBool(StopAfterFirstSolution);
10297 if (HasBinarySearchNumConflicts) {
10298 output.WriteRawTag(152, 6);
10299 output.WriteInt32(BinarySearchNumConflicts);
10301 if (HasNumSearchWorkers) {
10302 output.WriteRawTag(160, 6);
10303 output.WriteInt32(NumSearchWorkers);
10305 if (HasUseLnsOnly) {
10306 output.WriteRawTag(168, 6);
10307 output.WriteBool(UseLnsOnly);
10309 if (HasRandomizeSearch) {
10310 output.WriteRawTag(184, 6);
10311 output.WriteBool(RandomizeSearch);
10313 if (HasSearchRandomVariablePoolSize) {
10314 output.WriteRawTag(192, 6);
10315 output.WriteInt64(SearchRandomVariablePoolSize);
10317 if (HasInstantiateAllVariables) {
10318 output.WriteRawTag(208, 6);
10319 output.WriteBool(InstantiateAllVariables);
10321 if (HasBooleanEncodingLevel) {
10322 output.WriteRawTag(216, 6);
10323 output.WriteInt32(BooleanEncodingLevel);
10325 if (HasUseOptionalVariables) {
10326 output.WriteRawTag(224, 6);
10327 output.WriteBool(UseOptionalVariables);
10329 if (HasUseExactLpReason) {
10330 output.WriteRawTag(232, 6);
10331 output.WriteBool(UseExactLpReason);
10333 if (HasCpModelProbingLevel) {
10334 output.WriteRawTag(240, 6);
10335 output.WriteInt32(CpModelProbingLevel);
10337 if (HasAddLpConstraintsLazily) {
10338 output.WriteRawTag(128, 7);
10339 output.WriteBool(AddLpConstraintsLazily);
10341 if (HasShareObjectiveBounds) {
10342 output.WriteRawTag(136, 7);
10343 output.WriteBool(ShareObjectiveBounds);
10345 if (HasShareLevelZeroBounds) {
10346 output.WriteRawTag(144, 7);
10347 output.WriteBool(ShareLevelZeroBounds);
10349 if (HasMinOrthogonalityForLpConstraints) {
10350 output.WriteRawTag(153, 7);
10351 output.WriteDouble(MinOrthogonalityForLpConstraints);
10353 if (HasExploitAllLpSolution) {
10354 output.WriteRawTag(160, 7);
10355 output.WriteBool(ExploitAllLpSolution);
10357 if (HasAddCgCuts) {
10358 output.WriteRawTag(168, 7);
10359 output.WriteBool(AddCgCuts);
10361 if (HasMaxIntegerRoundingScaling) {
10362 output.WriteRawTag(184, 7);
10363 output.WriteInt32(MaxIntegerRoundingScaling);
10365 if (HasAddMirCuts) {
10366 output.WriteRawTag(192, 7);
10367 output.WriteBool(AddMirCuts);
10369 if (HasMaxConsecutiveInactiveCount) {
10370 output.WriteRawTag(200, 7);
10371 output.WriteInt32(MaxConsecutiveInactiveCount);
10373 if (HasNewConstraintsBatchSize) {
10374 output.WriteRawTag(208, 7);
10375 output.WriteInt32(NewConstraintsBatchSize);
10377 if (HasPseudoCostReliabilityThreshold) {
10378 output.WriteRawTag(216, 7);
10379 output.WriteInt64(PseudoCostReliabilityThreshold);
10381 if (HasMipMaxBound) {
10382 output.WriteRawTag(225, 7);
10383 output.WriteDouble(MipMaxBound);
10385 if (HasMipVarScaling) {
10386 output.WriteRawTag(233, 7);
10387 output.WriteDouble(MipVarScaling);
10389 if (HasMipWantedPrecision) {
10390 output.WriteRawTag(241, 7);
10391 output.WriteDouble(MipWantedPrecision);
10393 if (HasMipMaxActivityExponent) {
10394 output.WriteRawTag(248, 7);
10395 output.WriteInt32(MipMaxActivityExponent);
10397 if (HasMipCheckPrecision) {
10398 output.WriteRawTag(129, 8);
10399 output.WriteDouble(MipCheckPrecision);
10401 if (HasUseRinsLns) {
10402 output.WriteRawTag(136, 8);
10403 output.WriteBool(UseRinsLns);
10405 if (HasExploitBestSolution) {
10406 output.WriteRawTag(144, 8);
10407 output.WriteBool(ExploitBestSolution);
10409 if (HasExploitObjective) {
10410 output.WriteRawTag(152, 8);
10411 output.WriteBool(ExploitObjective);
10413 if (HasFillTightenedDomainsInResponse) {
10414 output.WriteRawTag(160, 8);
10415 output.WriteBool(FillTightenedDomainsInResponse);
10417 if (HasUseCombinedNoOverlap) {
10418 output.WriteRawTag(168, 8);
10419 output.WriteBool(UseCombinedNoOverlap);
10421 if (HasInterleaveBatchSize) {
10422 output.WriteRawTag(176, 8);
10423 output.WriteInt32(InterleaveBatchSize);
10425 if (HasCatchSigintSignal) {
10426 output.WriteRawTag(184, 8);
10427 output.WriteBool(CatchSigintSignal);
10429 if (HasInterleaveSearch) {
10430 output.WriteRawTag(192, 8);
10431 output.WriteBool(InterleaveSearch);
10433 if (HasDiversifyLnsParams) {
10434 output.WriteRawTag(200, 8);
10435 output.WriteBool(DiversifyLnsParams);
10437 if (HasMaxPresolveIterations) {
10438 output.WriteRawTag(208, 8);
10439 output.WriteInt32(MaxPresolveIterations);
10441 if (HasUseImpliedBounds) {
10442 output.WriteRawTag(128, 9);
10443 output.WriteBool(UseImpliedBounds);
10445 if (HasMergeNoOverlapWorkLimit) {
10446 output.WriteRawTag(137, 9);
10447 output.WriteDouble(MergeNoOverlapWorkLimit);
10449 if (HasMergeAtMostOneWorkLimit) {
10450 output.WriteRawTag(145, 9);
10451 output.WriteDouble(MergeAtMostOneWorkLimit);
10453 if (HasPresolveSubstitutionLevel) {
10454 output.WriteRawTag(152, 9);
10455 output.WriteInt32(PresolveSubstitutionLevel);
10457 if (HasMaxAllDiffCutSize) {
10458 output.WriteRawTag(160, 9);
10459 output.WriteInt32(MaxAllDiffCutSize);
10461 if (HasStopAfterPresolve) {
10462 output.WriteRawTag(168, 9);
10463 output.WriteBool(StopAfterPresolve);
10465 if (HasDebugMaxNumPresolveOperations) {
10466 output.WriteRawTag(184, 9);
10467 output.WriteInt32(DebugMaxNumPresolveOperations);
10469 if (HasAddLinMaxCuts) {
10470 output.WriteRawTag(192, 9);
10471 output.WriteBool(AddLinMaxCuts);
10473 if (HasHintConflictLimit) {
10474 output.WriteRawTag(200, 9);
10475 output.WriteInt32(HintConflictLimit);
10477 if (HasMaxCutRoundsAtLevelZero) {
10478 output.WriteRawTag(208, 9);
10479 output.WriteInt32(MaxCutRoundsAtLevelZero);
10481 if (HasCutMaxActiveCountValue) {
10482 output.WriteRawTag(217, 9);
10483 output.WriteDouble(CutMaxActiveCountValue);
10485 if (HasCutActiveCountDecay) {
10486 output.WriteRawTag(225, 9);
10487 output.WriteDouble(CutActiveCountDecay);
10489 if (HasCutCleanupTarget) {
10490 output.WriteRawTag(232, 9);
10491 output.WriteInt32(CutCleanupTarget);
10493 if (HasAbsoluteGapLimit) {
10494 output.WriteRawTag(249, 9);
10495 output.WriteDouble(AbsoluteGapLimit);
10497 if (HasRelativeGapLimit) {
10498 output.WriteRawTag(129, 10);
10499 output.WriteDouble(RelativeGapLimit);
10501 if (HasExploitRelaxationSolution) {
10502 output.WriteRawTag(136, 10);
10503 output.WriteBool(ExploitRelaxationSolution);
10505 if (HasDebugPostsolveWithFullSolver) {
10506 output.WriteRawTag(144, 10);
10507 output.WriteBool(DebugPostsolveWithFullSolver);
10509 if (HasUseSatInprocessing) {
10510 output.WriteRawTag(152, 10);
10511 output.WriteBool(UseSatInprocessing);
10513 if (HasUseFeasibilityPump) {
10514 output.WriteRawTag(160, 10);
10515 output.WriteBool(UseFeasibilityPump);
10517 if (HasFpRounding) {
10518 output.WriteRawTag(168, 10);
10519 output.WriteEnum((
int) FpRounding);
10521 if (HasMipAutomaticallyScaleVariables) {
10522 output.WriteRawTag(176, 10);
10523 output.WriteBool(MipAutomaticallyScaleVariables);
10525 if (HasRepairHint) {
10526 output.WriteRawTag(184, 10);
10527 output.WriteBool(RepairHint);
10529 if (HasPolarityRephaseIncrement) {
10530 output.WriteRawTag(192, 10);
10531 output.WriteInt32(PolarityRephaseIncrement);
10533 if (HasAddZeroHalfCuts) {
10534 output.WriteRawTag(200, 10);
10535 output.WriteBool(AddZeroHalfCuts);
10537 if (HasExpandAlldiffConstraints) {
10538 output.WriteRawTag(208, 10);
10539 output.WriteBool(ExpandAlldiffConstraints);
10542 output.WriteRawTag(218, 10);
10543 output.WriteString(Name);
10545 if (HasAddCliqueCuts) {
10546 output.WriteRawTag(224, 10);
10547 output.WriteBool(AddCliqueCuts);
10549 if (HasKeepAllFeasibleSolutionsInPresolve) {
10550 output.WriteRawTag(232, 10);
10551 output.WriteBool(KeepAllFeasibleSolutionsInPresolve);
10553 if (HasPresolveExtractIntegerEnforcement) {
10554 output.WriteRawTag(240, 10);
10555 output.WriteBool(PresolveExtractIntegerEnforcement);
10557 if (HasPolishLpSolution) {
10558 output.WriteRawTag(248, 10);
10559 output.WriteBool(PolishLpSolution);
10561 if (HasUseProbingSearch) {
10562 output.WriteRawTag(128, 11);
10563 output.WriteBool(UseProbingSearch);
10565 if (HasConvertIntervals) {
10566 output.WriteRawTag(136, 11);
10567 output.WriteBool(ConvertIntervals);
10569 if (HasPermuteVariableRandomly) {
10570 output.WriteRawTag(144, 11);
10571 output.WriteBool(PermuteVariableRandomly);
10573 if (HasPermutePresolveConstraintOrder) {
10574 output.WriteRawTag(152, 11);
10575 output.WriteBool(PermutePresolveConstraintOrder);
10577 if (HasUseAbslRandom) {
10578 output.WriteRawTag(160, 11);
10579 output.WriteBool(UseAbslRandom);
10581 if (HasDisableConstraintExpansion) {
10582 output.WriteRawTag(168, 11);
10583 output.WriteBool(DisableConstraintExpansion);
10585 if (HasExpandReservoirConstraints) {
10586 output.WriteRawTag(176, 11);
10587 output.WriteBool(ExpandReservoirConstraints);
10589 if (HasSymmetryLevel) {
10590 output.WriteRawTag(184, 11);
10591 output.WriteInt32(SymmetryLevel);
10593 if (HasLogPrefix) {
10594 output.WriteRawTag(202, 11);
10595 output.WriteString(LogPrefix);
10597 if (HasLogToStdout) {
10598 output.WriteRawTag(208, 11);
10599 output.WriteBool(LogToStdout);
10601 if (HasLogToResponse) {
10602 output.WriteRawTag(216, 11);
10603 output.WriteBool(LogToResponse);
10605 if (HasOptimizeWithLbTreeSearch) {
10606 output.WriteRawTag(224, 11);
10607 output.WriteBool(OptimizeWithLbTreeSearch);
10609 if (HasLogSubsolverStatistics) {
10610 output.WriteRawTag(232, 11);
10611 output.WriteBool(LogSubsolverStatistics);
10613 if (HasClauseCleanupRatio) {
10614 output.WriteRawTag(241, 11);
10615 output.WriteDouble(ClauseCleanupRatio);
10617 if (HasMaxDomainSizeWhenEncodingEqNeqConstraints) {
10618 output.WriteRawTag(248, 11);
10619 output.WriteInt32(MaxDomainSizeWhenEncodingEqNeqConstraints);
10621 if (HasFixVariablesToTheirHintedValue) {
10622 output.WriteRawTag(128, 12);
10623 output.WriteBool(FixVariablesToTheirHintedValue);
10625 if (HasSolutionPoolSize) {
10626 output.WriteRawTag(136, 12);
10627 output.WriteInt32(SolutionPoolSize);
10629 if (HasFillAdditionalSolutionsInResponse) {
10630 output.WriteRawTag(144, 12);
10631 output.WriteBool(FillAdditionalSolutionsInResponse);
10633 if (HasDebugCrashOnBadHint) {
10634 output.WriteRawTag(152, 12);
10635 output.WriteBool(DebugCrashOnBadHint);
10638 output.WriteRawTag(160, 12);
10639 output.WriteInt32(CutLevel);
10641 if (HasAddObjectiveCut) {
10642 output.WriteRawTag(168, 12);
10643 output.WriteBool(AddObjectiveCut);
10645 if (HasMipComputeTrueObjectiveBound) {
10646 output.WriteRawTag(176, 12);
10647 output.WriteBool(MipComputeTrueObjectiveBound);
10649 if (HasMipMaxValidMagnitude) {
10650 output.WriteRawTag(185, 12);
10651 output.WriteDouble(MipMaxValidMagnitude);
10653 if (HasUseTimetablingInNoOverlap2D) {
10654 output.WriteRawTag(192, 12);
10655 output.WriteBool(UseTimetablingInNoOverlap2D);
10657 if (HasPresolveInclusionWorkLimit) {
10658 output.WriteRawTag(200, 12);
10659 output.WriteInt64(PresolveInclusionWorkLimit);
10661 if (HasIgnoreNames) {
10662 output.WriteRawTag(208, 12);
10663 output.WriteBool(IgnoreNames);
10665 if (HasShareBinaryClauses) {
10666 output.WriteRawTag(216, 12);
10667 output.WriteBool(ShareBinaryClauses);
10669 if (HasShavingDeterministicTimeInProbingSearch) {
10670 output.WriteRawTag(225, 12);
10671 output.WriteDouble(ShavingDeterministicTimeInProbingSearch);
10673 if (HasShavingSearchDeterministicTime) {
10674 output.WriteRawTag(233, 12);
10675 output.WriteDouble(ShavingSearchDeterministicTime);
10677 if (HasNumWorkers) {
10678 output.WriteRawTag(240, 12);
10679 output.WriteInt32(NumWorkers);
10681 subsolvers_.WriteTo(output, _repeated_subsolvers_codec);
10682 ignoreSubsolvers_.WriteTo(output, _repeated_ignoreSubsolvers_codec);
10683 subsolverParams_.WriteTo(output, _repeated_subsolverParams_codec);
10684 if (HasUseEnergeticReasoningInNoOverlap2D) {
10685 output.WriteRawTag(168, 13);
10686 output.WriteBool(UseEnergeticReasoningInNoOverlap2D);
10688 if (HasUseDualSchedulingHeuristics) {
10689 output.WriteRawTag(176, 13);
10690 output.WriteBool(UseDualSchedulingHeuristics);
10692 if (HasUseHardPrecedencesInCumulative) {
10693 output.WriteRawTag(184, 13);
10694 output.WriteBool(UseHardPrecedencesInCumulative);
10696 if (HasDetectTableWithCost) {
10697 output.WriteRawTag(192, 13);
10698 output.WriteBool(DetectTableWithCost);
10700 if (HasTableCompressionLevel) {
10701 output.WriteRawTag(200, 13);
10702 output.WriteInt32(TableCompressionLevel);
10704 extraSubsolvers_.WriteTo(output, _repeated_extraSubsolvers_codec);
10705 if (HasExploitAllPrecedences) {
10706 output.WriteRawTag(224, 13);
10707 output.WriteBool(ExploitAllPrecedences);
10709 if (HasPropagationLoopDetectionFactor) {
10710 output.WriteRawTag(233, 13);
10711 output.WriteDouble(PropagationLoopDetectionFactor);
10713 if (HasOnlySolveIp) {
10714 output.WriteRawTag(240, 13);
10715 output.WriteBool(OnlySolveIp);
10717 if (HasEncodeComplexLinearConstraintWithInteger) {
10718 output.WriteRawTag(248, 13);
10719 output.WriteBool(EncodeComplexLinearConstraintWithInteger);
10721 if (HasNewLinearPropagation) {
10722 output.WriteRawTag(128, 14);
10723 output.WriteBool(NewLinearPropagation);
10725 if (HasMipScaleLargeDomain) {
10726 output.WriteRawTag(136, 14);
10727 output.WriteBool(MipScaleLargeDomain);
10729 if (HasProbingDeterministicTimeLimit) {
10730 output.WriteRawTag(145, 14);
10731 output.WriteDouble(ProbingDeterministicTimeLimit);
10733 if (HasRootLpIterations) {
10734 output.WriteRawTag(152, 14);
10735 output.WriteInt32(RootLpIterations);
10737 if (HasUseObjectiveLbSearch) {
10738 output.WriteRawTag(160, 14);
10739 output.WriteBool(UseObjectiveLbSearch);
10741 if (HasMaxSizeToCreatePrecedenceLiteralsInDisjunctive) {
10742 output.WriteRawTag(168, 14);
10743 output.WriteInt32(MaxSizeToCreatePrecedenceLiteralsInDisjunctive);
10745 if (HasUseStrongPropagationInDisjunctive) {
10746 output.WriteRawTag(176, 14);
10747 output.WriteBool(UseStrongPropagationInDisjunctive);
10749 if (HasMipDropTolerance) {
10750 output.WriteRawTag(193, 14);
10751 output.WriteDouble(MipDropTolerance);
10753 if (HasInferAllDiffs) {
10754 output.WriteRawTag(200, 14);
10755 output.WriteBool(InferAllDiffs);
10757 if (HasFindBigLinearOverlap) {
10758 output.WriteRawTag(208, 14);
10759 output.WriteBool(FindBigLinearOverlap);
10761 if (HasSharedTreeNumWorkers) {
10762 output.WriteRawTag(216, 14);
10763 output.WriteInt32(SharedTreeNumWorkers);
10765 if (HasUseSharedTreeSearch) {
10766 output.WriteRawTag(224, 14);
10767 output.WriteBool(UseSharedTreeSearch);
10769 if (HasSharedTreeMaxNodesPerWorker) {
10770 output.WriteRawTag(240, 14);
10771 output.WriteInt32(SharedTreeMaxNodesPerWorker);
10773 if (HasSharedTreeSplitStrategy) {
10774 output.WriteRawTag(248, 14);
10775 output.WriteEnum((
int) SharedTreeSplitStrategy);
10777 if (HasUseLsOnly) {
10778 output.WriteRawTag(128, 15);
10779 output.WriteBool(UseLsOnly);
10781 if (HasFeasibilityJumpDecay) {
10782 output.WriteRawTag(145, 15);
10783 output.WriteDouble(FeasibilityJumpDecay);
10785 if (HasNumViolationLs) {
10786 output.WriteRawTag(160, 15);
10787 output.WriteInt32(NumViolationLs);
10789 if (HasFeasibilityJumpVarRandomizationProbability) {
10790 output.WriteRawTag(185, 15);
10791 output.WriteDouble(FeasibilityJumpVarRandomizationProbability);
10793 if (HasFeasibilityJumpVarPerburbationRangeRatio) {
10794 output.WriteRawTag(193, 15);
10795 output.WriteDouble(FeasibilityJumpVarPerburbationRangeRatio);
10797 if (HasViolationLsPerturbationPeriod) {
10798 output.WriteRawTag(200, 15);
10799 output.WriteInt32(ViolationLsPerturbationPeriod);
10801 if (HasFeasibilityJumpEnableRestarts) {
10802 output.WriteRawTag(208, 15);
10803 output.WriteBool(FeasibilityJumpEnableRestarts);
10805 if (HasStopAfterRootPropagation) {
10806 output.WriteRawTag(224, 15);
10807 output.WriteBool(StopAfterRootPropagation);
10809 if (HasUseObjectiveShavingSearch) {
10810 output.WriteRawTag(232, 15);
10811 output.WriteBool(UseObjectiveShavingSearch);
10813 if (HasUseLbRelaxLns) {
10814 output.WriteRawTag(248, 15);
10815 output.WriteBool(UseLbRelaxLns);
10817 if (HasLinearSplitSize) {
10818 output.WriteRawTag(128, 16);
10819 output.WriteInt32(LinearSplitSize);
10821 if (HasFeasibilityJumpLinearizationLevel) {
10822 output.WriteRawTag(136, 16);
10823 output.WriteInt32(FeasibilityJumpLinearizationLevel);
10825 if (HasFeasibilityJumpRestartFactor) {
10826 output.WriteRawTag(144, 16);
10827 output.WriteInt32(FeasibilityJumpRestartFactor);
10829 if (HasViolationLsCompoundMoveProbability) {
10830 output.WriteRawTag(153, 16);
10831 output.WriteDouble(ViolationLsCompoundMoveProbability);
10833 if (HasMaxNumIntervalsForTimetableEdgeFinding) {
10834 output.WriteRawTag(160, 16);
10835 output.WriteInt32(MaxNumIntervalsForTimetableEdgeFinding);
10837 if (HasMipPresolveLevel) {
10838 output.WriteRawTag(168, 16);
10839 output.WriteInt32(MipPresolveLevel);
10841 if (HasPushAllTasksTowardStart) {
10842 output.WriteRawTag(176, 16);
10843 output.WriteBool(PushAllTasksTowardStart);
10845 if (HasUseDynamicPrecedenceInDisjunctive) {
10846 output.WriteRawTag(184, 16);
10847 output.WriteBool(UseDynamicPrecedenceInDisjunctive);
10849 if (HasFeasibilityJumpMaxExpandedConstraintSize) {
10850 output.WriteRawTag(192, 16);
10851 output.WriteInt32(FeasibilityJumpMaxExpandedConstraintSize);
10853 if (HasUseFeasibilityJump) {
10854 output.WriteRawTag(200, 16);
10855 output.WriteBool(UseFeasibilityJump);
10857 if (HasLpPrimalTolerance) {
10858 output.WriteRawTag(209, 16);
10859 output.WriteDouble(LpPrimalTolerance);
10861 if (HasLpDualTolerance) {
10862 output.WriteRawTag(217, 16);
10863 output.WriteDouble(LpDualTolerance);
10865 if (HasUseDynamicPrecedenceInCumulative) {
10866 output.WriteRawTag(224, 16);
10867 output.WriteBool(UseDynamicPrecedenceInCumulative);
10869 if (HasUseExtendedProbing) {
10870 output.WriteRawTag(232, 16);
10871 output.WriteBool(UseExtendedProbing);
10873 if (HasAtMostOneMaxExpansionSize) {
10874 output.WriteRawTag(240, 16);
10875 output.WriteInt32(AtMostOneMaxExpansionSize);
10877 if (HasUseAreaEnergeticReasoningInNoOverlap2D) {
10878 output.WriteRawTag(248, 16);
10879 output.WriteBool(UseAreaEnergeticReasoningInNoOverlap2D);
10881 if (HasProbingNumCombinationsLimit) {
10882 output.WriteRawTag(128, 17);
10883 output.WriteInt32(ProbingNumCombinationsLimit);
10885 if (HasInprocessingDtimeRatio) {
10886 output.WriteRawTag(137, 17);
10887 output.WriteDouble(InprocessingDtimeRatio);
10889 if (HasInprocessingProbingDtime) {
10890 output.WriteRawTag(145, 17);
10891 output.WriteDouble(InprocessingProbingDtime);
10893 if (HasInprocessingMinimizationDtime) {
10894 output.WriteRawTag(153, 17);
10895 output.WriteDouble(InprocessingMinimizationDtime);
10897 if (HasMaxPairsPairwiseReasoningInNoOverlap2D) {
10898 output.WriteRawTag(160, 17);
10899 output.WriteInt32(MaxPairsPairwiseReasoningInNoOverlap2D);
10901 if (HasDetectLinearizedProduct) {
10902 output.WriteRawTag(168, 17);
10903 output.WriteBool(DetectLinearizedProduct);
10905 if (HasMipTreatHighMagnitudeBoundsAsInfinity) {
10906 output.WriteRawTag(176, 17);
10907 output.WriteBool(MipTreatHighMagnitudeBoundsAsInfinity);
10909 if (HasAddRltCuts) {
10910 output.WriteRawTag(184, 17);
10911 output.WriteBool(AddRltCuts);
10913 if (HasMaxLinMaxSizeForExpansion) {
10914 output.WriteRawTag(192, 17);
10915 output.WriteInt32(MaxLinMaxSizeForExpansion);
10917 if (HasSharedTreeOpenLeavesPerWorker) {
10918 output.WriteRawTag(201, 17);
10919 output.WriteDouble(SharedTreeOpenLeavesPerWorker);
10921 if (HasSharedTreeWorkerMinRestartsPerSubtree) {
10922 output.WriteRawTag(208, 17);
10923 output.WriteInt32(SharedTreeWorkerMinRestartsPerSubtree);
10926 output.WriteRawTag(216, 17);
10927 output.WriteBool(UseLns);
10929 if (HasSaveLpBasisInLbTreeSearch) {
10930 output.WriteRawTag(224, 17);
10931 output.WriteBool(SaveLpBasisInLbTreeSearch);
10933 if (HasShareGlueClauses) {
10934 output.WriteRawTag(232, 17);
10935 output.WriteBool(ShareGlueClauses);
10937 if (HasUseConservativeScaleOverloadChecker) {
10938 output.WriteRawTag(240, 17);
10939 output.WriteBool(UseConservativeScaleOverloadChecker);
10941 if (HasEncodeCumulativeAsReservoir) {
10942 output.WriteRawTag(248, 17);
10943 output.WriteBool(EncodeCumulativeAsReservoir);
10945 if (HasExpandReservoirUsingCircuit) {
10946 output.WriteRawTag(128, 18);
10947 output.WriteBool(ExpandReservoirUsingCircuit);
10949 if (HasVariablesShavingLevel) {
10950 output.WriteRawTag(136, 18);
10951 output.WriteInt32(VariablesShavingLevel);
10953 if (HasShavingSearchThreshold) {
10954 output.WriteRawTag(144, 18);
10955 output.WriteInt64(ShavingSearchThreshold);
10957 if (HasMaxNumDeterministicBatches) {
10958 output.WriteRawTag(152, 18);
10959 output.WriteInt32(MaxNumDeterministicBatches);
10961 if (HasFeasibilityJumpBatchDtime) {
10962 output.WriteRawTag(161, 18);
10963 output.WriteDouble(FeasibilityJumpBatchDtime);
10965 filterSubsolvers_.WriteTo(output, _repeated_filterSubsolvers_codec);
10966 if (HasNumFullSubsolvers) {
10967 output.WriteRawTag(176, 18);
10968 output.WriteInt32(NumFullSubsolvers);
10970 if (HasSharedTreeWorkerEnableTrailSharing) {
10971 output.WriteRawTag(184, 18);
10972 output.WriteBool(SharedTreeWorkerEnableTrailSharing);
10974 if (HasLbRelaxNumWorkersThreshold) {
10975 output.WriteRawTag(192, 18);
10976 output.WriteInt32(LbRelaxNumWorkersThreshold);
10978 if (HasInprocessingMinimizationUseConflictAnalysis) {
10979 output.WriteRawTag(200, 18);
10980 output.WriteBool(InprocessingMinimizationUseConflictAnalysis);
10982 if (HasInprocessingMinimizationUseAllOrderings) {
10983 output.WriteRawTag(208, 18);
10984 output.WriteBool(InprocessingMinimizationUseAllOrderings);
10986 if (HasUseTryEdgeReasoningInNoOverlap2D) {
10987 output.WriteRawTag(216, 18);
10988 output.WriteBool(UseTryEdgeReasoningInNoOverlap2D);
10990 if (HasMinimizeSharedClauses) {
10991 output.WriteRawTag(224, 18);
10992 output.WriteBool(MinimizeSharedClauses);
10994 if (HasUseSymmetryInLp) {
10995 output.WriteRawTag(232, 18);
10996 output.WriteBool(UseSymmetryInLp);
10998 if (HasSymmetryDetectionDeterministicTimeLimit) {
10999 output.WriteRawTag(241, 18);
11000 output.WriteDouble(SymmetryDetectionDeterministicTimeLimit);
11002 if (HasKeepSymmetryInPresolve) {
11003 output.WriteRawTag(248, 18);
11004 output.WriteBool(KeepSymmetryInPresolve);
11006 if (HasSharedTreeWorkerEnablePhaseSharing) {
11007 output.WriteRawTag(128, 19);
11008 output.WriteBool(SharedTreeWorkerEnablePhaseSharing);
11010 if (HasSharedTreeBalanceTolerance) {
11011 output.WriteRawTag(136, 19);
11012 output.WriteInt32(SharedTreeBalanceTolerance);
11014 if (HasDebugCrashIfPresolveBreaksHint) {
11015 output.WriteRawTag(144, 19);
11016 output.WriteBool(DebugCrashIfPresolveBreaksHint);
11018 if (HasLnsInitialDifficulty) {
11019 output.WriteRawTag(153, 19);
11020 output.WriteDouble(LnsInitialDifficulty);
11022 if (HasLnsInitialDeterministicLimit) {
11023 output.WriteRawTag(161, 19);
11024 output.WriteDouble(LnsInitialDeterministicLimit);
11026 if (HasPolarityExploitLsHints) {
11027 output.WriteRawTag(168, 19);
11028 output.WriteBool(PolarityExploitLsHints);
11030 if (HasRemoveFixedVariablesEarly) {
11031 output.WriteRawTag(176, 19);
11032 output.WriteBool(RemoveFixedVariablesEarly);
11034 if (HasUseAllDifferentForCircuit) {
11035 output.WriteRawTag(184, 19);
11036 output.WriteBool(UseAllDifferentForCircuit);
11038 if (HasRoutingCutSubsetSizeForBinaryRelationBound) {
11039 output.WriteRawTag(192, 19);
11040 output.WriteInt32(RoutingCutSubsetSizeForBinaryRelationBound);
11042 if (HasRoutingCutSubsetSizeForTightBinaryRelationBound) {
11043 output.WriteRawTag(200, 19);
11044 output.WriteInt32(RoutingCutSubsetSizeForTightBinaryRelationBound);
11046 if (HasRoutingCutDpEffort) {
11047 output.WriteRawTag(209, 19);
11048 output.WriteDouble(RoutingCutDpEffort);
11050 if (HasMaximumRegionsToSplitInDisconnectedNoOverlap2D) {
11051 output.WriteRawTag(216, 19);
11052 output.WriteInt32(MaximumRegionsToSplitInDisconnectedNoOverlap2D);
11054 if (HasRoutingCutSubsetSizeForExactBinaryRelationBound) {
11055 output.WriteRawTag(224, 19);
11056 output.WriteInt32(RoutingCutSubsetSizeForExactBinaryRelationBound);
11058 if (HasRoutingCutMaxInfeasiblePathLength) {
11059 output.WriteRawTag(232, 19);
11060 output.WriteInt32(RoutingCutMaxInfeasiblePathLength);
11062 if (HasRoutingCutSubsetSizeForShortestPathsBound) {
11063 output.WriteRawTag(240, 19);
11064 output.WriteInt32(RoutingCutSubsetSizeForShortestPathsBound);
11066 if (HasMaxAlldiffDomainSize) {
11067 output.WriteRawTag(128, 20);
11068 output.WriteInt32(MaxAlldiffDomainSize);
11070 if (HasNoOverlap2DBooleanRelationsLimit) {
11071 output.WriteRawTag(136, 20);
11072 output.WriteInt32(NoOverlap2DBooleanRelationsLimit);
11074 if (HasShareGlueClausesDtime) {
11075 output.WriteRawTag(145, 20);
11076 output.WriteDouble(ShareGlueClausesDtime);
11078 if (HasUseLinear3ForNoOverlap2DPrecedences) {
11079 output.WriteRawTag(152, 20);
11080 output.WriteBool(UseLinear3ForNoOverlap2DPrecedences);
11082 if (HasFilterSatPostsolveClauses) {
11083 output.WriteRawTag(160, 20);
11084 output.WriteBool(FilterSatPostsolveClauses);
11086 if (_unknownFields !=
null) {
11087 _unknownFields.WriteTo(output);
11092 #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
11093 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
11094 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
11095 void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
11096 if (HasPreferredVariableOrder) {
11097 output.WriteRawTag(8);
11098 output.WriteEnum((
int) PreferredVariableOrder);
11100 if (HasInitialPolarity) {
11101 output.WriteRawTag(16);
11102 output.WriteEnum((
int) InitialPolarity);
11104 if (HasMinimizationAlgorithm) {
11105 output.WriteRawTag(32);
11106 output.WriteEnum((
int) MinimizationAlgorithm);
11108 if (HasClauseCleanupPeriod) {
11109 output.WriteRawTag(88);
11110 output.WriteInt32(ClauseCleanupPeriod);
11112 if (HasClauseCleanupTarget) {
11113 output.WriteRawTag(104);
11114 output.WriteInt32(ClauseCleanupTarget);
11116 if (HasVariableActivityDecay) {
11117 output.WriteRawTag(121);
11118 output.WriteDouble(VariableActivityDecay);
11120 if (HasMaxVariableActivityValue) {
11121 output.WriteRawTag(129, 1);
11122 output.WriteDouble(MaxVariableActivityValue);
11124 if (HasClauseActivityDecay) {
11125 output.WriteRawTag(137, 1);
11126 output.WriteDouble(ClauseActivityDecay);
11128 if (HasMaxClauseActivityValue) {
11129 output.WriteRawTag(145, 1);
11130 output.WriteDouble(MaxClauseActivityValue);
11132 if (HasGlucoseMaxDecay) {
11133 output.WriteRawTag(177, 1);
11134 output.WriteDouble(GlucoseMaxDecay);
11136 if (HasGlucoseDecayIncrement) {
11137 output.WriteRawTag(185, 1);
11138 output.WriteDouble(GlucoseDecayIncrement);
11140 if (HasGlucoseDecayIncrementPeriod) {
11141 output.WriteRawTag(192, 1);
11142 output.WriteInt32(GlucoseDecayIncrementPeriod);
11144 if (HasRestartPeriod) {
11145 output.WriteRawTag(240, 1);
11146 output.WriteInt32(RestartPeriod);
11148 if (HasRandomSeed) {
11149 output.WriteRawTag(248, 1);
11150 output.WriteInt32(RandomSeed);
11152 if (HasRandomBranchesRatio) {
11153 output.WriteRawTag(129, 2);
11154 output.WriteDouble(RandomBranchesRatio);
11156 if (HasBinaryMinimizationAlgorithm) {
11157 output.WriteRawTag(144, 2);
11158 output.WriteEnum((
int) BinaryMinimizationAlgorithm);
11160 if (HasUseOptimizationHints) {
11161 output.WriteRawTag(152, 2);
11162 output.WriteBool(UseOptimizationHints);
11164 if (HasMaxTimeInSeconds) {
11165 output.WriteRawTag(161, 2);
11166 output.WriteDouble(MaxTimeInSeconds);
11168 if (HasMaxNumberOfConflicts) {
11169 output.WriteRawTag(168, 2);
11170 output.WriteInt64(MaxNumberOfConflicts);
11172 if (HasMaxMemoryInMb) {
11173 output.WriteRawTag(192, 2);
11174 output.WriteInt64(MaxMemoryInMb);
11176 if (HasLogSearchProgress) {
11177 output.WriteRawTag(200, 2);
11178 output.WriteBool(LogSearchProgress);
11180 if (HasUsePbResolution) {
11181 output.WriteRawTag(216, 2);
11182 output.WriteBool(UsePbResolution);
11184 if (HasUsePhaseSaving) {
11185 output.WriteRawTag(224, 2);
11186 output.WriteBool(UsePhaseSaving);
11188 if (HasRandomPolarityRatio) {
11189 output.WriteRawTag(233, 2);
11190 output.WriteDouble(RandomPolarityRatio);
11192 if (HasPbCleanupIncrement) {
11193 output.WriteRawTag(240, 2);
11194 output.WriteInt32(PbCleanupIncrement);
11196 if (HasPbCleanupRatio) {
11197 output.WriteRawTag(249, 2);
11198 output.WriteDouble(PbCleanupRatio);
11200 if (HasMinimizeReductionDuringPbResolution) {
11201 output.WriteRawTag(128, 3);
11202 output.WriteBool(MinimizeReductionDuringPbResolution);
11204 if (HasCountAssumptionLevelsInLbd) {
11205 output.WriteRawTag(136, 3);
11206 output.WriteBool(CountAssumptionLevelsInLbd);
11208 if (HasCoreMinimizationLevel) {
11209 output.WriteRawTag(144, 3);
11210 output.WriteInt32(CoreMinimizationLevel);
11212 if (HasMaxSatAssumptionOrder) {
11213 output.WriteRawTag(152, 3);
11214 output.WriteEnum((
int) MaxSatAssumptionOrder);
11216 if (HasMaxSatReverseAssumptionOrder) {
11217 output.WriteRawTag(160, 3);
11218 output.WriteBool(MaxSatReverseAssumptionOrder);
11220 if (HasMaxSatStratification) {
11221 output.WriteRawTag(168, 3);
11222 output.WriteEnum((
int) MaxSatStratification);
11224 if (HasPresolveBveThreshold) {
11225 output.WriteRawTag(176, 3);
11226 output.WriteInt32(PresolveBveThreshold);
11228 if (HasPresolveBveClauseWeight) {
11229 output.WriteRawTag(184, 3);
11230 output.WriteInt32(PresolveBveClauseWeight);
11232 if (HasSubsumptionDuringConflictAnalysis) {
11233 output.WriteRawTag(192, 3);
11234 output.WriteBool(SubsumptionDuringConflictAnalysis);
11236 if (HasPresolveProbingDeterministicTimeLimit) {
11237 output.WriteRawTag(201, 3);
11238 output.WriteDouble(PresolveProbingDeterministicTimeLimit);
11240 if (HasClauseCleanupProtection) {
11241 output.WriteRawTag(208, 3);
11242 output.WriteEnum((
int) ClauseCleanupProtection);
11244 if (HasClauseCleanupLbdBound) {
11245 output.WriteRawTag(216, 3);
11246 output.WriteInt32(ClauseCleanupLbdBound);
11248 if (HasClauseCleanupOrdering) {
11249 output.WriteRawTag(224, 3);
11250 output.WriteEnum((
int) ClauseCleanupOrdering);
11252 restartAlgorithms_.WriteTo(ref output, _repeated_restartAlgorithms_codec);
11253 if (HasRestartRunningWindowSize) {
11254 output.WriteRawTag(240, 3);
11255 output.WriteInt32(RestartRunningWindowSize);
11257 if (HasRestartDlAverageRatio) {
11258 output.WriteRawTag(249, 3);
11259 output.WriteDouble(RestartDlAverageRatio);
11261 if (HasUseBlockingRestart) {
11262 output.WriteRawTag(128, 4);
11263 output.WriteBool(UseBlockingRestart);
11265 if (HasBlockingRestartWindowSize) {
11266 output.WriteRawTag(136, 4);
11267 output.WriteInt32(BlockingRestartWindowSize);
11269 if (HasBlockingRestartMultiplier) {
11270 output.WriteRawTag(145, 4);
11271 output.WriteDouble(BlockingRestartMultiplier);
11273 if (HasMaxDeterministicTime) {
11274 output.WriteRawTag(153, 4);
11275 output.WriteDouble(MaxDeterministicTime);
11277 if (HasNumConflictsBeforeStrategyChanges) {
11278 output.WriteRawTag(160, 4);
11279 output.WriteInt32(NumConflictsBeforeStrategyChanges);
11281 if (HasStrategyChangeIncreaseRatio) {
11282 output.WriteRawTag(169, 4);
11283 output.WriteDouble(StrategyChangeIncreaseRatio);
11285 if (HasDefaultRestartAlgorithms) {
11286 output.WriteRawTag(178, 4);
11287 output.WriteString(DefaultRestartAlgorithms);
11289 if (HasRestartLbdAverageRatio) {
11290 output.WriteRawTag(185, 4);
11291 output.WriteDouble(RestartLbdAverageRatio);
11293 if (HasPresolveUseBva) {
11294 output.WriteRawTag(192, 4);
11295 output.WriteBool(PresolveUseBva);
11297 if (HasPresolveBvaThreshold) {
11298 output.WriteRawTag(200, 4);
11299 output.WriteInt32(PresolveBvaThreshold);
11301 if (HasUsePrecedencesInDisjunctiveConstraint) {
11302 output.WriteRawTag(208, 4);
11303 output.WriteBool(UsePrecedencesInDisjunctiveConstraint);
11305 if (HasUseErwaHeuristic) {
11306 output.WriteRawTag(216, 4);
11307 output.WriteBool(UseErwaHeuristic);
11309 if (HasInitialVariablesActivity) {
11310 output.WriteRawTag(225, 4);
11311 output.WriteDouble(InitialVariablesActivity);
11313 if (HasAlsoBumpVariablesInConflictReasons) {
11314 output.WriteRawTag(232, 4);
11315 output.WriteBool(AlsoBumpVariablesInConflictReasons);
11317 if (HasUseOverloadCheckerInCumulative) {
11318 output.WriteRawTag(240, 4);
11319 output.WriteBool(UseOverloadCheckerInCumulative);
11321 if (HasUseTimetableEdgeFindingInCumulative) {
11322 output.WriteRawTag(248, 4);
11323 output.WriteBool(UseTimetableEdgeFindingInCumulative);
11325 if (HasUseDisjunctiveConstraintInCumulative) {
11326 output.WriteRawTag(128, 5);
11327 output.WriteBool(UseDisjunctiveConstraintInCumulative);
11329 if (HasSearchBranching) {
11330 output.WriteRawTag(144, 5);
11331 output.WriteEnum((
int) SearchBranching);
11333 if (HasOptimizeWithCore) {
11334 output.WriteRawTag(152, 5);
11335 output.WriteBool(OptimizeWithCore);
11337 if (HasFindMultipleCores) {
11338 output.WriteRawTag(160, 5);
11339 output.WriteBool(FindMultipleCores);
11341 if (HasOptimizeWithMaxHs) {
11342 output.WriteRawTag(168, 5);
11343 output.WriteBool(OptimizeWithMaxHs);
11345 if (HasCpModelPresolve) {
11346 output.WriteRawTag(176, 5);
11347 output.WriteBool(CpModelPresolve);
11349 if (HasEnumerateAllSolutions) {
11350 output.WriteRawTag(184, 5);
11351 output.WriteBool(EnumerateAllSolutions);
11353 if (HasPresolveBlockedClause) {
11354 output.WriteRawTag(192, 5);
11355 output.WriteBool(PresolveBlockedClause);
11357 if (HasCoverOptimization) {
11358 output.WriteRawTag(200, 5);
11359 output.WriteBool(CoverOptimization);
11361 if (HasLinearizationLevel) {
11362 output.WriteRawTag(208, 5);
11363 output.WriteInt32(LinearizationLevel);
11365 if (HasMaxNumCuts) {
11366 output.WriteRawTag(216, 5);
11367 output.WriteInt32(MaxNumCuts);
11369 if (HasOnlyAddCutsAtLevelZero) {
11370 output.WriteRawTag(224, 5);
11371 output.WriteBool(OnlyAddCutsAtLevelZero);
11373 if (HasCpModelUseSatPresolve) {
11374 output.WriteRawTag(232, 5);
11375 output.WriteBool(CpModelUseSatPresolve);
11377 if (HasExploitIntegerLpSolution) {
11378 output.WriteRawTag(240, 5);
11379 output.WriteBool(ExploitIntegerLpSolution);
11381 if (HasAutoDetectGreaterThanAtLeastOneOf) {
11382 output.WriteRawTag(248, 5);
11383 output.WriteBool(AutoDetectGreaterThanAtLeastOneOf);
11385 if (HasStopAfterFirstSolution) {
11386 output.WriteRawTag(144, 6);
11387 output.WriteBool(StopAfterFirstSolution);
11389 if (HasBinarySearchNumConflicts) {
11390 output.WriteRawTag(152, 6);
11391 output.WriteInt32(BinarySearchNumConflicts);
11393 if (HasNumSearchWorkers) {
11394 output.WriteRawTag(160, 6);
11395 output.WriteInt32(NumSearchWorkers);
11397 if (HasUseLnsOnly) {
11398 output.WriteRawTag(168, 6);
11399 output.WriteBool(UseLnsOnly);
11401 if (HasRandomizeSearch) {
11402 output.WriteRawTag(184, 6);
11403 output.WriteBool(RandomizeSearch);
11405 if (HasSearchRandomVariablePoolSize) {
11406 output.WriteRawTag(192, 6);
11407 output.WriteInt64(SearchRandomVariablePoolSize);
11409 if (HasInstantiateAllVariables) {
11410 output.WriteRawTag(208, 6);
11411 output.WriteBool(InstantiateAllVariables);
11413 if (HasBooleanEncodingLevel) {
11414 output.WriteRawTag(216, 6);
11415 output.WriteInt32(BooleanEncodingLevel);
11417 if (HasUseOptionalVariables) {
11418 output.WriteRawTag(224, 6);
11419 output.WriteBool(UseOptionalVariables);
11421 if (HasUseExactLpReason) {
11422 output.WriteRawTag(232, 6);
11423 output.WriteBool(UseExactLpReason);
11425 if (HasCpModelProbingLevel) {
11426 output.WriteRawTag(240, 6);
11427 output.WriteInt32(CpModelProbingLevel);
11429 if (HasAddLpConstraintsLazily) {
11430 output.WriteRawTag(128, 7);
11431 output.WriteBool(AddLpConstraintsLazily);
11433 if (HasShareObjectiveBounds) {
11434 output.WriteRawTag(136, 7);
11435 output.WriteBool(ShareObjectiveBounds);
11437 if (HasShareLevelZeroBounds) {
11438 output.WriteRawTag(144, 7);
11439 output.WriteBool(ShareLevelZeroBounds);
11441 if (HasMinOrthogonalityForLpConstraints) {
11442 output.WriteRawTag(153, 7);
11443 output.WriteDouble(MinOrthogonalityForLpConstraints);
11445 if (HasExploitAllLpSolution) {
11446 output.WriteRawTag(160, 7);
11447 output.WriteBool(ExploitAllLpSolution);
11449 if (HasAddCgCuts) {
11450 output.WriteRawTag(168, 7);
11451 output.WriteBool(AddCgCuts);
11453 if (HasMaxIntegerRoundingScaling) {
11454 output.WriteRawTag(184, 7);
11455 output.WriteInt32(MaxIntegerRoundingScaling);
11457 if (HasAddMirCuts) {
11458 output.WriteRawTag(192, 7);
11459 output.WriteBool(AddMirCuts);
11461 if (HasMaxConsecutiveInactiveCount) {
11462 output.WriteRawTag(200, 7);
11463 output.WriteInt32(MaxConsecutiveInactiveCount);
11465 if (HasNewConstraintsBatchSize) {
11466 output.WriteRawTag(208, 7);
11467 output.WriteInt32(NewConstraintsBatchSize);
11469 if (HasPseudoCostReliabilityThreshold) {
11470 output.WriteRawTag(216, 7);
11471 output.WriteInt64(PseudoCostReliabilityThreshold);
11473 if (HasMipMaxBound) {
11474 output.WriteRawTag(225, 7);
11475 output.WriteDouble(MipMaxBound);
11477 if (HasMipVarScaling) {
11478 output.WriteRawTag(233, 7);
11479 output.WriteDouble(MipVarScaling);
11481 if (HasMipWantedPrecision) {
11482 output.WriteRawTag(241, 7);
11483 output.WriteDouble(MipWantedPrecision);
11485 if (HasMipMaxActivityExponent) {
11486 output.WriteRawTag(248, 7);
11487 output.WriteInt32(MipMaxActivityExponent);
11489 if (HasMipCheckPrecision) {
11490 output.WriteRawTag(129, 8);
11491 output.WriteDouble(MipCheckPrecision);
11493 if (HasUseRinsLns) {
11494 output.WriteRawTag(136, 8);
11495 output.WriteBool(UseRinsLns);
11497 if (HasExploitBestSolution) {
11498 output.WriteRawTag(144, 8);
11499 output.WriteBool(ExploitBestSolution);
11501 if (HasExploitObjective) {
11502 output.WriteRawTag(152, 8);
11503 output.WriteBool(ExploitObjective);
11505 if (HasFillTightenedDomainsInResponse) {
11506 output.WriteRawTag(160, 8);
11507 output.WriteBool(FillTightenedDomainsInResponse);
11509 if (HasUseCombinedNoOverlap) {
11510 output.WriteRawTag(168, 8);
11511 output.WriteBool(UseCombinedNoOverlap);
11513 if (HasInterleaveBatchSize) {
11514 output.WriteRawTag(176, 8);
11515 output.WriteInt32(InterleaveBatchSize);
11517 if (HasCatchSigintSignal) {
11518 output.WriteRawTag(184, 8);
11519 output.WriteBool(CatchSigintSignal);
11521 if (HasInterleaveSearch) {
11522 output.WriteRawTag(192, 8);
11523 output.WriteBool(InterleaveSearch);
11525 if (HasDiversifyLnsParams) {
11526 output.WriteRawTag(200, 8);
11527 output.WriteBool(DiversifyLnsParams);
11529 if (HasMaxPresolveIterations) {
11530 output.WriteRawTag(208, 8);
11531 output.WriteInt32(MaxPresolveIterations);
11533 if (HasUseImpliedBounds) {
11534 output.WriteRawTag(128, 9);
11535 output.WriteBool(UseImpliedBounds);
11537 if (HasMergeNoOverlapWorkLimit) {
11538 output.WriteRawTag(137, 9);
11539 output.WriteDouble(MergeNoOverlapWorkLimit);
11541 if (HasMergeAtMostOneWorkLimit) {
11542 output.WriteRawTag(145, 9);
11543 output.WriteDouble(MergeAtMostOneWorkLimit);
11545 if (HasPresolveSubstitutionLevel) {
11546 output.WriteRawTag(152, 9);
11547 output.WriteInt32(PresolveSubstitutionLevel);
11549 if (HasMaxAllDiffCutSize) {
11550 output.WriteRawTag(160, 9);
11551 output.WriteInt32(MaxAllDiffCutSize);
11553 if (HasStopAfterPresolve) {
11554 output.WriteRawTag(168, 9);
11555 output.WriteBool(StopAfterPresolve);
11557 if (HasDebugMaxNumPresolveOperations) {
11558 output.WriteRawTag(184, 9);
11559 output.WriteInt32(DebugMaxNumPresolveOperations);
11561 if (HasAddLinMaxCuts) {
11562 output.WriteRawTag(192, 9);
11563 output.WriteBool(AddLinMaxCuts);
11565 if (HasHintConflictLimit) {
11566 output.WriteRawTag(200, 9);
11567 output.WriteInt32(HintConflictLimit);
11569 if (HasMaxCutRoundsAtLevelZero) {
11570 output.WriteRawTag(208, 9);
11571 output.WriteInt32(MaxCutRoundsAtLevelZero);
11573 if (HasCutMaxActiveCountValue) {
11574 output.WriteRawTag(217, 9);
11575 output.WriteDouble(CutMaxActiveCountValue);
11577 if (HasCutActiveCountDecay) {
11578 output.WriteRawTag(225, 9);
11579 output.WriteDouble(CutActiveCountDecay);
11581 if (HasCutCleanupTarget) {
11582 output.WriteRawTag(232, 9);
11583 output.WriteInt32(CutCleanupTarget);
11585 if (HasAbsoluteGapLimit) {
11586 output.WriteRawTag(249, 9);
11587 output.WriteDouble(AbsoluteGapLimit);
11589 if (HasRelativeGapLimit) {
11590 output.WriteRawTag(129, 10);
11591 output.WriteDouble(RelativeGapLimit);
11593 if (HasExploitRelaxationSolution) {
11594 output.WriteRawTag(136, 10);
11595 output.WriteBool(ExploitRelaxationSolution);
11597 if (HasDebugPostsolveWithFullSolver) {
11598 output.WriteRawTag(144, 10);
11599 output.WriteBool(DebugPostsolveWithFullSolver);
11601 if (HasUseSatInprocessing) {
11602 output.WriteRawTag(152, 10);
11603 output.WriteBool(UseSatInprocessing);
11605 if (HasUseFeasibilityPump) {
11606 output.WriteRawTag(160, 10);
11607 output.WriteBool(UseFeasibilityPump);
11609 if (HasFpRounding) {
11610 output.WriteRawTag(168, 10);
11611 output.WriteEnum((
int) FpRounding);
11613 if (HasMipAutomaticallyScaleVariables) {
11614 output.WriteRawTag(176, 10);
11615 output.WriteBool(MipAutomaticallyScaleVariables);
11617 if (HasRepairHint) {
11618 output.WriteRawTag(184, 10);
11619 output.WriteBool(RepairHint);
11621 if (HasPolarityRephaseIncrement) {
11622 output.WriteRawTag(192, 10);
11623 output.WriteInt32(PolarityRephaseIncrement);
11625 if (HasAddZeroHalfCuts) {
11626 output.WriteRawTag(200, 10);
11627 output.WriteBool(AddZeroHalfCuts);
11629 if (HasExpandAlldiffConstraints) {
11630 output.WriteRawTag(208, 10);
11631 output.WriteBool(ExpandAlldiffConstraints);
11634 output.WriteRawTag(218, 10);
11635 output.WriteString(Name);
11637 if (HasAddCliqueCuts) {
11638 output.WriteRawTag(224, 10);
11639 output.WriteBool(AddCliqueCuts);
11641 if (HasKeepAllFeasibleSolutionsInPresolve) {
11642 output.WriteRawTag(232, 10);
11643 output.WriteBool(KeepAllFeasibleSolutionsInPresolve);
11645 if (HasPresolveExtractIntegerEnforcement) {
11646 output.WriteRawTag(240, 10);
11647 output.WriteBool(PresolveExtractIntegerEnforcement);
11649 if (HasPolishLpSolution) {
11650 output.WriteRawTag(248, 10);
11651 output.WriteBool(PolishLpSolution);
11653 if (HasUseProbingSearch) {
11654 output.WriteRawTag(128, 11);
11655 output.WriteBool(UseProbingSearch);
11657 if (HasConvertIntervals) {
11658 output.WriteRawTag(136, 11);
11659 output.WriteBool(ConvertIntervals);
11661 if (HasPermuteVariableRandomly) {
11662 output.WriteRawTag(144, 11);
11663 output.WriteBool(PermuteVariableRandomly);
11665 if (HasPermutePresolveConstraintOrder) {
11666 output.WriteRawTag(152, 11);
11667 output.WriteBool(PermutePresolveConstraintOrder);
11669 if (HasUseAbslRandom) {
11670 output.WriteRawTag(160, 11);
11671 output.WriteBool(UseAbslRandom);
11673 if (HasDisableConstraintExpansion) {
11674 output.WriteRawTag(168, 11);
11675 output.WriteBool(DisableConstraintExpansion);
11677 if (HasExpandReservoirConstraints) {
11678 output.WriteRawTag(176, 11);
11679 output.WriteBool(ExpandReservoirConstraints);
11681 if (HasSymmetryLevel) {
11682 output.WriteRawTag(184, 11);
11683 output.WriteInt32(SymmetryLevel);
11685 if (HasLogPrefix) {
11686 output.WriteRawTag(202, 11);
11687 output.WriteString(LogPrefix);
11689 if (HasLogToStdout) {
11690 output.WriteRawTag(208, 11);
11691 output.WriteBool(LogToStdout);
11693 if (HasLogToResponse) {
11694 output.WriteRawTag(216, 11);
11695 output.WriteBool(LogToResponse);
11697 if (HasOptimizeWithLbTreeSearch) {
11698 output.WriteRawTag(224, 11);
11699 output.WriteBool(OptimizeWithLbTreeSearch);
11701 if (HasLogSubsolverStatistics) {
11702 output.WriteRawTag(232, 11);
11703 output.WriteBool(LogSubsolverStatistics);
11705 if (HasClauseCleanupRatio) {
11706 output.WriteRawTag(241, 11);
11707 output.WriteDouble(ClauseCleanupRatio);
11709 if (HasMaxDomainSizeWhenEncodingEqNeqConstraints) {
11710 output.WriteRawTag(248, 11);
11711 output.WriteInt32(MaxDomainSizeWhenEncodingEqNeqConstraints);
11713 if (HasFixVariablesToTheirHintedValue) {
11714 output.WriteRawTag(128, 12);
11715 output.WriteBool(FixVariablesToTheirHintedValue);
11717 if (HasSolutionPoolSize) {
11718 output.WriteRawTag(136, 12);
11719 output.WriteInt32(SolutionPoolSize);
11721 if (HasFillAdditionalSolutionsInResponse) {
11722 output.WriteRawTag(144, 12);
11723 output.WriteBool(FillAdditionalSolutionsInResponse);
11725 if (HasDebugCrashOnBadHint) {
11726 output.WriteRawTag(152, 12);
11727 output.WriteBool(DebugCrashOnBadHint);
11730 output.WriteRawTag(160, 12);
11731 output.WriteInt32(CutLevel);
11733 if (HasAddObjectiveCut) {
11734 output.WriteRawTag(168, 12);
11735 output.WriteBool(AddObjectiveCut);
11737 if (HasMipComputeTrueObjectiveBound) {
11738 output.WriteRawTag(176, 12);
11739 output.WriteBool(MipComputeTrueObjectiveBound);
11741 if (HasMipMaxValidMagnitude) {
11742 output.WriteRawTag(185, 12);
11743 output.WriteDouble(MipMaxValidMagnitude);
11745 if (HasUseTimetablingInNoOverlap2D) {
11746 output.WriteRawTag(192, 12);
11747 output.WriteBool(UseTimetablingInNoOverlap2D);
11749 if (HasPresolveInclusionWorkLimit) {
11750 output.WriteRawTag(200, 12);
11751 output.WriteInt64(PresolveInclusionWorkLimit);
11753 if (HasIgnoreNames) {
11754 output.WriteRawTag(208, 12);
11755 output.WriteBool(IgnoreNames);
11757 if (HasShareBinaryClauses) {
11758 output.WriteRawTag(216, 12);
11759 output.WriteBool(ShareBinaryClauses);
11761 if (HasShavingDeterministicTimeInProbingSearch) {
11762 output.WriteRawTag(225, 12);
11763 output.WriteDouble(ShavingDeterministicTimeInProbingSearch);
11765 if (HasShavingSearchDeterministicTime) {
11766 output.WriteRawTag(233, 12);
11767 output.WriteDouble(ShavingSearchDeterministicTime);
11769 if (HasNumWorkers) {
11770 output.WriteRawTag(240, 12);
11771 output.WriteInt32(NumWorkers);
11773 subsolvers_.WriteTo(ref output, _repeated_subsolvers_codec);
11774 ignoreSubsolvers_.WriteTo(ref output, _repeated_ignoreSubsolvers_codec);
11775 subsolverParams_.WriteTo(ref output, _repeated_subsolverParams_codec);
11776 if (HasUseEnergeticReasoningInNoOverlap2D) {
11777 output.WriteRawTag(168, 13);
11778 output.WriteBool(UseEnergeticReasoningInNoOverlap2D);
11780 if (HasUseDualSchedulingHeuristics) {
11781 output.WriteRawTag(176, 13);
11782 output.WriteBool(UseDualSchedulingHeuristics);
11784 if (HasUseHardPrecedencesInCumulative) {
11785 output.WriteRawTag(184, 13);
11786 output.WriteBool(UseHardPrecedencesInCumulative);
11788 if (HasDetectTableWithCost) {
11789 output.WriteRawTag(192, 13);
11790 output.WriteBool(DetectTableWithCost);
11792 if (HasTableCompressionLevel) {
11793 output.WriteRawTag(200, 13);
11794 output.WriteInt32(TableCompressionLevel);
11796 extraSubsolvers_.WriteTo(ref output, _repeated_extraSubsolvers_codec);
11797 if (HasExploitAllPrecedences) {
11798 output.WriteRawTag(224, 13);
11799 output.WriteBool(ExploitAllPrecedences);
11801 if (HasPropagationLoopDetectionFactor) {
11802 output.WriteRawTag(233, 13);
11803 output.WriteDouble(PropagationLoopDetectionFactor);
11805 if (HasOnlySolveIp) {
11806 output.WriteRawTag(240, 13);
11807 output.WriteBool(OnlySolveIp);
11809 if (HasEncodeComplexLinearConstraintWithInteger) {
11810 output.WriteRawTag(248, 13);
11811 output.WriteBool(EncodeComplexLinearConstraintWithInteger);
11813 if (HasNewLinearPropagation) {
11814 output.WriteRawTag(128, 14);
11815 output.WriteBool(NewLinearPropagation);
11817 if (HasMipScaleLargeDomain) {
11818 output.WriteRawTag(136, 14);
11819 output.WriteBool(MipScaleLargeDomain);
11821 if (HasProbingDeterministicTimeLimit) {
11822 output.WriteRawTag(145, 14);
11823 output.WriteDouble(ProbingDeterministicTimeLimit);
11825 if (HasRootLpIterations) {
11826 output.WriteRawTag(152, 14);
11827 output.WriteInt32(RootLpIterations);
11829 if (HasUseObjectiveLbSearch) {
11830 output.WriteRawTag(160, 14);
11831 output.WriteBool(UseObjectiveLbSearch);
11833 if (HasMaxSizeToCreatePrecedenceLiteralsInDisjunctive) {
11834 output.WriteRawTag(168, 14);
11835 output.WriteInt32(MaxSizeToCreatePrecedenceLiteralsInDisjunctive);
11837 if (HasUseStrongPropagationInDisjunctive) {
11838 output.WriteRawTag(176, 14);
11839 output.WriteBool(UseStrongPropagationInDisjunctive);
11841 if (HasMipDropTolerance) {
11842 output.WriteRawTag(193, 14);
11843 output.WriteDouble(MipDropTolerance);
11845 if (HasInferAllDiffs) {
11846 output.WriteRawTag(200, 14);
11847 output.WriteBool(InferAllDiffs);
11849 if (HasFindBigLinearOverlap) {
11850 output.WriteRawTag(208, 14);
11851 output.WriteBool(FindBigLinearOverlap);
11853 if (HasSharedTreeNumWorkers) {
11854 output.WriteRawTag(216, 14);
11855 output.WriteInt32(SharedTreeNumWorkers);
11857 if (HasUseSharedTreeSearch) {
11858 output.WriteRawTag(224, 14);
11859 output.WriteBool(UseSharedTreeSearch);
11861 if (HasSharedTreeMaxNodesPerWorker) {
11862 output.WriteRawTag(240, 14);
11863 output.WriteInt32(SharedTreeMaxNodesPerWorker);
11865 if (HasSharedTreeSplitStrategy) {
11866 output.WriteRawTag(248, 14);
11867 output.WriteEnum((
int) SharedTreeSplitStrategy);
11869 if (HasUseLsOnly) {
11870 output.WriteRawTag(128, 15);
11871 output.WriteBool(UseLsOnly);
11873 if (HasFeasibilityJumpDecay) {
11874 output.WriteRawTag(145, 15);
11875 output.WriteDouble(FeasibilityJumpDecay);
11877 if (HasNumViolationLs) {
11878 output.WriteRawTag(160, 15);
11879 output.WriteInt32(NumViolationLs);
11881 if (HasFeasibilityJumpVarRandomizationProbability) {
11882 output.WriteRawTag(185, 15);
11883 output.WriteDouble(FeasibilityJumpVarRandomizationProbability);
11885 if (HasFeasibilityJumpVarPerburbationRangeRatio) {
11886 output.WriteRawTag(193, 15);
11887 output.WriteDouble(FeasibilityJumpVarPerburbationRangeRatio);
11889 if (HasViolationLsPerturbationPeriod) {
11890 output.WriteRawTag(200, 15);
11891 output.WriteInt32(ViolationLsPerturbationPeriod);
11893 if (HasFeasibilityJumpEnableRestarts) {
11894 output.WriteRawTag(208, 15);
11895 output.WriteBool(FeasibilityJumpEnableRestarts);
11897 if (HasStopAfterRootPropagation) {
11898 output.WriteRawTag(224, 15);
11899 output.WriteBool(StopAfterRootPropagation);
11901 if (HasUseObjectiveShavingSearch) {
11902 output.WriteRawTag(232, 15);
11903 output.WriteBool(UseObjectiveShavingSearch);
11905 if (HasUseLbRelaxLns) {
11906 output.WriteRawTag(248, 15);
11907 output.WriteBool(UseLbRelaxLns);
11909 if (HasLinearSplitSize) {
11910 output.WriteRawTag(128, 16);
11911 output.WriteInt32(LinearSplitSize);
11913 if (HasFeasibilityJumpLinearizationLevel) {
11914 output.WriteRawTag(136, 16);
11915 output.WriteInt32(FeasibilityJumpLinearizationLevel);
11917 if (HasFeasibilityJumpRestartFactor) {
11918 output.WriteRawTag(144, 16);
11919 output.WriteInt32(FeasibilityJumpRestartFactor);
11921 if (HasViolationLsCompoundMoveProbability) {
11922 output.WriteRawTag(153, 16);
11923 output.WriteDouble(ViolationLsCompoundMoveProbability);
11925 if (HasMaxNumIntervalsForTimetableEdgeFinding) {
11926 output.WriteRawTag(160, 16);
11927 output.WriteInt32(MaxNumIntervalsForTimetableEdgeFinding);
11929 if (HasMipPresolveLevel) {
11930 output.WriteRawTag(168, 16);
11931 output.WriteInt32(MipPresolveLevel);
11933 if (HasPushAllTasksTowardStart) {
11934 output.WriteRawTag(176, 16);
11935 output.WriteBool(PushAllTasksTowardStart);
11937 if (HasUseDynamicPrecedenceInDisjunctive) {
11938 output.WriteRawTag(184, 16);
11939 output.WriteBool(UseDynamicPrecedenceInDisjunctive);
11941 if (HasFeasibilityJumpMaxExpandedConstraintSize) {
11942 output.WriteRawTag(192, 16);
11943 output.WriteInt32(FeasibilityJumpMaxExpandedConstraintSize);
11945 if (HasUseFeasibilityJump) {
11946 output.WriteRawTag(200, 16);
11947 output.WriteBool(UseFeasibilityJump);
11949 if (HasLpPrimalTolerance) {
11950 output.WriteRawTag(209, 16);
11951 output.WriteDouble(LpPrimalTolerance);
11953 if (HasLpDualTolerance) {
11954 output.WriteRawTag(217, 16);
11955 output.WriteDouble(LpDualTolerance);
11957 if (HasUseDynamicPrecedenceInCumulative) {
11958 output.WriteRawTag(224, 16);
11959 output.WriteBool(UseDynamicPrecedenceInCumulative);
11961 if (HasUseExtendedProbing) {
11962 output.WriteRawTag(232, 16);
11963 output.WriteBool(UseExtendedProbing);
11965 if (HasAtMostOneMaxExpansionSize) {
11966 output.WriteRawTag(240, 16);
11967 output.WriteInt32(AtMostOneMaxExpansionSize);
11969 if (HasUseAreaEnergeticReasoningInNoOverlap2D) {
11970 output.WriteRawTag(248, 16);
11971 output.WriteBool(UseAreaEnergeticReasoningInNoOverlap2D);
11973 if (HasProbingNumCombinationsLimit) {
11974 output.WriteRawTag(128, 17);
11975 output.WriteInt32(ProbingNumCombinationsLimit);
11977 if (HasInprocessingDtimeRatio) {
11978 output.WriteRawTag(137, 17);
11979 output.WriteDouble(InprocessingDtimeRatio);
11981 if (HasInprocessingProbingDtime) {
11982 output.WriteRawTag(145, 17);
11983 output.WriteDouble(InprocessingProbingDtime);
11985 if (HasInprocessingMinimizationDtime) {
11986 output.WriteRawTag(153, 17);
11987 output.WriteDouble(InprocessingMinimizationDtime);
11989 if (HasMaxPairsPairwiseReasoningInNoOverlap2D) {
11990 output.WriteRawTag(160, 17);
11991 output.WriteInt32(MaxPairsPairwiseReasoningInNoOverlap2D);
11993 if (HasDetectLinearizedProduct) {
11994 output.WriteRawTag(168, 17);
11995 output.WriteBool(DetectLinearizedProduct);
11997 if (HasMipTreatHighMagnitudeBoundsAsInfinity) {
11998 output.WriteRawTag(176, 17);
11999 output.WriteBool(MipTreatHighMagnitudeBoundsAsInfinity);
12001 if (HasAddRltCuts) {
12002 output.WriteRawTag(184, 17);
12003 output.WriteBool(AddRltCuts);
12005 if (HasMaxLinMaxSizeForExpansion) {
12006 output.WriteRawTag(192, 17);
12007 output.WriteInt32(MaxLinMaxSizeForExpansion);
12009 if (HasSharedTreeOpenLeavesPerWorker) {
12010 output.WriteRawTag(201, 17);
12011 output.WriteDouble(SharedTreeOpenLeavesPerWorker);
12013 if (HasSharedTreeWorkerMinRestartsPerSubtree) {
12014 output.WriteRawTag(208, 17);
12015 output.WriteInt32(SharedTreeWorkerMinRestartsPerSubtree);
12018 output.WriteRawTag(216, 17);
12019 output.WriteBool(UseLns);
12021 if (HasSaveLpBasisInLbTreeSearch) {
12022 output.WriteRawTag(224, 17);
12023 output.WriteBool(SaveLpBasisInLbTreeSearch);
12025 if (HasShareGlueClauses) {
12026 output.WriteRawTag(232, 17);
12027 output.WriteBool(ShareGlueClauses);
12029 if (HasUseConservativeScaleOverloadChecker) {
12030 output.WriteRawTag(240, 17);
12031 output.WriteBool(UseConservativeScaleOverloadChecker);
12033 if (HasEncodeCumulativeAsReservoir) {
12034 output.WriteRawTag(248, 17);
12035 output.WriteBool(EncodeCumulativeAsReservoir);
12037 if (HasExpandReservoirUsingCircuit) {
12038 output.WriteRawTag(128, 18);
12039 output.WriteBool(ExpandReservoirUsingCircuit);
12041 if (HasVariablesShavingLevel) {
12042 output.WriteRawTag(136, 18);
12043 output.WriteInt32(VariablesShavingLevel);
12045 if (HasShavingSearchThreshold) {
12046 output.WriteRawTag(144, 18);
12047 output.WriteInt64(ShavingSearchThreshold);
12049 if (HasMaxNumDeterministicBatches) {
12050 output.WriteRawTag(152, 18);
12051 output.WriteInt32(MaxNumDeterministicBatches);
12053 if (HasFeasibilityJumpBatchDtime) {
12054 output.WriteRawTag(161, 18);
12055 output.WriteDouble(FeasibilityJumpBatchDtime);
12057 filterSubsolvers_.WriteTo(ref output, _repeated_filterSubsolvers_codec);
12058 if (HasNumFullSubsolvers) {
12059 output.WriteRawTag(176, 18);
12060 output.WriteInt32(NumFullSubsolvers);
12062 if (HasSharedTreeWorkerEnableTrailSharing) {
12063 output.WriteRawTag(184, 18);
12064 output.WriteBool(SharedTreeWorkerEnableTrailSharing);
12066 if (HasLbRelaxNumWorkersThreshold) {
12067 output.WriteRawTag(192, 18);
12068 output.WriteInt32(LbRelaxNumWorkersThreshold);
12070 if (HasInprocessingMinimizationUseConflictAnalysis) {
12071 output.WriteRawTag(200, 18);
12072 output.WriteBool(InprocessingMinimizationUseConflictAnalysis);
12074 if (HasInprocessingMinimizationUseAllOrderings) {
12075 output.WriteRawTag(208, 18);
12076 output.WriteBool(InprocessingMinimizationUseAllOrderings);
12078 if (HasUseTryEdgeReasoningInNoOverlap2D) {
12079 output.WriteRawTag(216, 18);
12080 output.WriteBool(UseTryEdgeReasoningInNoOverlap2D);
12082 if (HasMinimizeSharedClauses) {
12083 output.WriteRawTag(224, 18);
12084 output.WriteBool(MinimizeSharedClauses);
12086 if (HasUseSymmetryInLp) {
12087 output.WriteRawTag(232, 18);
12088 output.WriteBool(UseSymmetryInLp);
12090 if (HasSymmetryDetectionDeterministicTimeLimit) {
12091 output.WriteRawTag(241, 18);
12092 output.WriteDouble(SymmetryDetectionDeterministicTimeLimit);
12094 if (HasKeepSymmetryInPresolve) {
12095 output.WriteRawTag(248, 18);
12096 output.WriteBool(KeepSymmetryInPresolve);
12098 if (HasSharedTreeWorkerEnablePhaseSharing) {
12099 output.WriteRawTag(128, 19);
12100 output.WriteBool(SharedTreeWorkerEnablePhaseSharing);
12102 if (HasSharedTreeBalanceTolerance) {
12103 output.WriteRawTag(136, 19);
12104 output.WriteInt32(SharedTreeBalanceTolerance);
12106 if (HasDebugCrashIfPresolveBreaksHint) {
12107 output.WriteRawTag(144, 19);
12108 output.WriteBool(DebugCrashIfPresolveBreaksHint);
12110 if (HasLnsInitialDifficulty) {
12111 output.WriteRawTag(153, 19);
12112 output.WriteDouble(LnsInitialDifficulty);
12114 if (HasLnsInitialDeterministicLimit) {
12115 output.WriteRawTag(161, 19);
12116 output.WriteDouble(LnsInitialDeterministicLimit);
12118 if (HasPolarityExploitLsHints) {
12119 output.WriteRawTag(168, 19);
12120 output.WriteBool(PolarityExploitLsHints);
12122 if (HasRemoveFixedVariablesEarly) {
12123 output.WriteRawTag(176, 19);
12124 output.WriteBool(RemoveFixedVariablesEarly);
12126 if (HasUseAllDifferentForCircuit) {
12127 output.WriteRawTag(184, 19);
12128 output.WriteBool(UseAllDifferentForCircuit);
12130 if (HasRoutingCutSubsetSizeForBinaryRelationBound) {
12131 output.WriteRawTag(192, 19);
12132 output.WriteInt32(RoutingCutSubsetSizeForBinaryRelationBound);
12134 if (HasRoutingCutSubsetSizeForTightBinaryRelationBound) {
12135 output.WriteRawTag(200, 19);
12136 output.WriteInt32(RoutingCutSubsetSizeForTightBinaryRelationBound);
12138 if (HasRoutingCutDpEffort) {
12139 output.WriteRawTag(209, 19);
12140 output.WriteDouble(RoutingCutDpEffort);
12142 if (HasMaximumRegionsToSplitInDisconnectedNoOverlap2D) {
12143 output.WriteRawTag(216, 19);
12144 output.WriteInt32(MaximumRegionsToSplitInDisconnectedNoOverlap2D);
12146 if (HasRoutingCutSubsetSizeForExactBinaryRelationBound) {
12147 output.WriteRawTag(224, 19);
12148 output.WriteInt32(RoutingCutSubsetSizeForExactBinaryRelationBound);
12150 if (HasRoutingCutMaxInfeasiblePathLength) {
12151 output.WriteRawTag(232, 19);
12152 output.WriteInt32(RoutingCutMaxInfeasiblePathLength);
12154 if (HasRoutingCutSubsetSizeForShortestPathsBound) {
12155 output.WriteRawTag(240, 19);
12156 output.WriteInt32(RoutingCutSubsetSizeForShortestPathsBound);
12158 if (HasMaxAlldiffDomainSize) {
12159 output.WriteRawTag(128, 20);
12160 output.WriteInt32(MaxAlldiffDomainSize);
12162 if (HasNoOverlap2DBooleanRelationsLimit) {
12163 output.WriteRawTag(136, 20);
12164 output.WriteInt32(NoOverlap2DBooleanRelationsLimit);
12166 if (HasShareGlueClausesDtime) {
12167 output.WriteRawTag(145, 20);
12168 output.WriteDouble(ShareGlueClausesDtime);
12170 if (HasUseLinear3ForNoOverlap2DPrecedences) {
12171 output.WriteRawTag(152, 20);
12172 output.WriteBool(UseLinear3ForNoOverlap2DPrecedences);
12174 if (HasFilterSatPostsolveClauses) {
12175 output.WriteRawTag(160, 20);
12176 output.WriteBool(FilterSatPostsolveClauses);
12178 if (_unknownFields !=
null) {
12179 _unknownFields.WriteTo(ref output);
12184 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
12185 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
12186 public int CalculateSize() {
12189 size += 2 + pb::CodedOutputStream.ComputeStringSize(Name);
12191 if (HasPreferredVariableOrder) {
12192 size += 1 + pb::CodedOutputStream.ComputeEnumSize((
int) PreferredVariableOrder);
12194 if (HasInitialPolarity) {
12195 size += 1 + pb::CodedOutputStream.ComputeEnumSize((
int) InitialPolarity);
12197 if (HasUsePhaseSaving) {
12200 if (HasPolarityRephaseIncrement) {
12201 size += 2 + pb::CodedOutputStream.ComputeInt32Size(PolarityRephaseIncrement);
12203 if (HasPolarityExploitLsHints) {
12206 if (HasRandomPolarityRatio) {
12209 if (HasRandomBranchesRatio) {
12212 if (HasUseErwaHeuristic) {
12215 if (HasInitialVariablesActivity) {
12218 if (HasAlsoBumpVariablesInConflictReasons) {
12221 if (HasMinimizationAlgorithm) {
12222 size += 1 + pb::CodedOutputStream.ComputeEnumSize((
int) MinimizationAlgorithm);
12224 if (HasBinaryMinimizationAlgorithm) {
12225 size += 2 + pb::CodedOutputStream.ComputeEnumSize((
int) BinaryMinimizationAlgorithm);
12227 if (HasSubsumptionDuringConflictAnalysis) {
12230 if (HasClauseCleanupPeriod) {
12231 size += 1 + pb::CodedOutputStream.ComputeInt32Size(ClauseCleanupPeriod);
12233 if (HasClauseCleanupTarget) {
12234 size += 1 + pb::CodedOutputStream.ComputeInt32Size(ClauseCleanupTarget);
12236 if (HasClauseCleanupRatio) {
12239 if (HasClauseCleanupProtection) {
12240 size += 2 + pb::CodedOutputStream.ComputeEnumSize((
int) ClauseCleanupProtection);
12245 if (HasClauseCleanupOrdering) {
12246 size += 2 + pb::CodedOutputStream.ComputeEnumSize((
int) ClauseCleanupOrdering);
12248 if (HasPbCleanupIncrement) {
12249 size += 2 + pb::CodedOutputStream.ComputeInt32Size(PbCleanupIncrement);
12251 if (HasPbCleanupRatio) {
12254 if (HasVariableActivityDecay) {
12257 if (HasMaxVariableActivityValue) {
12260 if (HasGlucoseMaxDecay) {
12263 if (HasGlucoseDecayIncrement) {
12266 if (HasGlucoseDecayIncrementPeriod) {
12267 size += 2 + pb::CodedOutputStream.ComputeInt32Size(GlucoseDecayIncrementPeriod);
12269 if (HasClauseActivityDecay) {
12272 if (HasMaxClauseActivityValue) {
12275 size += restartAlgorithms_.CalculateSize(_repeated_restartAlgorithms_codec);
12276 if (HasDefaultRestartAlgorithms) {
12277 size += 2 + pb::CodedOutputStream.ComputeStringSize(DefaultRestartAlgorithms);
12279 if (HasRestartPeriod) {
12280 size += 2 + pb::CodedOutputStream.ComputeInt32Size(RestartPeriod);
12282 if (HasRestartRunningWindowSize) {
12283 size += 2 + pb::CodedOutputStream.ComputeInt32Size(RestartRunningWindowSize);
12285 if (HasRestartDlAverageRatio) {
12288 if (HasRestartLbdAverageRatio) {
12291 if (HasUseBlockingRestart) {
12294 if (HasBlockingRestartWindowSize) {
12295 size += 2 + pb::CodedOutputStream.ComputeInt32Size(BlockingRestartWindowSize);
12297 if (HasBlockingRestartMultiplier) {
12300 if (HasNumConflictsBeforeStrategyChanges) {
12301 size += 2 + pb::CodedOutputStream.ComputeInt32Size(NumConflictsBeforeStrategyChanges);
12303 if (HasStrategyChangeIncreaseRatio) {
12306 if (HasMaxTimeInSeconds) {
12309 if (HasMaxDeterministicTime) {
12312 if (HasMaxNumDeterministicBatches) {
12313 size += 2 + pb::CodedOutputStream.ComputeInt32Size(MaxNumDeterministicBatches);
12315 if (HasMaxNumberOfConflicts) {
12316 size += 2 + pb::CodedOutputStream.ComputeInt64Size(MaxNumberOfConflicts);
12318 if (HasMaxMemoryInMb) {
12319 size += 2 + pb::CodedOutputStream.ComputeInt64Size(MaxMemoryInMb);
12321 if (HasAbsoluteGapLimit) {
12324 if (HasRelativeGapLimit) {
12327 if (HasRandomSeed) {
12328 size += 2 + pb::CodedOutputStream.ComputeInt32Size(RandomSeed);
12330 if (HasPermuteVariableRandomly) {
12333 if (HasPermutePresolveConstraintOrder) {
12336 if (HasUseAbslRandom) {
12339 if (HasLogSearchProgress) {
12342 if (HasLogSubsolverStatistics) {
12345 if (HasLogPrefix) {
12346 size += 2 + pb::CodedOutputStream.ComputeStringSize(LogPrefix);
12348 if (HasLogToStdout) {
12351 if (HasLogToResponse) {
12354 if (HasUsePbResolution) {
12357 if (HasMinimizeReductionDuringPbResolution) {
12360 if (HasCountAssumptionLevelsInLbd) {
12363 if (HasPresolveBveThreshold) {
12364 size += 2 + pb::CodedOutputStream.ComputeInt32Size(PresolveBveThreshold);
12366 if (HasFilterSatPostsolveClauses) {
12369 if (HasPresolveBveClauseWeight) {
12370 size += 2 + pb::CodedOutputStream.ComputeInt32Size(PresolveBveClauseWeight);
12372 if (HasProbingDeterministicTimeLimit) {
12375 if (HasPresolveProbingDeterministicTimeLimit) {
12378 if (HasPresolveBlockedClause) {
12381 if (HasPresolveUseBva) {
12384 if (HasPresolveBvaThreshold) {
12385 size += 2 + pb::CodedOutputStream.ComputeInt32Size(PresolveBvaThreshold);
12387 if (HasMaxPresolveIterations) {
12388 size += 2 + pb::CodedOutputStream.ComputeInt32Size(MaxPresolveIterations);
12390 if (HasCpModelPresolve) {
12393 if (HasCpModelProbingLevel) {
12394 size += 2 + pb::CodedOutputStream.ComputeInt32Size(CpModelProbingLevel);
12396 if (HasCpModelUseSatPresolve) {
12399 if (HasRemoveFixedVariablesEarly) {
12402 if (HasDetectTableWithCost) {
12405 if (HasTableCompressionLevel) {
12406 size += 2 + pb::CodedOutputStream.ComputeInt32Size(TableCompressionLevel);
12408 if (HasExpandAlldiffConstraints) {
12411 if (HasMaxAlldiffDomainSize) {
12412 size += 2 + pb::CodedOutputStream.ComputeInt32Size(MaxAlldiffDomainSize);
12414 if (HasExpandReservoirConstraints) {
12417 if (HasExpandReservoirUsingCircuit) {
12420 if (HasEncodeCumulativeAsReservoir) {
12423 if (HasMaxLinMaxSizeForExpansion) {
12424 size += 2 + pb::CodedOutputStream.ComputeInt32Size(MaxLinMaxSizeForExpansion);
12426 if (HasDisableConstraintExpansion) {
12429 if (HasEncodeComplexLinearConstraintWithInteger) {
12432 if (HasMergeNoOverlapWorkLimit) {
12435 if (HasMergeAtMostOneWorkLimit) {
12438 if (HasPresolveSubstitutionLevel) {
12439 size += 2 + pb::CodedOutputStream.ComputeInt32Size(PresolveSubstitutionLevel);
12441 if (HasPresolveExtractIntegerEnforcement) {
12444 if (HasPresolveInclusionWorkLimit) {
12445 size += 2 + pb::CodedOutputStream.ComputeInt64Size(PresolveInclusionWorkLimit);
12447 if (HasIgnoreNames) {
12450 if (HasInferAllDiffs) {
12453 if (HasFindBigLinearOverlap) {
12456 if (HasUseSatInprocessing) {
12459 if (HasInprocessingDtimeRatio) {
12462 if (HasInprocessingProbingDtime) {
12465 if (HasInprocessingMinimizationDtime) {
12468 if (HasInprocessingMinimizationUseConflictAnalysis) {
12471 if (HasInprocessingMinimizationUseAllOrderings) {
12474 if (HasNumWorkers) {
12475 size += 2 + pb::CodedOutputStream.ComputeInt32Size(NumWorkers);
12477 if (HasNumSearchWorkers) {
12478 size += 2 + pb::CodedOutputStream.ComputeInt32Size(NumSearchWorkers);
12480 if (HasNumFullSubsolvers) {
12481 size += 2 + pb::CodedOutputStream.ComputeInt32Size(NumFullSubsolvers);
12483 size += subsolvers_.CalculateSize(_repeated_subsolvers_codec);
12484 size += extraSubsolvers_.CalculateSize(_repeated_extraSubsolvers_codec);
12485 size += ignoreSubsolvers_.CalculateSize(_repeated_ignoreSubsolvers_codec);
12486 size += filterSubsolvers_.CalculateSize(_repeated_filterSubsolvers_codec);
12487 size += subsolverParams_.CalculateSize(_repeated_subsolverParams_codec);
12488 if (HasInterleaveSearch) {
12491 if (HasInterleaveBatchSize) {
12492 size += 2 + pb::CodedOutputStream.ComputeInt32Size(InterleaveBatchSize);
12494 if (HasShareObjectiveBounds) {
12497 if (HasShareLevelZeroBounds) {
12500 if (HasShareBinaryClauses) {
12503 if (HasShareGlueClauses) {
12506 if (HasMinimizeSharedClauses) {
12509 if (HasShareGlueClausesDtime) {
12512 if (HasDebugPostsolveWithFullSolver) {
12515 if (HasDebugMaxNumPresolveOperations) {
12516 size += 2 + pb::CodedOutputStream.ComputeInt32Size(DebugMaxNumPresolveOperations);
12518 if (HasDebugCrashOnBadHint) {
12521 if (HasDebugCrashIfPresolveBreaksHint) {
12524 if (HasUseOptimizationHints) {
12527 if (HasCoreMinimizationLevel) {
12528 size += 2 + pb::CodedOutputStream.ComputeInt32Size(CoreMinimizationLevel);
12530 if (HasFindMultipleCores) {
12533 if (HasCoverOptimization) {
12536 if (HasMaxSatAssumptionOrder) {
12537 size += 2 + pb::CodedOutputStream.ComputeEnumSize((
int) MaxSatAssumptionOrder);
12539 if (HasMaxSatReverseAssumptionOrder) {
12542 if (HasMaxSatStratification) {
12543 size += 2 + pb::CodedOutputStream.ComputeEnumSize((
int) MaxSatStratification);
12545 if (HasPropagationLoopDetectionFactor) {
12548 if (HasUsePrecedencesInDisjunctiveConstraint) {
12551 if (HasMaxSizeToCreatePrecedenceLiteralsInDisjunctive) {
12552 size += 2 + pb::CodedOutputStream.ComputeInt32Size(MaxSizeToCreatePrecedenceLiteralsInDisjunctive);
12554 if (HasUseStrongPropagationInDisjunctive) {
12557 if (HasUseDynamicPrecedenceInDisjunctive) {
12560 if (HasUseDynamicPrecedenceInCumulative) {
12563 if (HasUseOverloadCheckerInCumulative) {
12566 if (HasUseConservativeScaleOverloadChecker) {
12569 if (HasUseTimetableEdgeFindingInCumulative) {
12572 if (HasMaxNumIntervalsForTimetableEdgeFinding) {
12573 size += 2 + pb::CodedOutputStream.ComputeInt32Size(MaxNumIntervalsForTimetableEdgeFinding);
12575 if (HasUseHardPrecedencesInCumulative) {
12578 if (HasExploitAllPrecedences) {
12581 if (HasUseDisjunctiveConstraintInCumulative) {
12584 if (HasNoOverlap2DBooleanRelationsLimit) {
12585 size += 2 + pb::CodedOutputStream.ComputeInt32Size(NoOverlap2DBooleanRelationsLimit);
12587 if (HasUseTimetablingInNoOverlap2D) {
12590 if (HasUseEnergeticReasoningInNoOverlap2D) {
12593 if (HasUseAreaEnergeticReasoningInNoOverlap2D) {
12596 if (HasUseTryEdgeReasoningInNoOverlap2D) {
12599 if (HasMaxPairsPairwiseReasoningInNoOverlap2D) {
12600 size += 2 + pb::CodedOutputStream.ComputeInt32Size(MaxPairsPairwiseReasoningInNoOverlap2D);
12602 if (HasMaximumRegionsToSplitInDisconnectedNoOverlap2D) {
12603 size += 2 + pb::CodedOutputStream.ComputeInt32Size(MaximumRegionsToSplitInDisconnectedNoOverlap2D);
12605 if (HasUseLinear3ForNoOverlap2DPrecedences) {
12608 if (HasUseDualSchedulingHeuristics) {
12611 if (HasUseAllDifferentForCircuit) {
12614 if (HasRoutingCutSubsetSizeForBinaryRelationBound) {
12615 size += 2 + pb::CodedOutputStream.ComputeInt32Size(RoutingCutSubsetSizeForBinaryRelationBound);
12617 if (HasRoutingCutSubsetSizeForTightBinaryRelationBound) {
12618 size += 2 + pb::CodedOutputStream.ComputeInt32Size(RoutingCutSubsetSizeForTightBinaryRelationBound);
12620 if (HasRoutingCutSubsetSizeForExactBinaryRelationBound) {
12621 size += 2 + pb::CodedOutputStream.ComputeInt32Size(RoutingCutSubsetSizeForExactBinaryRelationBound);
12623 if (HasRoutingCutSubsetSizeForShortestPathsBound) {
12624 size += 2 + pb::CodedOutputStream.ComputeInt32Size(RoutingCutSubsetSizeForShortestPathsBound);
12626 if (HasRoutingCutDpEffort) {
12629 if (HasRoutingCutMaxInfeasiblePathLength) {
12630 size += 2 + pb::CodedOutputStream.ComputeInt32Size(RoutingCutMaxInfeasiblePathLength);
12632 if (HasSearchBranching) {
12633 size += 2 + pb::CodedOutputStream.ComputeEnumSize((
int) SearchBranching);
12635 if (HasHintConflictLimit) {
12636 size += 2 + pb::CodedOutputStream.ComputeInt32Size(HintConflictLimit);
12638 if (HasRepairHint) {
12641 if (HasFixVariablesToTheirHintedValue) {
12644 if (HasUseProbingSearch) {
12647 if (HasUseExtendedProbing) {
12650 if (HasProbingNumCombinationsLimit) {
12651 size += 2 + pb::CodedOutputStream.ComputeInt32Size(ProbingNumCombinationsLimit);
12653 if (HasShavingDeterministicTimeInProbingSearch) {
12656 if (HasShavingSearchDeterministicTime) {
12659 if (HasShavingSearchThreshold) {
12660 size += 2 + pb::CodedOutputStream.ComputeInt64Size(ShavingSearchThreshold);
12662 if (HasUseObjectiveLbSearch) {
12665 if (HasUseObjectiveShavingSearch) {
12668 if (HasVariablesShavingLevel) {
12669 size += 2 + pb::CodedOutputStream.ComputeInt32Size(VariablesShavingLevel);
12671 if (HasPseudoCostReliabilityThreshold) {
12672 size += 2 + pb::CodedOutputStream.ComputeInt64Size(PseudoCostReliabilityThreshold);
12674 if (HasOptimizeWithCore) {
12677 if (HasOptimizeWithLbTreeSearch) {
12680 if (HasSaveLpBasisInLbTreeSearch) {
12683 if (HasBinarySearchNumConflicts) {
12684 size += 2 + pb::CodedOutputStream.ComputeInt32Size(BinarySearchNumConflicts);
12686 if (HasOptimizeWithMaxHs) {
12689 if (HasUseFeasibilityJump) {
12692 if (HasUseLsOnly) {
12695 if (HasFeasibilityJumpDecay) {
12698 if (HasFeasibilityJumpLinearizationLevel) {
12699 size += 2 + pb::CodedOutputStream.ComputeInt32Size(FeasibilityJumpLinearizationLevel);
12701 if (HasFeasibilityJumpRestartFactor) {
12702 size += 2 + pb::CodedOutputStream.ComputeInt32Size(FeasibilityJumpRestartFactor);
12704 if (HasFeasibilityJumpBatchDtime) {
12707 if (HasFeasibilityJumpVarRandomizationProbability) {
12710 if (HasFeasibilityJumpVarPerburbationRangeRatio) {
12713 if (HasFeasibilityJumpEnableRestarts) {
12716 if (HasFeasibilityJumpMaxExpandedConstraintSize) {
12717 size += 2 + pb::CodedOutputStream.ComputeInt32Size(FeasibilityJumpMaxExpandedConstraintSize);
12719 if (HasNumViolationLs) {
12720 size += 2 + pb::CodedOutputStream.ComputeInt32Size(NumViolationLs);
12722 if (HasViolationLsPerturbationPeriod) {
12723 size += 2 + pb::CodedOutputStream.ComputeInt32Size(ViolationLsPerturbationPeriod);
12725 if (HasViolationLsCompoundMoveProbability) {
12728 if (HasSharedTreeNumWorkers) {
12729 size += 2 + pb::CodedOutputStream.ComputeInt32Size(SharedTreeNumWorkers);
12731 if (HasUseSharedTreeSearch) {
12734 if (HasSharedTreeWorkerMinRestartsPerSubtree) {
12735 size += 2 + pb::CodedOutputStream.ComputeInt32Size(SharedTreeWorkerMinRestartsPerSubtree);
12737 if (HasSharedTreeWorkerEnableTrailSharing) {
12740 if (HasSharedTreeWorkerEnablePhaseSharing) {
12743 if (HasSharedTreeOpenLeavesPerWorker) {
12746 if (HasSharedTreeMaxNodesPerWorker) {
12747 size += 2 + pb::CodedOutputStream.ComputeInt32Size(SharedTreeMaxNodesPerWorker);
12749 if (HasSharedTreeSplitStrategy) {
12750 size += 2 + pb::CodedOutputStream.ComputeEnumSize((
int) SharedTreeSplitStrategy);
12752 if (HasSharedTreeBalanceTolerance) {
12753 size += 2 + pb::CodedOutputStream.ComputeInt32Size(SharedTreeBalanceTolerance);
12755 if (HasEnumerateAllSolutions) {
12758 if (HasKeepAllFeasibleSolutionsInPresolve) {
12761 if (HasFillTightenedDomainsInResponse) {
12764 if (HasFillAdditionalSolutionsInResponse) {
12767 if (HasInstantiateAllVariables) {
12770 if (HasAutoDetectGreaterThanAtLeastOneOf) {
12773 if (HasStopAfterFirstSolution) {
12776 if (HasStopAfterPresolve) {
12779 if (HasStopAfterRootPropagation) {
12782 if (HasLnsInitialDifficulty) {
12785 if (HasLnsInitialDeterministicLimit) {
12791 if (HasUseLnsOnly) {
12794 if (HasSolutionPoolSize) {
12795 size += 2 + pb::CodedOutputStream.ComputeInt32Size(SolutionPoolSize);
12797 if (HasUseRinsLns) {
12800 if (HasUseFeasibilityPump) {
12803 if (HasUseLbRelaxLns) {
12806 if (HasLbRelaxNumWorkersThreshold) {
12807 size += 2 + pb::CodedOutputStream.ComputeInt32Size(LbRelaxNumWorkersThreshold);
12809 if (HasFpRounding) {
12810 size += 2 + pb::CodedOutputStream.ComputeEnumSize((
int) FpRounding);
12812 if (HasDiversifyLnsParams) {
12815 if (HasRandomizeSearch) {
12818 if (HasSearchRandomVariablePoolSize) {
12819 size += 2 + pb::CodedOutputStream.ComputeInt64Size(SearchRandomVariablePoolSize);
12821 if (HasPushAllTasksTowardStart) {
12824 if (HasUseOptionalVariables) {
12827 if (HasUseExactLpReason) {
12830 if (HasUseCombinedNoOverlap) {
12833 if (HasAtMostOneMaxExpansionSize) {
12834 size += 2 + pb::CodedOutputStream.ComputeInt32Size(AtMostOneMaxExpansionSize);
12836 if (HasCatchSigintSignal) {
12839 if (HasUseImpliedBounds) {
12842 if (HasPolishLpSolution) {
12845 if (HasLpPrimalTolerance) {
12848 if (HasLpDualTolerance) {
12851 if (HasConvertIntervals) {
12854 if (HasSymmetryLevel) {
12855 size += 2 + pb::CodedOutputStream.ComputeInt32Size(SymmetryLevel);
12857 if (HasUseSymmetryInLp) {
12860 if (HasKeepSymmetryInPresolve) {
12863 if (HasSymmetryDetectionDeterministicTimeLimit) {
12866 if (HasNewLinearPropagation) {
12869 if (HasLinearSplitSize) {
12870 size += 2 + pb::CodedOutputStream.ComputeInt32Size(LinearSplitSize);
12872 if (HasLinearizationLevel) {
12873 size += 2 + pb::CodedOutputStream.ComputeInt32Size(LinearizationLevel);
12875 if (HasBooleanEncodingLevel) {
12876 size += 2 + pb::CodedOutputStream.ComputeInt32Size(BooleanEncodingLevel);
12878 if (HasMaxDomainSizeWhenEncodingEqNeqConstraints) {
12879 size += 2 + pb::CodedOutputStream.ComputeInt32Size(MaxDomainSizeWhenEncodingEqNeqConstraints);
12881 if (HasMaxNumCuts) {
12882 size += 2 + pb::CodedOutputStream.ComputeInt32Size(MaxNumCuts);
12885 size += 2 + pb::CodedOutputStream.ComputeInt32Size(CutLevel);
12887 if (HasOnlyAddCutsAtLevelZero) {
12890 if (HasAddObjectiveCut) {
12893 if (HasAddCgCuts) {
12896 if (HasAddMirCuts) {
12899 if (HasAddZeroHalfCuts) {
12902 if (HasAddCliqueCuts) {
12905 if (HasAddRltCuts) {
12908 if (HasMaxAllDiffCutSize) {
12909 size += 2 + pb::CodedOutputStream.ComputeInt32Size(MaxAllDiffCutSize);
12911 if (HasAddLinMaxCuts) {
12914 if (HasMaxIntegerRoundingScaling) {
12915 size += 2 + pb::CodedOutputStream.ComputeInt32Size(MaxIntegerRoundingScaling);
12917 if (HasAddLpConstraintsLazily) {
12920 if (HasRootLpIterations) {
12921 size += 2 + pb::CodedOutputStream.ComputeInt32Size(RootLpIterations);
12923 if (HasMinOrthogonalityForLpConstraints) {
12926 if (HasMaxCutRoundsAtLevelZero) {
12927 size += 2 + pb::CodedOutputStream.ComputeInt32Size(MaxCutRoundsAtLevelZero);
12929 if (HasMaxConsecutiveInactiveCount) {
12930 size += 2 + pb::CodedOutputStream.ComputeInt32Size(MaxConsecutiveInactiveCount);
12932 if (HasCutMaxActiveCountValue) {
12935 if (HasCutActiveCountDecay) {
12938 if (HasCutCleanupTarget) {
12939 size += 2 + pb::CodedOutputStream.ComputeInt32Size(CutCleanupTarget);
12941 if (HasNewConstraintsBatchSize) {
12942 size += 2 + pb::CodedOutputStream.ComputeInt32Size(NewConstraintsBatchSize);
12944 if (HasExploitIntegerLpSolution) {
12947 if (HasExploitAllLpSolution) {
12950 if (HasExploitBestSolution) {
12953 if (HasExploitRelaxationSolution) {
12956 if (HasExploitObjective) {
12959 if (HasDetectLinearizedProduct) {
12962 if (HasMipMaxBound) {
12965 if (HasMipVarScaling) {
12968 if (HasMipScaleLargeDomain) {
12971 if (HasMipAutomaticallyScaleVariables) {
12974 if (HasOnlySolveIp) {
12977 if (HasMipWantedPrecision) {
12980 if (HasMipMaxActivityExponent) {
12981 size += 2 + pb::CodedOutputStream.ComputeInt32Size(MipMaxActivityExponent);
12983 if (HasMipCheckPrecision) {
12986 if (HasMipComputeTrueObjectiveBound) {
12989 if (HasMipMaxValidMagnitude) {
12992 if (HasMipTreatHighMagnitudeBoundsAsInfinity) {
12995 if (HasMipDropTolerance) {
12998 if (HasMipPresolveLevel) {
12999 size += 2 + pb::CodedOutputStream.ComputeInt32Size(MipPresolveLevel);
13001 if (_unknownFields !=
null) {
13002 size += _unknownFields.CalculateSize();
13007 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
13008 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
13009 public void MergeFrom(SatParameters other) {
13010 if (other ==
null) {
13013 if (other.HasName) {
13016 if (other.HasPreferredVariableOrder) {
13017 PreferredVariableOrder = other.PreferredVariableOrder;
13019 if (other.HasInitialPolarity) {
13020 InitialPolarity = other.InitialPolarity;
13022 if (other.HasUsePhaseSaving) {
13023 UsePhaseSaving = other.UsePhaseSaving;
13025 if (other.HasPolarityRephaseIncrement) {
13026 PolarityRephaseIncrement = other.PolarityRephaseIncrement;
13028 if (other.HasPolarityExploitLsHints) {
13029 PolarityExploitLsHints = other.PolarityExploitLsHints;
13031 if (other.HasRandomPolarityRatio) {
13032 RandomPolarityRatio = other.RandomPolarityRatio;
13034 if (other.HasRandomBranchesRatio) {
13035 RandomBranchesRatio = other.RandomBranchesRatio;
13037 if (other.HasUseErwaHeuristic) {
13038 UseErwaHeuristic = other.UseErwaHeuristic;
13040 if (other.HasInitialVariablesActivity) {
13041 InitialVariablesActivity = other.InitialVariablesActivity;
13043 if (other.HasAlsoBumpVariablesInConflictReasons) {
13044 AlsoBumpVariablesInConflictReasons = other.AlsoBumpVariablesInConflictReasons;
13046 if (other.HasMinimizationAlgorithm) {
13047 MinimizationAlgorithm = other.MinimizationAlgorithm;
13049 if (other.HasBinaryMinimizationAlgorithm) {
13050 BinaryMinimizationAlgorithm = other.BinaryMinimizationAlgorithm;
13052 if (other.HasSubsumptionDuringConflictAnalysis) {
13053 SubsumptionDuringConflictAnalysis = other.SubsumptionDuringConflictAnalysis;
13055 if (other.HasClauseCleanupPeriod) {
13056 ClauseCleanupPeriod = other.ClauseCleanupPeriod;
13058 if (other.HasClauseCleanupTarget) {
13059 ClauseCleanupTarget = other.ClauseCleanupTarget;
13061 if (other.HasClauseCleanupRatio) {
13062 ClauseCleanupRatio = other.ClauseCleanupRatio;
13064 if (other.HasClauseCleanupProtection) {
13067 if (other.HasClauseCleanupLbdBound) {
13068 ClauseCleanupLbdBound = other.ClauseCleanupLbdBound;
13070 if (other.HasClauseCleanupOrdering) {
13071 ClauseCleanupOrdering = other.ClauseCleanupOrdering;
13073 if (other.HasPbCleanupIncrement) {
13074 PbCleanupIncrement = other.PbCleanupIncrement;
13076 if (other.HasPbCleanupRatio) {
13077 PbCleanupRatio = other.PbCleanupRatio;
13079 if (other.HasVariableActivityDecay) {
13080 VariableActivityDecay = other.VariableActivityDecay;
13082 if (other.HasMaxVariableActivityValue) {
13083 MaxVariableActivityValue = other.MaxVariableActivityValue;
13085 if (other.HasGlucoseMaxDecay) {
13086 GlucoseMaxDecay = other.GlucoseMaxDecay;
13088 if (other.HasGlucoseDecayIncrement) {
13089 GlucoseDecayIncrement = other.GlucoseDecayIncrement;
13091 if (other.HasGlucoseDecayIncrementPeriod) {
13092 GlucoseDecayIncrementPeriod = other.GlucoseDecayIncrementPeriod;
13094 if (other.HasClauseActivityDecay) {
13095 ClauseActivityDecay = other.ClauseActivityDecay;
13097 if (other.HasMaxClauseActivityValue) {
13098 MaxClauseActivityValue = other.MaxClauseActivityValue;
13100 restartAlgorithms_.Add(other.restartAlgorithms_);
13101 if (other.HasDefaultRestartAlgorithms) {
13102 DefaultRestartAlgorithms = other.DefaultRestartAlgorithms;
13104 if (other.HasRestartPeriod) {
13105 RestartPeriod = other.RestartPeriod;
13107 if (other.HasRestartRunningWindowSize) {
13108 RestartRunningWindowSize = other.RestartRunningWindowSize;
13110 if (other.HasRestartDlAverageRatio) {
13111 RestartDlAverageRatio = other.RestartDlAverageRatio;
13113 if (other.HasRestartLbdAverageRatio) {
13114 RestartLbdAverageRatio = other.RestartLbdAverageRatio;
13116 if (other.HasUseBlockingRestart) {
13117 UseBlockingRestart = other.UseBlockingRestart;
13119 if (other.HasBlockingRestartWindowSize) {
13120 BlockingRestartWindowSize = other.BlockingRestartWindowSize;
13122 if (other.HasBlockingRestartMultiplier) {
13123 BlockingRestartMultiplier = other.BlockingRestartMultiplier;
13125 if (other.HasNumConflictsBeforeStrategyChanges) {
13126 NumConflictsBeforeStrategyChanges = other.NumConflictsBeforeStrategyChanges;
13128 if (other.HasStrategyChangeIncreaseRatio) {
13129 StrategyChangeIncreaseRatio = other.StrategyChangeIncreaseRatio;
13131 if (other.HasMaxTimeInSeconds) {
13132 MaxTimeInSeconds = other.MaxTimeInSeconds;
13134 if (other.HasMaxDeterministicTime) {
13135 MaxDeterministicTime = other.MaxDeterministicTime;
13137 if (other.HasMaxNumDeterministicBatches) {
13138 MaxNumDeterministicBatches = other.MaxNumDeterministicBatches;
13140 if (other.HasMaxNumberOfConflicts) {
13141 MaxNumberOfConflicts = other.MaxNumberOfConflicts;
13143 if (other.HasMaxMemoryInMb) {
13144 MaxMemoryInMb = other.MaxMemoryInMb;
13146 if (other.HasAbsoluteGapLimit) {
13147 AbsoluteGapLimit = other.AbsoluteGapLimit;
13149 if (other.HasRelativeGapLimit) {
13150 RelativeGapLimit = other.RelativeGapLimit;
13152 if (other.HasRandomSeed) {
13153 RandomSeed = other.RandomSeed;
13155 if (other.HasPermuteVariableRandomly) {
13156 PermuteVariableRandomly = other.PermuteVariableRandomly;
13158 if (other.HasPermutePresolveConstraintOrder) {
13159 PermutePresolveConstraintOrder = other.PermutePresolveConstraintOrder;
13161 if (other.HasUseAbslRandom) {
13162 UseAbslRandom = other.UseAbslRandom;
13164 if (other.HasLogSearchProgress) {
13165 LogSearchProgress = other.LogSearchProgress;
13167 if (other.HasLogSubsolverStatistics) {
13168 LogSubsolverStatistics = other.LogSubsolverStatistics;
13170 if (other.HasLogPrefix) {
13171 LogPrefix = other.LogPrefix;
13173 if (other.HasLogToStdout) {
13174 LogToStdout = other.LogToStdout;
13176 if (other.HasLogToResponse) {
13177 LogToResponse = other.LogToResponse;
13179 if (other.HasUsePbResolution) {
13180 UsePbResolution = other.UsePbResolution;
13182 if (other.HasMinimizeReductionDuringPbResolution) {
13183 MinimizeReductionDuringPbResolution = other.MinimizeReductionDuringPbResolution;
13185 if (other.HasCountAssumptionLevelsInLbd) {
13186 CountAssumptionLevelsInLbd = other.CountAssumptionLevelsInLbd;
13188 if (other.HasPresolveBveThreshold) {
13189 PresolveBveThreshold = other.PresolveBveThreshold;
13191 if (other.HasFilterSatPostsolveClauses) {
13192 FilterSatPostsolveClauses = other.FilterSatPostsolveClauses;
13194 if (other.HasPresolveBveClauseWeight) {
13195 PresolveBveClauseWeight = other.PresolveBveClauseWeight;
13197 if (other.HasProbingDeterministicTimeLimit) {
13198 ProbingDeterministicTimeLimit = other.ProbingDeterministicTimeLimit;
13200 if (other.HasPresolveProbingDeterministicTimeLimit) {
13201 PresolveProbingDeterministicTimeLimit = other.PresolveProbingDeterministicTimeLimit;
13203 if (other.HasPresolveBlockedClause) {
13204 PresolveBlockedClause = other.PresolveBlockedClause;
13206 if (other.HasPresolveUseBva) {
13207 PresolveUseBva = other.PresolveUseBva;
13209 if (other.HasPresolveBvaThreshold) {
13210 PresolveBvaThreshold = other.PresolveBvaThreshold;
13212 if (other.HasMaxPresolveIterations) {
13213 MaxPresolveIterations = other.MaxPresolveIterations;
13215 if (other.HasCpModelPresolve) {
13216 CpModelPresolve = other.CpModelPresolve;
13218 if (other.HasCpModelProbingLevel) {
13219 CpModelProbingLevel = other.CpModelProbingLevel;
13221 if (other.HasCpModelUseSatPresolve) {
13222 CpModelUseSatPresolve = other.CpModelUseSatPresolve;
13224 if (other.HasRemoveFixedVariablesEarly) {
13225 RemoveFixedVariablesEarly = other.RemoveFixedVariablesEarly;
13227 if (other.HasDetectTableWithCost) {
13228 DetectTableWithCost = other.DetectTableWithCost;
13230 if (other.HasTableCompressionLevel) {
13231 TableCompressionLevel = other.TableCompressionLevel;
13233 if (other.HasExpandAlldiffConstraints) {
13234 ExpandAlldiffConstraints = other.ExpandAlldiffConstraints;
13236 if (other.HasMaxAlldiffDomainSize) {
13237 MaxAlldiffDomainSize = other.MaxAlldiffDomainSize;
13239 if (other.HasExpandReservoirConstraints) {
13240 ExpandReservoirConstraints = other.ExpandReservoirConstraints;
13242 if (other.HasExpandReservoirUsingCircuit) {
13243 ExpandReservoirUsingCircuit = other.ExpandReservoirUsingCircuit;
13245 if (other.HasEncodeCumulativeAsReservoir) {
13246 EncodeCumulativeAsReservoir = other.EncodeCumulativeAsReservoir;
13248 if (other.HasMaxLinMaxSizeForExpansion) {
13249 MaxLinMaxSizeForExpansion = other.MaxLinMaxSizeForExpansion;
13251 if (other.HasDisableConstraintExpansion) {
13252 DisableConstraintExpansion = other.DisableConstraintExpansion;
13254 if (other.HasEncodeComplexLinearConstraintWithInteger) {
13255 EncodeComplexLinearConstraintWithInteger = other.EncodeComplexLinearConstraintWithInteger;
13257 if (other.HasMergeNoOverlapWorkLimit) {
13258 MergeNoOverlapWorkLimit = other.MergeNoOverlapWorkLimit;
13260 if (other.HasMergeAtMostOneWorkLimit) {
13261 MergeAtMostOneWorkLimit = other.MergeAtMostOneWorkLimit;
13263 if (other.HasPresolveSubstitutionLevel) {
13264 PresolveSubstitutionLevel = other.PresolveSubstitutionLevel;
13266 if (other.HasPresolveExtractIntegerEnforcement) {
13267 PresolveExtractIntegerEnforcement = other.PresolveExtractIntegerEnforcement;
13269 if (other.HasPresolveInclusionWorkLimit) {
13270 PresolveInclusionWorkLimit = other.PresolveInclusionWorkLimit;
13272 if (other.HasIgnoreNames) {
13273 IgnoreNames = other.IgnoreNames;
13275 if (other.HasInferAllDiffs) {
13276 InferAllDiffs = other.InferAllDiffs;
13278 if (other.HasFindBigLinearOverlap) {
13279 FindBigLinearOverlap = other.FindBigLinearOverlap;
13281 if (other.HasUseSatInprocessing) {
13282 UseSatInprocessing = other.UseSatInprocessing;
13284 if (other.HasInprocessingDtimeRatio) {
13285 InprocessingDtimeRatio = other.InprocessingDtimeRatio;
13287 if (other.HasInprocessingProbingDtime) {
13288 InprocessingProbingDtime = other.InprocessingProbingDtime;
13290 if (other.HasInprocessingMinimizationDtime) {
13291 InprocessingMinimizationDtime = other.InprocessingMinimizationDtime;
13293 if (other.HasInprocessingMinimizationUseConflictAnalysis) {
13294 InprocessingMinimizationUseConflictAnalysis = other.InprocessingMinimizationUseConflictAnalysis;
13296 if (other.HasInprocessingMinimizationUseAllOrderings) {
13297 InprocessingMinimizationUseAllOrderings = other.InprocessingMinimizationUseAllOrderings;
13299 if (other.HasNumWorkers) {
13300 NumWorkers = other.NumWorkers;
13302 if (other.HasNumSearchWorkers) {
13303 NumSearchWorkers = other.NumSearchWorkers;
13305 if (other.HasNumFullSubsolvers) {
13306 NumFullSubsolvers = other.NumFullSubsolvers;
13308 subsolvers_.Add(other.subsolvers_);
13309 extraSubsolvers_.Add(other.extraSubsolvers_);
13310 ignoreSubsolvers_.Add(other.ignoreSubsolvers_);
13311 filterSubsolvers_.Add(other.filterSubsolvers_);
13312 subsolverParams_.Add(other.subsolverParams_);
13313 if (other.HasInterleaveSearch) {
13314 InterleaveSearch = other.InterleaveSearch;
13316 if (other.HasInterleaveBatchSize) {
13317 InterleaveBatchSize = other.InterleaveBatchSize;
13319 if (other.HasShareObjectiveBounds) {
13320 ShareObjectiveBounds = other.ShareObjectiveBounds;
13322 if (other.HasShareLevelZeroBounds) {
13323 ShareLevelZeroBounds = other.ShareLevelZeroBounds;
13325 if (other.HasShareBinaryClauses) {
13326 ShareBinaryClauses = other.ShareBinaryClauses;
13328 if (other.HasShareGlueClauses) {
13329 ShareGlueClauses = other.ShareGlueClauses;
13331 if (other.HasMinimizeSharedClauses) {
13332 MinimizeSharedClauses = other.MinimizeSharedClauses;
13334 if (other.HasShareGlueClausesDtime) {
13335 ShareGlueClausesDtime = other.ShareGlueClausesDtime;
13337 if (other.HasDebugPostsolveWithFullSolver) {
13338 DebugPostsolveWithFullSolver = other.DebugPostsolveWithFullSolver;
13340 if (other.HasDebugMaxNumPresolveOperations) {
13341 DebugMaxNumPresolveOperations = other.DebugMaxNumPresolveOperations;
13343 if (other.HasDebugCrashOnBadHint) {
13344 DebugCrashOnBadHint = other.DebugCrashOnBadHint;
13346 if (other.HasDebugCrashIfPresolveBreaksHint) {
13347 DebugCrashIfPresolveBreaksHint = other.DebugCrashIfPresolveBreaksHint;
13349 if (other.HasUseOptimizationHints) {
13350 UseOptimizationHints = other.UseOptimizationHints;
13352 if (other.HasCoreMinimizationLevel) {
13353 CoreMinimizationLevel = other.CoreMinimizationLevel;
13355 if (other.HasFindMultipleCores) {
13356 FindMultipleCores = other.FindMultipleCores;
13358 if (other.HasCoverOptimization) {
13359 CoverOptimization = other.CoverOptimization;
13361 if (other.HasMaxSatAssumptionOrder) {
13362 MaxSatAssumptionOrder = other.MaxSatAssumptionOrder;
13364 if (other.HasMaxSatReverseAssumptionOrder) {
13365 MaxSatReverseAssumptionOrder = other.MaxSatReverseAssumptionOrder;
13367 if (other.HasMaxSatStratification) {
13368 MaxSatStratification = other.MaxSatStratification;
13370 if (other.HasPropagationLoopDetectionFactor) {
13371 PropagationLoopDetectionFactor = other.PropagationLoopDetectionFactor;
13373 if (other.HasUsePrecedencesInDisjunctiveConstraint) {
13374 UsePrecedencesInDisjunctiveConstraint = other.UsePrecedencesInDisjunctiveConstraint;
13376 if (other.HasMaxSizeToCreatePrecedenceLiteralsInDisjunctive) {
13377 MaxSizeToCreatePrecedenceLiteralsInDisjunctive = other.MaxSizeToCreatePrecedenceLiteralsInDisjunctive;
13379 if (other.HasUseStrongPropagationInDisjunctive) {
13380 UseStrongPropagationInDisjunctive = other.UseStrongPropagationInDisjunctive;
13382 if (other.HasUseDynamicPrecedenceInDisjunctive) {
13383 UseDynamicPrecedenceInDisjunctive = other.UseDynamicPrecedenceInDisjunctive;
13385 if (other.HasUseDynamicPrecedenceInCumulative) {
13386 UseDynamicPrecedenceInCumulative = other.UseDynamicPrecedenceInCumulative;
13388 if (other.HasUseOverloadCheckerInCumulative) {
13389 UseOverloadCheckerInCumulative = other.UseOverloadCheckerInCumulative;
13391 if (other.HasUseConservativeScaleOverloadChecker) {
13392 UseConservativeScaleOverloadChecker = other.UseConservativeScaleOverloadChecker;
13394 if (other.HasUseTimetableEdgeFindingInCumulative) {
13395 UseTimetableEdgeFindingInCumulative = other.UseTimetableEdgeFindingInCumulative;
13397 if (other.HasMaxNumIntervalsForTimetableEdgeFinding) {
13398 MaxNumIntervalsForTimetableEdgeFinding = other.MaxNumIntervalsForTimetableEdgeFinding;
13400 if (other.HasUseHardPrecedencesInCumulative) {
13401 UseHardPrecedencesInCumulative = other.UseHardPrecedencesInCumulative;
13403 if (other.HasExploitAllPrecedences) {
13404 ExploitAllPrecedences = other.ExploitAllPrecedences;
13406 if (other.HasUseDisjunctiveConstraintInCumulative) {
13407 UseDisjunctiveConstraintInCumulative = other.UseDisjunctiveConstraintInCumulative;
13409 if (other.HasNoOverlap2DBooleanRelationsLimit) {
13410 NoOverlap2DBooleanRelationsLimit = other.NoOverlap2DBooleanRelationsLimit;
13412 if (other.HasUseTimetablingInNoOverlap2D) {
13413 UseTimetablingInNoOverlap2D = other.UseTimetablingInNoOverlap2D;
13415 if (other.HasUseEnergeticReasoningInNoOverlap2D) {
13416 UseEnergeticReasoningInNoOverlap2D = other.UseEnergeticReasoningInNoOverlap2D;
13418 if (other.HasUseAreaEnergeticReasoningInNoOverlap2D) {
13419 UseAreaEnergeticReasoningInNoOverlap2D = other.UseAreaEnergeticReasoningInNoOverlap2D;
13421 if (other.HasUseTryEdgeReasoningInNoOverlap2D) {
13422 UseTryEdgeReasoningInNoOverlap2D = other.UseTryEdgeReasoningInNoOverlap2D;
13424 if (other.HasMaxPairsPairwiseReasoningInNoOverlap2D) {
13425 MaxPairsPairwiseReasoningInNoOverlap2D = other.MaxPairsPairwiseReasoningInNoOverlap2D;
13427 if (other.HasMaximumRegionsToSplitInDisconnectedNoOverlap2D) {
13428 MaximumRegionsToSplitInDisconnectedNoOverlap2D = other.MaximumRegionsToSplitInDisconnectedNoOverlap2D;
13430 if (other.HasUseLinear3ForNoOverlap2DPrecedences) {
13431 UseLinear3ForNoOverlap2DPrecedences = other.UseLinear3ForNoOverlap2DPrecedences;
13433 if (other.HasUseDualSchedulingHeuristics) {
13434 UseDualSchedulingHeuristics = other.UseDualSchedulingHeuristics;
13436 if (other.HasUseAllDifferentForCircuit) {
13437 UseAllDifferentForCircuit = other.UseAllDifferentForCircuit;
13439 if (other.HasRoutingCutSubsetSizeForBinaryRelationBound) {
13440 RoutingCutSubsetSizeForBinaryRelationBound = other.RoutingCutSubsetSizeForBinaryRelationBound;
13442 if (other.HasRoutingCutSubsetSizeForTightBinaryRelationBound) {
13443 RoutingCutSubsetSizeForTightBinaryRelationBound = other.RoutingCutSubsetSizeForTightBinaryRelationBound;
13445 if (other.HasRoutingCutSubsetSizeForExactBinaryRelationBound) {
13446 RoutingCutSubsetSizeForExactBinaryRelationBound = other.RoutingCutSubsetSizeForExactBinaryRelationBound;
13448 if (other.HasRoutingCutSubsetSizeForShortestPathsBound) {
13449 RoutingCutSubsetSizeForShortestPathsBound = other.RoutingCutSubsetSizeForShortestPathsBound;
13451 if (other.HasRoutingCutDpEffort) {
13452 RoutingCutDpEffort = other.RoutingCutDpEffort;
13454 if (other.HasRoutingCutMaxInfeasiblePathLength) {
13455 RoutingCutMaxInfeasiblePathLength = other.RoutingCutMaxInfeasiblePathLength;
13457 if (other.HasSearchBranching) {
13458 SearchBranching = other.SearchBranching;
13460 if (other.HasHintConflictLimit) {
13461 HintConflictLimit = other.HintConflictLimit;
13463 if (other.HasRepairHint) {
13464 RepairHint = other.RepairHint;
13466 if (other.HasFixVariablesToTheirHintedValue) {
13467 FixVariablesToTheirHintedValue = other.FixVariablesToTheirHintedValue;
13469 if (other.HasUseProbingSearch) {
13470 UseProbingSearch = other.UseProbingSearch;
13472 if (other.HasUseExtendedProbing) {
13473 UseExtendedProbing = other.UseExtendedProbing;
13475 if (other.HasProbingNumCombinationsLimit) {
13476 ProbingNumCombinationsLimit = other.ProbingNumCombinationsLimit;
13478 if (other.HasShavingDeterministicTimeInProbingSearch) {
13479 ShavingDeterministicTimeInProbingSearch = other.ShavingDeterministicTimeInProbingSearch;
13481 if (other.HasShavingSearchDeterministicTime) {
13482 ShavingSearchDeterministicTime = other.ShavingSearchDeterministicTime;
13484 if (other.HasShavingSearchThreshold) {
13485 ShavingSearchThreshold = other.ShavingSearchThreshold;
13487 if (other.HasUseObjectiveLbSearch) {
13488 UseObjectiveLbSearch = other.UseObjectiveLbSearch;
13490 if (other.HasUseObjectiveShavingSearch) {
13491 UseObjectiveShavingSearch = other.UseObjectiveShavingSearch;
13493 if (other.HasVariablesShavingLevel) {
13494 VariablesShavingLevel = other.VariablesShavingLevel;
13496 if (other.HasPseudoCostReliabilityThreshold) {
13497 PseudoCostReliabilityThreshold = other.PseudoCostReliabilityThreshold;
13499 if (other.HasOptimizeWithCore) {
13500 OptimizeWithCore = other.OptimizeWithCore;
13502 if (other.HasOptimizeWithLbTreeSearch) {
13503 OptimizeWithLbTreeSearch = other.OptimizeWithLbTreeSearch;
13505 if (other.HasSaveLpBasisInLbTreeSearch) {
13506 SaveLpBasisInLbTreeSearch = other.SaveLpBasisInLbTreeSearch;
13508 if (other.HasBinarySearchNumConflicts) {
13509 BinarySearchNumConflicts = other.BinarySearchNumConflicts;
13511 if (other.HasOptimizeWithMaxHs) {
13512 OptimizeWithMaxHs = other.OptimizeWithMaxHs;
13514 if (other.HasUseFeasibilityJump) {
13515 UseFeasibilityJump = other.UseFeasibilityJump;
13517 if (other.HasUseLsOnly) {
13518 UseLsOnly = other.UseLsOnly;
13520 if (other.HasFeasibilityJumpDecay) {
13521 FeasibilityJumpDecay = other.FeasibilityJumpDecay;
13523 if (other.HasFeasibilityJumpLinearizationLevel) {
13524 FeasibilityJumpLinearizationLevel = other.FeasibilityJumpLinearizationLevel;
13526 if (other.HasFeasibilityJumpRestartFactor) {
13527 FeasibilityJumpRestartFactor = other.FeasibilityJumpRestartFactor;
13529 if (other.HasFeasibilityJumpBatchDtime) {
13530 FeasibilityJumpBatchDtime = other.FeasibilityJumpBatchDtime;
13532 if (other.HasFeasibilityJumpVarRandomizationProbability) {
13533 FeasibilityJumpVarRandomizationProbability = other.FeasibilityJumpVarRandomizationProbability;
13535 if (other.HasFeasibilityJumpVarPerburbationRangeRatio) {
13536 FeasibilityJumpVarPerburbationRangeRatio = other.FeasibilityJumpVarPerburbationRangeRatio;
13538 if (other.HasFeasibilityJumpEnableRestarts) {
13539 FeasibilityJumpEnableRestarts = other.FeasibilityJumpEnableRestarts;
13541 if (other.HasFeasibilityJumpMaxExpandedConstraintSize) {
13542 FeasibilityJumpMaxExpandedConstraintSize = other.FeasibilityJumpMaxExpandedConstraintSize;
13544 if (other.HasNumViolationLs) {
13545 NumViolationLs = other.NumViolationLs;
13547 if (other.HasViolationLsPerturbationPeriod) {
13548 ViolationLsPerturbationPeriod = other.ViolationLsPerturbationPeriod;
13550 if (other.HasViolationLsCompoundMoveProbability) {
13551 ViolationLsCompoundMoveProbability = other.ViolationLsCompoundMoveProbability;
13553 if (other.HasSharedTreeNumWorkers) {
13554 SharedTreeNumWorkers = other.SharedTreeNumWorkers;
13556 if (other.HasUseSharedTreeSearch) {
13557 UseSharedTreeSearch = other.UseSharedTreeSearch;
13559 if (other.HasSharedTreeWorkerMinRestartsPerSubtree) {
13560 SharedTreeWorkerMinRestartsPerSubtree = other.SharedTreeWorkerMinRestartsPerSubtree;
13562 if (other.HasSharedTreeWorkerEnableTrailSharing) {
13563 SharedTreeWorkerEnableTrailSharing = other.SharedTreeWorkerEnableTrailSharing;
13565 if (other.HasSharedTreeWorkerEnablePhaseSharing) {
13566 SharedTreeWorkerEnablePhaseSharing = other.SharedTreeWorkerEnablePhaseSharing;
13568 if (other.HasSharedTreeOpenLeavesPerWorker) {
13569 SharedTreeOpenLeavesPerWorker = other.SharedTreeOpenLeavesPerWorker;
13571 if (other.HasSharedTreeMaxNodesPerWorker) {
13572 SharedTreeMaxNodesPerWorker = other.SharedTreeMaxNodesPerWorker;
13574 if (other.HasSharedTreeSplitStrategy) {
13575 SharedTreeSplitStrategy = other.SharedTreeSplitStrategy;
13577 if (other.HasSharedTreeBalanceTolerance) {
13578 SharedTreeBalanceTolerance = other.SharedTreeBalanceTolerance;
13580 if (other.HasEnumerateAllSolutions) {
13581 EnumerateAllSolutions = other.EnumerateAllSolutions;
13583 if (other.HasKeepAllFeasibleSolutionsInPresolve) {
13584 KeepAllFeasibleSolutionsInPresolve = other.KeepAllFeasibleSolutionsInPresolve;
13586 if (other.HasFillTightenedDomainsInResponse) {
13587 FillTightenedDomainsInResponse = other.FillTightenedDomainsInResponse;
13589 if (other.HasFillAdditionalSolutionsInResponse) {
13590 FillAdditionalSolutionsInResponse = other.FillAdditionalSolutionsInResponse;
13592 if (other.HasInstantiateAllVariables) {
13593 InstantiateAllVariables = other.InstantiateAllVariables;
13595 if (other.HasAutoDetectGreaterThanAtLeastOneOf) {
13596 AutoDetectGreaterThanAtLeastOneOf = other.AutoDetectGreaterThanAtLeastOneOf;
13598 if (other.HasStopAfterFirstSolution) {
13599 StopAfterFirstSolution = other.StopAfterFirstSolution;
13601 if (other.HasStopAfterPresolve) {
13602 StopAfterPresolve = other.StopAfterPresolve;
13604 if (other.HasStopAfterRootPropagation) {
13605 StopAfterRootPropagation = other.StopAfterRootPropagation;
13607 if (other.HasLnsInitialDifficulty) {
13608 LnsInitialDifficulty = other.LnsInitialDifficulty;
13610 if (other.HasLnsInitialDeterministicLimit) {
13611 LnsInitialDeterministicLimit = other.LnsInitialDeterministicLimit;
13613 if (other.HasUseLns) {
13614 UseLns = other.UseLns;
13616 if (other.HasUseLnsOnly) {
13617 UseLnsOnly = other.UseLnsOnly;
13619 if (other.HasSolutionPoolSize) {
13620 SolutionPoolSize = other.SolutionPoolSize;
13622 if (other.HasUseRinsLns) {
13623 UseRinsLns = other.UseRinsLns;
13625 if (other.HasUseFeasibilityPump) {
13626 UseFeasibilityPump = other.UseFeasibilityPump;
13628 if (other.HasUseLbRelaxLns) {
13629 UseLbRelaxLns = other.UseLbRelaxLns;
13631 if (other.HasLbRelaxNumWorkersThreshold) {
13632 LbRelaxNumWorkersThreshold = other.LbRelaxNumWorkersThreshold;
13634 if (other.HasFpRounding) {
13635 FpRounding = other.FpRounding;
13637 if (other.HasDiversifyLnsParams) {
13638 DiversifyLnsParams = other.DiversifyLnsParams;
13640 if (other.HasRandomizeSearch) {
13641 RandomizeSearch = other.RandomizeSearch;
13643 if (other.HasSearchRandomVariablePoolSize) {
13644 SearchRandomVariablePoolSize = other.SearchRandomVariablePoolSize;
13646 if (other.HasPushAllTasksTowardStart) {
13647 PushAllTasksTowardStart = other.PushAllTasksTowardStart;
13649 if (other.HasUseOptionalVariables) {
13650 UseOptionalVariables = other.UseOptionalVariables;
13652 if (other.HasUseExactLpReason) {
13653 UseExactLpReason = other.UseExactLpReason;
13655 if (other.HasUseCombinedNoOverlap) {
13656 UseCombinedNoOverlap = other.UseCombinedNoOverlap;
13658 if (other.HasAtMostOneMaxExpansionSize) {
13659 AtMostOneMaxExpansionSize = other.AtMostOneMaxExpansionSize;
13661 if (other.HasCatchSigintSignal) {
13662 CatchSigintSignal = other.CatchSigintSignal;
13664 if (other.HasUseImpliedBounds) {
13665 UseImpliedBounds = other.UseImpliedBounds;
13667 if (other.HasPolishLpSolution) {
13668 PolishLpSolution = other.PolishLpSolution;
13670 if (other.HasLpPrimalTolerance) {
13671 LpPrimalTolerance = other.LpPrimalTolerance;
13673 if (other.HasLpDualTolerance) {
13674 LpDualTolerance = other.LpDualTolerance;
13676 if (other.HasConvertIntervals) {
13677 ConvertIntervals = other.ConvertIntervals;
13679 if (other.HasSymmetryLevel) {
13680 SymmetryLevel = other.SymmetryLevel;
13682 if (other.HasUseSymmetryInLp) {
13683 UseSymmetryInLp = other.UseSymmetryInLp;
13685 if (other.HasKeepSymmetryInPresolve) {
13686 KeepSymmetryInPresolve = other.KeepSymmetryInPresolve;
13688 if (other.HasSymmetryDetectionDeterministicTimeLimit) {
13689 SymmetryDetectionDeterministicTimeLimit = other.SymmetryDetectionDeterministicTimeLimit;
13691 if (other.HasNewLinearPropagation) {
13692 NewLinearPropagation = other.NewLinearPropagation;
13694 if (other.HasLinearSplitSize) {
13695 LinearSplitSize = other.LinearSplitSize;
13697 if (other.HasLinearizationLevel) {
13698 LinearizationLevel = other.LinearizationLevel;
13700 if (other.HasBooleanEncodingLevel) {
13701 BooleanEncodingLevel = other.BooleanEncodingLevel;
13703 if (other.HasMaxDomainSizeWhenEncodingEqNeqConstraints) {
13704 MaxDomainSizeWhenEncodingEqNeqConstraints = other.MaxDomainSizeWhenEncodingEqNeqConstraints;
13706 if (other.HasMaxNumCuts) {
13707 MaxNumCuts = other.MaxNumCuts;
13709 if (other.HasCutLevel) {
13710 CutLevel = other.CutLevel;
13712 if (other.HasOnlyAddCutsAtLevelZero) {
13713 OnlyAddCutsAtLevelZero = other.OnlyAddCutsAtLevelZero;
13715 if (other.HasAddObjectiveCut) {
13716 AddObjectiveCut = other.AddObjectiveCut;
13718 if (other.HasAddCgCuts) {
13719 AddCgCuts = other.AddCgCuts;
13721 if (other.HasAddMirCuts) {
13722 AddMirCuts = other.AddMirCuts;
13724 if (other.HasAddZeroHalfCuts) {
13725 AddZeroHalfCuts = other.AddZeroHalfCuts;
13727 if (other.HasAddCliqueCuts) {
13728 AddCliqueCuts = other.AddCliqueCuts;
13730 if (other.HasAddRltCuts) {
13731 AddRltCuts = other.AddRltCuts;
13733 if (other.HasMaxAllDiffCutSize) {
13734 MaxAllDiffCutSize = other.MaxAllDiffCutSize;
13736 if (other.HasAddLinMaxCuts) {
13737 AddLinMaxCuts = other.AddLinMaxCuts;
13739 if (other.HasMaxIntegerRoundingScaling) {
13740 MaxIntegerRoundingScaling = other.MaxIntegerRoundingScaling;
13742 if (other.HasAddLpConstraintsLazily) {
13743 AddLpConstraintsLazily = other.AddLpConstraintsLazily;
13745 if (other.HasRootLpIterations) {
13746 RootLpIterations = other.RootLpIterations;
13748 if (other.HasMinOrthogonalityForLpConstraints) {
13749 MinOrthogonalityForLpConstraints = other.MinOrthogonalityForLpConstraints;
13751 if (other.HasMaxCutRoundsAtLevelZero) {
13752 MaxCutRoundsAtLevelZero = other.MaxCutRoundsAtLevelZero;
13754 if (other.HasMaxConsecutiveInactiveCount) {
13755 MaxConsecutiveInactiveCount = other.MaxConsecutiveInactiveCount;
13757 if (other.HasCutMaxActiveCountValue) {
13758 CutMaxActiveCountValue = other.CutMaxActiveCountValue;
13760 if (other.HasCutActiveCountDecay) {
13761 CutActiveCountDecay = other.CutActiveCountDecay;
13763 if (other.HasCutCleanupTarget) {
13764 CutCleanupTarget = other.CutCleanupTarget;
13766 if (other.HasNewConstraintsBatchSize) {
13767 NewConstraintsBatchSize = other.NewConstraintsBatchSize;
13769 if (other.HasExploitIntegerLpSolution) {
13770 ExploitIntegerLpSolution = other.ExploitIntegerLpSolution;
13772 if (other.HasExploitAllLpSolution) {
13773 ExploitAllLpSolution = other.ExploitAllLpSolution;
13775 if (other.HasExploitBestSolution) {
13776 ExploitBestSolution = other.ExploitBestSolution;
13778 if (other.HasExploitRelaxationSolution) {
13779 ExploitRelaxationSolution = other.ExploitRelaxationSolution;
13781 if (other.HasExploitObjective) {
13782 ExploitObjective = other.ExploitObjective;
13784 if (other.HasDetectLinearizedProduct) {
13785 DetectLinearizedProduct = other.DetectLinearizedProduct;
13787 if (other.HasMipMaxBound) {
13788 MipMaxBound = other.MipMaxBound;
13790 if (other.HasMipVarScaling) {
13791 MipVarScaling = other.MipVarScaling;
13793 if (other.HasMipScaleLargeDomain) {
13794 MipScaleLargeDomain = other.MipScaleLargeDomain;
13796 if (other.HasMipAutomaticallyScaleVariables) {
13797 MipAutomaticallyScaleVariables = other.MipAutomaticallyScaleVariables;
13799 if (other.HasOnlySolveIp) {
13800 OnlySolveIp = other.OnlySolveIp;
13802 if (other.HasMipWantedPrecision) {
13803 MipWantedPrecision = other.MipWantedPrecision;
13805 if (other.HasMipMaxActivityExponent) {
13806 MipMaxActivityExponent = other.MipMaxActivityExponent;
13808 if (other.HasMipCheckPrecision) {
13809 MipCheckPrecision = other.MipCheckPrecision;
13811 if (other.HasMipComputeTrueObjectiveBound) {
13812 MipComputeTrueObjectiveBound = other.MipComputeTrueObjectiveBound;
13814 if (other.HasMipMaxValidMagnitude) {
13815 MipMaxValidMagnitude = other.MipMaxValidMagnitude;
13817 if (other.HasMipTreatHighMagnitudeBoundsAsInfinity) {
13818 MipTreatHighMagnitudeBoundsAsInfinity = other.MipTreatHighMagnitudeBoundsAsInfinity;
13820 if (other.HasMipDropTolerance) {
13821 MipDropTolerance = other.MipDropTolerance;
13823 if (other.HasMipPresolveLevel) {
13824 MipPresolveLevel = other.MipPresolveLevel;
13826 _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
13829 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
13830 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
13831 public void MergeFrom(pb::CodedInputStream input) {
13832 #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
13833 input.ReadRawMessage(
this);
13836 while ((tag = input.ReadTag()) != 0) {
13837 if ((tag & 7) == 4) {
13843 _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
13846 PreferredVariableOrder = (global::Google.OrTools.Sat.SatParameters.Types.VariableOrder) input.ReadEnum();
13850 InitialPolarity = (global::Google.OrTools.Sat.SatParameters.Types.Polarity) input.ReadEnum();
13854 MinimizationAlgorithm = (global::Google.OrTools.Sat.SatParameters.Types.ConflictMinimizationAlgorithm) input.ReadEnum();
13858 ClauseCleanupPeriod = input.ReadInt32();
13862 ClauseCleanupTarget = input.ReadInt32();
13866 VariableActivityDecay = input.ReadDouble();
13870 MaxVariableActivityValue = input.ReadDouble();
13874 ClauseActivityDecay = input.ReadDouble();
13878 MaxClauseActivityValue = input.ReadDouble();
13882 GlucoseMaxDecay = input.ReadDouble();
13886 GlucoseDecayIncrement = input.ReadDouble();
13890 GlucoseDecayIncrementPeriod = input.ReadInt32();
13894 RestartPeriod = input.ReadInt32();
13898 RandomSeed = input.ReadInt32();
13902 RandomBranchesRatio = input.ReadDouble();
13906 BinaryMinimizationAlgorithm = (global::Google.OrTools.Sat.SatParameters.Types.BinaryMinizationAlgorithm) input.ReadEnum();
13910 UseOptimizationHints = input.ReadBool();
13914 MaxTimeInSeconds = input.ReadDouble();
13918 MaxNumberOfConflicts = input.ReadInt64();
13922 MaxMemoryInMb = input.ReadInt64();
13926 LogSearchProgress = input.ReadBool();
13930 UsePbResolution = input.ReadBool();
13934 UsePhaseSaving = input.ReadBool();
13938 RandomPolarityRatio = input.ReadDouble();
13942 PbCleanupIncrement = input.ReadInt32();
13946 PbCleanupRatio = input.ReadDouble();
13950 MinimizeReductionDuringPbResolution = input.ReadBool();
13954 CountAssumptionLevelsInLbd = input.ReadBool();
13958 CoreMinimizationLevel = input.ReadInt32();
13962 MaxSatAssumptionOrder = (global::Google.OrTools.Sat.SatParameters.Types.MaxSatAssumptionOrder) input.ReadEnum();
13966 MaxSatReverseAssumptionOrder = input.ReadBool();
13970 MaxSatStratification = (global::Google.OrTools.Sat.SatParameters.Types.MaxSatStratificationAlgorithm) input.ReadEnum();
13974 PresolveBveThreshold = input.ReadInt32();
13978 PresolveBveClauseWeight = input.ReadInt32();
13982 SubsumptionDuringConflictAnalysis = input.ReadBool();
13986 PresolveProbingDeterministicTimeLimit = input.ReadDouble();
13990 ClauseCleanupProtection = (global::Google.OrTools.Sat.SatParameters.Types.ClauseProtection) input.ReadEnum();
13994 ClauseCleanupLbdBound = input.ReadInt32();
13998 ClauseCleanupOrdering = (global::Google.OrTools.Sat.SatParameters.Types.ClauseOrdering) input.ReadEnum();
14003 restartAlgorithms_.AddEntriesFrom(input, _repeated_restartAlgorithms_codec);
14007 RestartRunningWindowSize = input.ReadInt32();
14011 RestartDlAverageRatio = input.ReadDouble();
14015 UseBlockingRestart = input.ReadBool();
14019 BlockingRestartWindowSize = input.ReadInt32();
14023 BlockingRestartMultiplier = input.ReadDouble();
14027 MaxDeterministicTime = input.ReadDouble();
14031 NumConflictsBeforeStrategyChanges = input.ReadInt32();
14035 StrategyChangeIncreaseRatio = input.ReadDouble();
14039 DefaultRestartAlgorithms = input.ReadString();
14043 RestartLbdAverageRatio = input.ReadDouble();
14047 PresolveUseBva = input.ReadBool();
14051 PresolveBvaThreshold = input.ReadInt32();
14055 UsePrecedencesInDisjunctiveConstraint = input.ReadBool();
14059 UseErwaHeuristic = input.ReadBool();
14063 InitialVariablesActivity = input.ReadDouble();
14067 AlsoBumpVariablesInConflictReasons = input.ReadBool();
14071 UseOverloadCheckerInCumulative = input.ReadBool();
14075 UseTimetableEdgeFindingInCumulative = input.ReadBool();
14079 UseDisjunctiveConstraintInCumulative = input.ReadBool();
14083 SearchBranching = (global::Google.OrTools.Sat.SatParameters.Types.SearchBranching) input.ReadEnum();
14087 OptimizeWithCore = input.ReadBool();
14091 FindMultipleCores = input.ReadBool();
14095 OptimizeWithMaxHs = input.ReadBool();
14099 CpModelPresolve = input.ReadBool();
14103 EnumerateAllSolutions = input.ReadBool();
14107 PresolveBlockedClause = input.ReadBool();
14111 CoverOptimization = input.ReadBool();
14115 LinearizationLevel = input.ReadInt32();
14119 MaxNumCuts = input.ReadInt32();
14123 OnlyAddCutsAtLevelZero = input.ReadBool();
14127 CpModelUseSatPresolve = input.ReadBool();
14131 ExploitIntegerLpSolution = input.ReadBool();
14135 AutoDetectGreaterThanAtLeastOneOf = input.ReadBool();
14139 StopAfterFirstSolution = input.ReadBool();
14143 BinarySearchNumConflicts = input.ReadInt32();
14147 NumSearchWorkers = input.ReadInt32();
14151 UseLnsOnly = input.ReadBool();
14155 RandomizeSearch = input.ReadBool();
14159 SearchRandomVariablePoolSize = input.ReadInt64();
14163 InstantiateAllVariables = input.ReadBool();
14167 BooleanEncodingLevel = input.ReadInt32();
14171 UseOptionalVariables = input.ReadBool();
14175 UseExactLpReason = input.ReadBool();
14179 CpModelProbingLevel = input.ReadInt32();
14183 AddLpConstraintsLazily = input.ReadBool();
14187 ShareObjectiveBounds = input.ReadBool();
14191 ShareLevelZeroBounds = input.ReadBool();
14195 MinOrthogonalityForLpConstraints = input.ReadDouble();
14199 ExploitAllLpSolution = input.ReadBool();
14203 AddCgCuts = input.ReadBool();
14207 MaxIntegerRoundingScaling = input.ReadInt32();
14211 AddMirCuts = input.ReadBool();
14215 MaxConsecutiveInactiveCount = input.ReadInt32();
14219 NewConstraintsBatchSize = input.ReadInt32();
14223 PseudoCostReliabilityThreshold = input.ReadInt64();
14227 MipMaxBound = input.ReadDouble();
14231 MipVarScaling = input.ReadDouble();
14235 MipWantedPrecision = input.ReadDouble();
14239 MipMaxActivityExponent = input.ReadInt32();
14243 MipCheckPrecision = input.ReadDouble();
14247 UseRinsLns = input.ReadBool();
14251 ExploitBestSolution = input.ReadBool();
14255 ExploitObjective = input.ReadBool();
14259 FillTightenedDomainsInResponse = input.ReadBool();
14263 UseCombinedNoOverlap = input.ReadBool();
14267 InterleaveBatchSize = input.ReadInt32();
14271 CatchSigintSignal = input.ReadBool();
14275 InterleaveSearch = input.ReadBool();
14279 DiversifyLnsParams = input.ReadBool();
14283 MaxPresolveIterations = input.ReadInt32();
14287 UseImpliedBounds = input.ReadBool();
14291 MergeNoOverlapWorkLimit = input.ReadDouble();
14295 MergeAtMostOneWorkLimit = input.ReadDouble();
14299 PresolveSubstitutionLevel = input.ReadInt32();
14303 MaxAllDiffCutSize = input.ReadInt32();
14307 StopAfterPresolve = input.ReadBool();
14311 DebugMaxNumPresolveOperations = input.ReadInt32();
14315 AddLinMaxCuts = input.ReadBool();
14319 HintConflictLimit = input.ReadInt32();
14323 MaxCutRoundsAtLevelZero = input.ReadInt32();
14327 CutMaxActiveCountValue = input.ReadDouble();
14331 CutActiveCountDecay = input.ReadDouble();
14335 CutCleanupTarget = input.ReadInt32();
14339 AbsoluteGapLimit = input.ReadDouble();
14343 RelativeGapLimit = input.ReadDouble();
14347 ExploitRelaxationSolution = input.ReadBool();
14351 DebugPostsolveWithFullSolver = input.ReadBool();
14355 UseSatInprocessing = input.ReadBool();
14359 UseFeasibilityPump = input.ReadBool();
14363 FpRounding = (global::Google.OrTools.Sat.SatParameters.Types.FPRoundingMethod) input.ReadEnum();
14367 MipAutomaticallyScaleVariables = input.ReadBool();
14371 RepairHint = input.ReadBool();
14375 PolarityRephaseIncrement = input.ReadInt32();
14379 AddZeroHalfCuts = input.ReadBool();
14383 ExpandAlldiffConstraints = input.ReadBool();
14387 Name = input.ReadString();
14391 AddCliqueCuts = input.ReadBool();
14395 KeepAllFeasibleSolutionsInPresolve = input.ReadBool();
14399 PresolveExtractIntegerEnforcement = input.ReadBool();
14403 PolishLpSolution = input.ReadBool();
14407 UseProbingSearch = input.ReadBool();
14411 ConvertIntervals = input.ReadBool();
14415 PermuteVariableRandomly = input.ReadBool();
14419 PermutePresolveConstraintOrder = input.ReadBool();
14423 UseAbslRandom = input.ReadBool();
14427 DisableConstraintExpansion = input.ReadBool();
14431 ExpandReservoirConstraints = input.ReadBool();
14435 SymmetryLevel = input.ReadInt32();
14439 LogPrefix = input.ReadString();
14443 LogToStdout = input.ReadBool();
14447 LogToResponse = input.ReadBool();
14451 OptimizeWithLbTreeSearch = input.ReadBool();
14455 LogSubsolverStatistics = input.ReadBool();
14459 ClauseCleanupRatio = input.ReadDouble();
14463 MaxDomainSizeWhenEncodingEqNeqConstraints = input.ReadInt32();
14467 FixVariablesToTheirHintedValue = input.ReadBool();
14471 SolutionPoolSize = input.ReadInt32();
14475 FillAdditionalSolutionsInResponse = input.ReadBool();
14479 DebugCrashOnBadHint = input.ReadBool();
14483 CutLevel = input.ReadInt32();
14487 AddObjectiveCut = input.ReadBool();
14491 MipComputeTrueObjectiveBound = input.ReadBool();
14495 MipMaxValidMagnitude = input.ReadDouble();
14499 UseTimetablingInNoOverlap2D = input.ReadBool();
14503 PresolveInclusionWorkLimit = input.ReadInt64();
14507 IgnoreNames = input.ReadBool();
14511 ShareBinaryClauses = input.ReadBool();
14515 ShavingDeterministicTimeInProbingSearch = input.ReadDouble();
14519 ShavingSearchDeterministicTime = input.ReadDouble();
14523 NumWorkers = input.ReadInt32();
14527 subsolvers_.AddEntriesFrom(input, _repeated_subsolvers_codec);
14531 ignoreSubsolvers_.AddEntriesFrom(input, _repeated_ignoreSubsolvers_codec);
14535 subsolverParams_.AddEntriesFrom(input, _repeated_subsolverParams_codec);
14539 UseEnergeticReasoningInNoOverlap2D = input.ReadBool();
14543 UseDualSchedulingHeuristics = input.ReadBool();
14547 UseHardPrecedencesInCumulative = input.ReadBool();
14551 DetectTableWithCost = input.ReadBool();
14555 TableCompressionLevel = input.ReadInt32();
14559 extraSubsolvers_.AddEntriesFrom(input, _repeated_extraSubsolvers_codec);
14563 ExploitAllPrecedences = input.ReadBool();
14567 PropagationLoopDetectionFactor = input.ReadDouble();
14571 OnlySolveIp = input.ReadBool();
14575 EncodeComplexLinearConstraintWithInteger = input.ReadBool();
14579 NewLinearPropagation = input.ReadBool();
14583 MipScaleLargeDomain = input.ReadBool();
14587 ProbingDeterministicTimeLimit = input.ReadDouble();
14591 RootLpIterations = input.ReadInt32();
14595 UseObjectiveLbSearch = input.ReadBool();
14599 MaxSizeToCreatePrecedenceLiteralsInDisjunctive = input.ReadInt32();
14603 UseStrongPropagationInDisjunctive = input.ReadBool();
14607 MipDropTolerance = input.ReadDouble();
14611 InferAllDiffs = input.ReadBool();
14615 FindBigLinearOverlap = input.ReadBool();
14619 SharedTreeNumWorkers = input.ReadInt32();
14623 UseSharedTreeSearch = input.ReadBool();
14627 SharedTreeMaxNodesPerWorker = input.ReadInt32();
14631 SharedTreeSplitStrategy = (global::Google.OrTools.Sat.SatParameters.Types.SharedTreeSplitStrategy) input.ReadEnum();
14635 UseLsOnly = input.ReadBool();
14639 FeasibilityJumpDecay = input.ReadDouble();
14643 NumViolationLs = input.ReadInt32();
14647 FeasibilityJumpVarRandomizationProbability = input.ReadDouble();
14651 FeasibilityJumpVarPerburbationRangeRatio = input.ReadDouble();
14655 ViolationLsPerturbationPeriod = input.ReadInt32();
14659 FeasibilityJumpEnableRestarts = input.ReadBool();
14663 StopAfterRootPropagation = input.ReadBool();
14667 UseObjectiveShavingSearch = input.ReadBool();
14671 UseLbRelaxLns = input.ReadBool();
14675 LinearSplitSize = input.ReadInt32();
14679 FeasibilityJumpLinearizationLevel = input.ReadInt32();
14683 FeasibilityJumpRestartFactor = input.ReadInt32();
14687 ViolationLsCompoundMoveProbability = input.ReadDouble();
14691 MaxNumIntervalsForTimetableEdgeFinding = input.ReadInt32();
14695 MipPresolveLevel = input.ReadInt32();
14699 PushAllTasksTowardStart = input.ReadBool();
14703 UseDynamicPrecedenceInDisjunctive = input.ReadBool();
14707 FeasibilityJumpMaxExpandedConstraintSize = input.ReadInt32();
14711 UseFeasibilityJump = input.ReadBool();
14715 LpPrimalTolerance = input.ReadDouble();
14719 LpDualTolerance = input.ReadDouble();
14723 UseDynamicPrecedenceInCumulative = input.ReadBool();
14727 UseExtendedProbing = input.ReadBool();
14731 AtMostOneMaxExpansionSize = input.ReadInt32();
14735 UseAreaEnergeticReasoningInNoOverlap2D = input.ReadBool();
14739 ProbingNumCombinationsLimit = input.ReadInt32();
14743 InprocessingDtimeRatio = input.ReadDouble();
14747 InprocessingProbingDtime = input.ReadDouble();
14751 InprocessingMinimizationDtime = input.ReadDouble();
14755 MaxPairsPairwiseReasoningInNoOverlap2D = input.ReadInt32();
14759 DetectLinearizedProduct = input.ReadBool();
14763 MipTreatHighMagnitudeBoundsAsInfinity = input.ReadBool();
14767 AddRltCuts = input.ReadBool();
14771 MaxLinMaxSizeForExpansion = input.ReadInt32();
14775 SharedTreeOpenLeavesPerWorker = input.ReadDouble();
14779 SharedTreeWorkerMinRestartsPerSubtree = input.ReadInt32();
14783 UseLns = input.ReadBool();
14787 SaveLpBasisInLbTreeSearch = input.ReadBool();
14791 ShareGlueClauses = input.ReadBool();
14795 UseConservativeScaleOverloadChecker = input.ReadBool();
14799 EncodeCumulativeAsReservoir = input.ReadBool();
14803 ExpandReservoirUsingCircuit = input.ReadBool();
14807 VariablesShavingLevel = input.ReadInt32();
14811 ShavingSearchThreshold = input.ReadInt64();
14815 MaxNumDeterministicBatches = input.ReadInt32();
14819 FeasibilityJumpBatchDtime = input.ReadDouble();
14823 filterSubsolvers_.AddEntriesFrom(input, _repeated_filterSubsolvers_codec);
14827 NumFullSubsolvers = input.ReadInt32();
14831 SharedTreeWorkerEnableTrailSharing = input.ReadBool();
14835 LbRelaxNumWorkersThreshold = input.ReadInt32();
14839 InprocessingMinimizationUseConflictAnalysis = input.ReadBool();
14843 InprocessingMinimizationUseAllOrderings = input.ReadBool();
14847 UseTryEdgeReasoningInNoOverlap2D = input.ReadBool();
14851 MinimizeSharedClauses = input.ReadBool();
14855 UseSymmetryInLp = input.ReadBool();
14859 SymmetryDetectionDeterministicTimeLimit = input.ReadDouble();
14863 KeepSymmetryInPresolve = input.ReadBool();
14867 SharedTreeWorkerEnablePhaseSharing = input.ReadBool();
14871 SharedTreeBalanceTolerance = input.ReadInt32();
14875 DebugCrashIfPresolveBreaksHint = input.ReadBool();
14879 LnsInitialDifficulty = input.ReadDouble();
14883 LnsInitialDeterministicLimit = input.ReadDouble();
14887 PolarityExploitLsHints = input.ReadBool();
14891 RemoveFixedVariablesEarly = input.ReadBool();
14895 UseAllDifferentForCircuit = input.ReadBool();
14899 RoutingCutSubsetSizeForBinaryRelationBound = input.ReadInt32();
14903 RoutingCutSubsetSizeForTightBinaryRelationBound = input.ReadInt32();
14907 RoutingCutDpEffort = input.ReadDouble();
14911 MaximumRegionsToSplitInDisconnectedNoOverlap2D = input.ReadInt32();
14915 RoutingCutSubsetSizeForExactBinaryRelationBound = input.ReadInt32();
14919 RoutingCutMaxInfeasiblePathLength = input.ReadInt32();
14923 RoutingCutSubsetSizeForShortestPathsBound = input.ReadInt32();
14927 MaxAlldiffDomainSize = input.ReadInt32();
14931 NoOverlap2DBooleanRelationsLimit = input.ReadInt32();
14935 ShareGlueClausesDtime = input.ReadDouble();
14939 UseLinear3ForNoOverlap2DPrecedences = input.ReadBool();
14943 FilterSatPostsolveClauses = input.ReadBool();
14951 #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
14952 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
14953 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
14954 void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) {
14956 while ((tag = input.ReadTag()) != 0) {
14957 if ((tag & 7) == 4) {
14963 _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);
14966 PreferredVariableOrder = (global::Google.OrTools.Sat.SatParameters.Types.VariableOrder) input.ReadEnum();
14970 InitialPolarity = (global::Google.OrTools.Sat.SatParameters.Types.Polarity) input.ReadEnum();
14974 MinimizationAlgorithm = (global::Google.OrTools.Sat.SatParameters.Types.ConflictMinimizationAlgorithm) input.ReadEnum();
14978 ClauseCleanupPeriod = input.ReadInt32();
14982 ClauseCleanupTarget = input.ReadInt32();
14986 VariableActivityDecay = input.ReadDouble();
14990 MaxVariableActivityValue = input.ReadDouble();
14994 ClauseActivityDecay = input.ReadDouble();
14998 MaxClauseActivityValue = input.ReadDouble();
15002 GlucoseMaxDecay = input.ReadDouble();
15006 GlucoseDecayIncrement = input.ReadDouble();
15010 GlucoseDecayIncrementPeriod = input.ReadInt32();
15014 RestartPeriod = input.ReadInt32();
15018 RandomSeed = input.ReadInt32();
15022 RandomBranchesRatio = input.ReadDouble();
15026 BinaryMinimizationAlgorithm = (global::Google.OrTools.Sat.SatParameters.Types.BinaryMinizationAlgorithm) input.ReadEnum();
15030 UseOptimizationHints = input.ReadBool();
15034 MaxTimeInSeconds = input.ReadDouble();
15038 MaxNumberOfConflicts = input.ReadInt64();
15042 MaxMemoryInMb = input.ReadInt64();
15046 LogSearchProgress = input.ReadBool();
15050 UsePbResolution = input.ReadBool();
15054 UsePhaseSaving = input.ReadBool();
15058 RandomPolarityRatio = input.ReadDouble();
15062 PbCleanupIncrement = input.ReadInt32();
15066 PbCleanupRatio = input.ReadDouble();
15070 MinimizeReductionDuringPbResolution = input.ReadBool();
15074 CountAssumptionLevelsInLbd = input.ReadBool();
15078 CoreMinimizationLevel = input.ReadInt32();
15082 MaxSatAssumptionOrder = (global::Google.OrTools.Sat.SatParameters.Types.MaxSatAssumptionOrder) input.ReadEnum();
15086 MaxSatReverseAssumptionOrder = input.ReadBool();
15090 MaxSatStratification = (global::Google.OrTools.Sat.SatParameters.Types.MaxSatStratificationAlgorithm) input.ReadEnum();
15094 PresolveBveThreshold = input.ReadInt32();
15098 PresolveBveClauseWeight = input.ReadInt32();
15102 SubsumptionDuringConflictAnalysis = input.ReadBool();
15106 PresolveProbingDeterministicTimeLimit = input.ReadDouble();
15110 ClauseCleanupProtection = (global::Google.OrTools.Sat.SatParameters.Types.ClauseProtection) input.ReadEnum();
15114 ClauseCleanupLbdBound = input.ReadInt32();
15118 ClauseCleanupOrdering = (global::Google.OrTools.Sat.SatParameters.Types.ClauseOrdering) input.ReadEnum();
15123 restartAlgorithms_.AddEntriesFrom(ref input, _repeated_restartAlgorithms_codec);
15127 RestartRunningWindowSize = input.ReadInt32();
15131 RestartDlAverageRatio = input.ReadDouble();
15135 UseBlockingRestart = input.ReadBool();
15139 BlockingRestartWindowSize = input.ReadInt32();
15143 BlockingRestartMultiplier = input.ReadDouble();
15147 MaxDeterministicTime = input.ReadDouble();
15151 NumConflictsBeforeStrategyChanges = input.ReadInt32();
15155 StrategyChangeIncreaseRatio = input.ReadDouble();
15159 DefaultRestartAlgorithms = input.ReadString();
15163 RestartLbdAverageRatio = input.ReadDouble();
15167 PresolveUseBva = input.ReadBool();
15171 PresolveBvaThreshold = input.ReadInt32();
15175 UsePrecedencesInDisjunctiveConstraint = input.ReadBool();
15179 UseErwaHeuristic = input.ReadBool();
15183 InitialVariablesActivity = input.ReadDouble();
15187 AlsoBumpVariablesInConflictReasons = input.ReadBool();
15191 UseOverloadCheckerInCumulative = input.ReadBool();
15195 UseTimetableEdgeFindingInCumulative = input.ReadBool();
15199 UseDisjunctiveConstraintInCumulative = input.ReadBool();
15203 SearchBranching = (global::Google.OrTools.Sat.SatParameters.Types.SearchBranching) input.ReadEnum();
15207 OptimizeWithCore = input.ReadBool();
15211 FindMultipleCores = input.ReadBool();
15215 OptimizeWithMaxHs = input.ReadBool();
15219 CpModelPresolve = input.ReadBool();
15223 EnumerateAllSolutions = input.ReadBool();
15227 PresolveBlockedClause = input.ReadBool();
15231 CoverOptimization = input.ReadBool();
15235 LinearizationLevel = input.ReadInt32();
15239 MaxNumCuts = input.ReadInt32();
15243 OnlyAddCutsAtLevelZero = input.ReadBool();
15247 CpModelUseSatPresolve = input.ReadBool();
15251 ExploitIntegerLpSolution = input.ReadBool();
15255 AutoDetectGreaterThanAtLeastOneOf = input.ReadBool();
15259 StopAfterFirstSolution = input.ReadBool();
15263 BinarySearchNumConflicts = input.ReadInt32();
15267 NumSearchWorkers = input.ReadInt32();
15271 UseLnsOnly = input.ReadBool();
15275 RandomizeSearch = input.ReadBool();
15279 SearchRandomVariablePoolSize = input.ReadInt64();
15283 InstantiateAllVariables = input.ReadBool();
15287 BooleanEncodingLevel = input.ReadInt32();
15291 UseOptionalVariables = input.ReadBool();
15295 UseExactLpReason = input.ReadBool();
15299 CpModelProbingLevel = input.ReadInt32();
15303 AddLpConstraintsLazily = input.ReadBool();
15307 ShareObjectiveBounds = input.ReadBool();
15311 ShareLevelZeroBounds = input.ReadBool();
15315 MinOrthogonalityForLpConstraints = input.ReadDouble();
15319 ExploitAllLpSolution = input.ReadBool();
15323 AddCgCuts = input.ReadBool();
15327 MaxIntegerRoundingScaling = input.ReadInt32();
15331 AddMirCuts = input.ReadBool();
15335 MaxConsecutiveInactiveCount = input.ReadInt32();
15339 NewConstraintsBatchSize = input.ReadInt32();
15343 PseudoCostReliabilityThreshold = input.ReadInt64();
15347 MipMaxBound = input.ReadDouble();
15351 MipVarScaling = input.ReadDouble();
15355 MipWantedPrecision = input.ReadDouble();
15359 MipMaxActivityExponent = input.ReadInt32();
15363 MipCheckPrecision = input.ReadDouble();
15367 UseRinsLns = input.ReadBool();
15371 ExploitBestSolution = input.ReadBool();
15375 ExploitObjective = input.ReadBool();
15379 FillTightenedDomainsInResponse = input.ReadBool();
15383 UseCombinedNoOverlap = input.ReadBool();
15387 InterleaveBatchSize = input.ReadInt32();
15391 CatchSigintSignal = input.ReadBool();
15395 InterleaveSearch = input.ReadBool();
15399 DiversifyLnsParams = input.ReadBool();
15403 MaxPresolveIterations = input.ReadInt32();
15407 UseImpliedBounds = input.ReadBool();
15411 MergeNoOverlapWorkLimit = input.ReadDouble();
15415 MergeAtMostOneWorkLimit = input.ReadDouble();
15419 PresolveSubstitutionLevel = input.ReadInt32();
15423 MaxAllDiffCutSize = input.ReadInt32();
15427 StopAfterPresolve = input.ReadBool();
15431 DebugMaxNumPresolveOperations = input.ReadInt32();
15435 AddLinMaxCuts = input.ReadBool();
15439 HintConflictLimit = input.ReadInt32();
15443 MaxCutRoundsAtLevelZero = input.ReadInt32();
15447 CutMaxActiveCountValue = input.ReadDouble();
15451 CutActiveCountDecay = input.ReadDouble();
15455 CutCleanupTarget = input.ReadInt32();
15459 AbsoluteGapLimit = input.ReadDouble();
15463 RelativeGapLimit = input.ReadDouble();
15467 ExploitRelaxationSolution = input.ReadBool();
15471 DebugPostsolveWithFullSolver = input.ReadBool();
15475 UseSatInprocessing = input.ReadBool();
15479 UseFeasibilityPump = input.ReadBool();
15483 FpRounding = (global::Google.OrTools.Sat.SatParameters.Types.FPRoundingMethod) input.ReadEnum();
15487 MipAutomaticallyScaleVariables = input.ReadBool();
15491 RepairHint = input.ReadBool();
15495 PolarityRephaseIncrement = input.ReadInt32();
15499 AddZeroHalfCuts = input.ReadBool();
15503 ExpandAlldiffConstraints = input.ReadBool();
15507 Name = input.ReadString();
15511 AddCliqueCuts = input.ReadBool();
15515 KeepAllFeasibleSolutionsInPresolve = input.ReadBool();
15519 PresolveExtractIntegerEnforcement = input.ReadBool();
15523 PolishLpSolution = input.ReadBool();
15527 UseProbingSearch = input.ReadBool();
15531 ConvertIntervals = input.ReadBool();
15535 PermuteVariableRandomly = input.ReadBool();
15539 PermutePresolveConstraintOrder = input.ReadBool();
15543 UseAbslRandom = input.ReadBool();
15547 DisableConstraintExpansion = input.ReadBool();
15551 ExpandReservoirConstraints = input.ReadBool();
15555 SymmetryLevel = input.ReadInt32();
15559 LogPrefix = input.ReadString();
15563 LogToStdout = input.ReadBool();
15567 LogToResponse = input.ReadBool();
15571 OptimizeWithLbTreeSearch = input.ReadBool();
15575 LogSubsolverStatistics = input.ReadBool();
15579 ClauseCleanupRatio = input.ReadDouble();
15583 MaxDomainSizeWhenEncodingEqNeqConstraints = input.ReadInt32();
15587 FixVariablesToTheirHintedValue = input.ReadBool();
15591 SolutionPoolSize = input.ReadInt32();
15595 FillAdditionalSolutionsInResponse = input.ReadBool();
15599 DebugCrashOnBadHint = input.ReadBool();
15603 CutLevel = input.ReadInt32();
15607 AddObjectiveCut = input.ReadBool();
15611 MipComputeTrueObjectiveBound = input.ReadBool();
15615 MipMaxValidMagnitude = input.ReadDouble();
15619 UseTimetablingInNoOverlap2D = input.ReadBool();
15623 PresolveInclusionWorkLimit = input.ReadInt64();
15627 IgnoreNames = input.ReadBool();
15631 ShareBinaryClauses = input.ReadBool();
15635 ShavingDeterministicTimeInProbingSearch = input.ReadDouble();
15639 ShavingSearchDeterministicTime = input.ReadDouble();
15643 NumWorkers = input.ReadInt32();
15647 subsolvers_.AddEntriesFrom(ref input, _repeated_subsolvers_codec);
15651 ignoreSubsolvers_.AddEntriesFrom(ref input, _repeated_ignoreSubsolvers_codec);
15655 subsolverParams_.AddEntriesFrom(ref input, _repeated_subsolverParams_codec);
15659 UseEnergeticReasoningInNoOverlap2D = input.ReadBool();
15663 UseDualSchedulingHeuristics = input.ReadBool();
15667 UseHardPrecedencesInCumulative = input.ReadBool();
15671 DetectTableWithCost = input.ReadBool();
15675 TableCompressionLevel = input.ReadInt32();
15679 extraSubsolvers_.AddEntriesFrom(ref input, _repeated_extraSubsolvers_codec);
15683 ExploitAllPrecedences = input.ReadBool();
15687 PropagationLoopDetectionFactor = input.ReadDouble();
15691 OnlySolveIp = input.ReadBool();
15695 EncodeComplexLinearConstraintWithInteger = input.ReadBool();
15699 NewLinearPropagation = input.ReadBool();
15703 MipScaleLargeDomain = input.ReadBool();
15707 ProbingDeterministicTimeLimit = input.ReadDouble();
15711 RootLpIterations = input.ReadInt32();
15715 UseObjectiveLbSearch = input.ReadBool();
15719 MaxSizeToCreatePrecedenceLiteralsInDisjunctive = input.ReadInt32();
15723 UseStrongPropagationInDisjunctive = input.ReadBool();
15727 MipDropTolerance = input.ReadDouble();
15731 InferAllDiffs = input.ReadBool();
15735 FindBigLinearOverlap = input.ReadBool();
15739 SharedTreeNumWorkers = input.ReadInt32();
15743 UseSharedTreeSearch = input.ReadBool();
15747 SharedTreeMaxNodesPerWorker = input.ReadInt32();
15751 SharedTreeSplitStrategy = (global::Google.OrTools.Sat.SatParameters.Types.SharedTreeSplitStrategy) input.ReadEnum();
15755 UseLsOnly = input.ReadBool();
15759 FeasibilityJumpDecay = input.ReadDouble();
15763 NumViolationLs = input.ReadInt32();
15767 FeasibilityJumpVarRandomizationProbability = input.ReadDouble();
15771 FeasibilityJumpVarPerburbationRangeRatio = input.ReadDouble();
15775 ViolationLsPerturbationPeriod = input.ReadInt32();
15779 FeasibilityJumpEnableRestarts = input.ReadBool();
15783 StopAfterRootPropagation = input.ReadBool();
15787 UseObjectiveShavingSearch = input.ReadBool();
15791 UseLbRelaxLns = input.ReadBool();
15795 LinearSplitSize = input.ReadInt32();
15799 FeasibilityJumpLinearizationLevel = input.ReadInt32();
15803 FeasibilityJumpRestartFactor = input.ReadInt32();
15807 ViolationLsCompoundMoveProbability = input.ReadDouble();
15811 MaxNumIntervalsForTimetableEdgeFinding = input.ReadInt32();
15815 MipPresolveLevel = input.ReadInt32();
15819 PushAllTasksTowardStart = input.ReadBool();
15823 UseDynamicPrecedenceInDisjunctive = input.ReadBool();
15827 FeasibilityJumpMaxExpandedConstraintSize = input.ReadInt32();
15831 UseFeasibilityJump = input.ReadBool();
15835 LpPrimalTolerance = input.ReadDouble();
15839 LpDualTolerance = input.ReadDouble();
15843 UseDynamicPrecedenceInCumulative = input.ReadBool();
15847 UseExtendedProbing = input.ReadBool();
15851 AtMostOneMaxExpansionSize = input.ReadInt32();
15855 UseAreaEnergeticReasoningInNoOverlap2D = input.ReadBool();
15859 ProbingNumCombinationsLimit = input.ReadInt32();
15863 InprocessingDtimeRatio = input.ReadDouble();
15867 InprocessingProbingDtime = input.ReadDouble();
15871 InprocessingMinimizationDtime = input.ReadDouble();
15875 MaxPairsPairwiseReasoningInNoOverlap2D = input.ReadInt32();
15879 DetectLinearizedProduct = input.ReadBool();
15883 MipTreatHighMagnitudeBoundsAsInfinity = input.ReadBool();
15887 AddRltCuts = input.ReadBool();
15891 MaxLinMaxSizeForExpansion = input.ReadInt32();
15895 SharedTreeOpenLeavesPerWorker = input.ReadDouble();
15899 SharedTreeWorkerMinRestartsPerSubtree = input.ReadInt32();
15903 UseLns = input.ReadBool();
15907 SaveLpBasisInLbTreeSearch = input.ReadBool();
15911 ShareGlueClauses = input.ReadBool();
15915 UseConservativeScaleOverloadChecker = input.ReadBool();
15919 EncodeCumulativeAsReservoir = input.ReadBool();
15923 ExpandReservoirUsingCircuit = input.ReadBool();
15927 VariablesShavingLevel = input.ReadInt32();
15931 ShavingSearchThreshold = input.ReadInt64();
15935 MaxNumDeterministicBatches = input.ReadInt32();
15939 FeasibilityJumpBatchDtime = input.ReadDouble();
15943 filterSubsolvers_.AddEntriesFrom(ref input, _repeated_filterSubsolvers_codec);
15947 NumFullSubsolvers = input.ReadInt32();
15951 SharedTreeWorkerEnableTrailSharing = input.ReadBool();
15955 LbRelaxNumWorkersThreshold = input.ReadInt32();
15959 InprocessingMinimizationUseConflictAnalysis = input.ReadBool();
15963 InprocessingMinimizationUseAllOrderings = input.ReadBool();
15967 UseTryEdgeReasoningInNoOverlap2D = input.ReadBool();
15971 MinimizeSharedClauses = input.ReadBool();
15975 UseSymmetryInLp = input.ReadBool();
15979 SymmetryDetectionDeterministicTimeLimit = input.ReadDouble();
15983 KeepSymmetryInPresolve = input.ReadBool();
15987 SharedTreeWorkerEnablePhaseSharing = input.ReadBool();
15991 SharedTreeBalanceTolerance = input.ReadInt32();
15995 DebugCrashIfPresolveBreaksHint = input.ReadBool();
15999 LnsInitialDifficulty = input.ReadDouble();
16003 LnsInitialDeterministicLimit = input.ReadDouble();
16007 PolarityExploitLsHints = input.ReadBool();
16011 RemoveFixedVariablesEarly = input.ReadBool();
16015 UseAllDifferentForCircuit = input.ReadBool();
16019 RoutingCutSubsetSizeForBinaryRelationBound = input.ReadInt32();
16023 RoutingCutSubsetSizeForTightBinaryRelationBound = input.ReadInt32();
16027 RoutingCutDpEffort = input.ReadDouble();
16031 MaximumRegionsToSplitInDisconnectedNoOverlap2D = input.ReadInt32();
16035 RoutingCutSubsetSizeForExactBinaryRelationBound = input.ReadInt32();
16039 RoutingCutMaxInfeasiblePathLength = input.ReadInt32();
16043 RoutingCutSubsetSizeForShortestPathsBound = input.ReadInt32();
16047 MaxAlldiffDomainSize = input.ReadInt32();
16051 NoOverlap2DBooleanRelationsLimit = input.ReadInt32();
16055 ShareGlueClausesDtime = input.ReadDouble();
16059 UseLinear3ForNoOverlap2DPrecedences = input.ReadBool();
16063 FilterSatPostsolveClauses = input.ReadBool();
16071 #region Nested types
16073 [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
16074 [global::System.CodeDom.Compiler.GeneratedCode(
"protoc",
null)]
16075 public static partial class Types {
16080 public enum VariableOrder {
16084 [pbr::OriginalName(
"IN_ORDER")] InOrder = 0,
16085 [pbr::OriginalName(
"IN_REVERSE_ORDER")] InReverseOrder = 1,
16086 [pbr::OriginalName(
"IN_RANDOM_ORDER")] InRandomOrder = 2,
16097 public enum Polarity {
16098 [pbr::OriginalName(
"POLARITY_TRUE")] True = 0,
16099 [pbr::OriginalName(
"POLARITY_FALSE")] False = 1,
16100 [pbr::OriginalName(
"POLARITY_RANDOM")] Random = 2,
16106 public enum ConflictMinimizationAlgorithm {
16107 [pbr::OriginalName(
"NONE")]
None = 0,
16108 [pbr::OriginalName(
"SIMPLE")] Simple = 1,
16109 [pbr::OriginalName(
"RECURSIVE")] Recursive = 2,
16110 [pbr::OriginalName(
"EXPERIMENTAL")] Experimental = 3,
16116 public enum BinaryMinizationAlgorithm {
16117 [pbr::OriginalName(
"NO_BINARY_MINIMIZATION")] NoBinaryMinimization = 0,
16118 [pbr::OriginalName(
"BINARY_MINIMIZATION_FIRST")] BinaryMinimizationFirst = 1,
16119 [pbr::OriginalName(
"BINARY_MINIMIZATION_FIRST_WITH_TRANSITIVE_REDUCTION")] BinaryMinimizationFirstWithTransitiveReduction = 4,
16120 [pbr::OriginalName(
"BINARY_MINIMIZATION_WITH_REACHABILITY")] BinaryMinimizationWithReachability = 2,
16121 [pbr::OriginalName(
"EXPERIMENTAL_BINARY_MINIMIZATION")] ExperimentalBinaryMinimization = 3,
16129 public enum ClauseProtection {
16148 public enum ClauseOrdering {
16152 [pbr::OriginalName(
"CLAUSE_ACTIVITY")] ClauseActivity = 0,
16168 [pbr::OriginalName(
"NO_RESTART")]
NoRestart = 0,
16172 [pbr::OriginalName(
"LUBY_RESTART")]
LubyRestart = 1,
16184 [pbr::OriginalName(
"FIXED_RESTART")]
FixedRestart = 4,
16243 [pbr::OriginalName(
"LP_SEARCH")]
LpSearch = 3,
16318 [pbr::OriginalName(
"LOCK_BASED")]
LockBased = 1,
16344#endregion Designer generated code
1.14.0