Parameters.pb.cs

Go to the documentation of this file.

// <auto-generated>
//     Generated by the protocol buffer compiler.  DO NOT EDIT!
//     source: ortools/glop/parameters.proto
// </auto-generated>
#pragma warning disable 1591, 0612, 3021, 8981
#region Designer generated code
 
using pb = global::Google.Protobuf;
using pbc = global::Google.Protobuf.Collections;
using pbr = global::Google.Protobuf.Reflection;
using scg = global::System.Collections.Generic;
namespace Google.OrTools.Glop {

  public static partial class ParametersReflection {
 
    #region Descriptor
    public static pbr::FileDescriptor Descriptor {
      get { return descriptor; }
    }
    private static pbr::FileDescriptor descriptor;
 
    static ParametersReflection() {
      byte[] descriptorData = global::System.Convert.FromBase64String(
          string.Concat(
            "Ch1vcnRvb2xzL2dsb3AvcGFyYW1ldGVycy5wcm90bxIYb3BlcmF0aW9uc19y",
            "ZXNlYXJjaC5nbG9wItAYCg5HbG9wUGFyYW1ldGVycxJgCg5zY2FsaW5nX21l",
            "dGhvZBg5IAEoDjI5Lm9wZXJhdGlvbnNfcmVzZWFyY2guZ2xvcC5HbG9wUGFy",
            "YW1ldGVycy5TY2FsaW5nQWxnb3JpdGhtOg1FUVVJTElCUkFUSU9OEl0KEGZl",
            "YXNpYmlsaXR5X3J1bGUYASABKA4yNC5vcGVyYXRpb25zX3Jlc2VhcmNoLmds",
            "b3AuR2xvcFBhcmFtZXRlcnMuUHJpY2luZ1J1bGU6DVNURUVQRVNUX0VER0US",
            "XgoRb3B0aW1pemF0aW9uX3J1bGUYAiABKA4yNC5vcGVyYXRpb25zX3Jlc2Vh",
            "cmNoLmdsb3AuR2xvcFBhcmFtZXRlcnMuUHJpY2luZ1J1bGU6DVNURUVQRVNU",
            "X0VER0USKAoZcmVmYWN0b3JpemF0aW9uX3RocmVzaG9sZBgGIAEoAToFMWUt",
            "MDkSMAohcmVjb21wdXRlX3JlZHVjZWRfY29zdHNfdGhyZXNob2xkGAggASgB",
            "OgUxZS0wOBIrCh5yZWNvbXB1dGVfZWRnZXNfbm9ybV90aHJlc2hvbGQYCSAB",
            "KAE6AzEwMBIrChxwcmltYWxfZmVhc2liaWxpdHlfdG9sZXJhbmNlGAogASgB",
            "OgUxZS0wOBIpChpkdWFsX2ZlYXNpYmlsaXR5X3RvbGVyYW5jZRgLIAEoAToF",
            "MWUtMDgSKAoZcmF0aW9fdGVzdF96ZXJvX3RocmVzaG9sZBgMIAEoAToFMWUt",
            "MDkSIwoWaGFycmlzX3RvbGVyYW5jZV9yYXRpbxgNIAEoAToDMC41EiQKFXNt",
            "YWxsX3Bpdm90X3RocmVzaG9sZBgOIAEoAToFMWUtMDYSJwoYbWluaW11bV9h",
            "Y2NlcHRhYmxlX3Bpdm90GA8gASgBOgUxZS0wNhIdCg5kcm9wX3RvbGVyYW5j",
            "ZRg0IAEoAToFMWUtMTQSGQoLdXNlX3NjYWxpbmcYECABKAg6BHRydWUSbQoM",
            "Y29zdF9zY2FsaW5nGDwgASgOMj0ub3BlcmF0aW9uc19yZXNlYXJjaC5nbG9w",
            "Lkdsb3BQYXJhbWV0ZXJzLkNvc3RTY2FsaW5nQWxnb3JpdGhtOhhDT05UQUlO",
            "X09ORV9DT1NUX1NDQUxJTkcSYQoNaW5pdGlhbF9iYXNpcxgRIAEoDjI+Lm9w",
            "ZXJhdGlvbnNfcmVzZWFyY2guZ2xvcC5HbG9wUGFyYW1ldGVycy5Jbml0aWFs",
            "QmFzaXNIZXVyaXN0aWM6ClRSSUFOR1VMQVISIwoVdXNlX3RyYW5zcG9zZWRf",
            "bWF0cml4GBIgASgIOgR0cnVlEigKHGJhc2lzX3JlZmFjdG9yaXphdGlvbl9w",
            "ZXJpb2QYEyABKAU6AjY0EjcKKWR5bmFtaWNhbGx5X2FkanVzdF9yZWZhY3Rv",
            "cml6YXRpb25fcGVyaW9kGD8gASgIOgR0cnVlEmYKEnNvbHZlX2R1YWxfcHJv",
            "YmxlbRgUIAEoDjI3Lm9wZXJhdGlvbnNfcmVzZWFyY2guZ2xvcC5HbG9wUGFy",
            "YW1ldGVycy5Tb2x2ZXJCZWhhdmlvcjoRTEVUX1NPTFZFUl9ERUNJREUSHwoS",
            "ZHVhbGl6ZXJfdGhyZXNob2xkGBUgASgBOgMxLjUSLQoec29sdXRpb25fZmVh",
            "c2liaWxpdHlfdG9sZXJhbmNlGBYgASgBOgUxZS0wNhIuCiBwcm92aWRlX3N0",
            "cm9uZ19vcHRpbWFsX2d1YXJhbnRlZRgYIAEoCDoEdHJ1ZRIoChpjaGFuZ2Vf",
            "c3RhdHVzX3RvX2ltcHJlY2lzZRg6IAEoCDoEdHJ1ZRIpCh1tYXhfbnVtYmVy",
            "X29mX3Jlb3B0aW1pemF0aW9ucxg4IAEoAToCNDASLgogbHVfZmFjdG9yaXph",
            "dGlvbl9waXZvdF90aHJlc2hvbGQYGSABKAE6BDAuMDESIAoTbWF4X3RpbWVf",
            "aW5fc2Vjb25kcxgaIAEoAToDaW5mEiMKFm1heF9kZXRlcm1pbmlzdGljX3Rp",
            "bWUYLSABKAE6A2luZhIkChhtYXhfbnVtYmVyX29mX2l0ZXJhdGlvbnMYGyAB",
            "KAM6Ai0xEiUKGm1hcmtvd2l0el96bGF0ZXZfcGFyYW1ldGVyGB0gASgFOgEz",
            "Ei4KH21hcmtvd2l0el9zaW5ndWxhcml0eV90aHJlc2hvbGQYHiABKAE6BTFl",
            "LTE1Eh8KEHVzZV9kdWFsX3NpbXBsZXgYHyABKAg6BWZhbHNlEi0KHmFsbG93",
            "X3NpbXBsZXhfYWxnb3JpdGhtX2NoYW5nZRggIAEoCDoFZmFsc2USJwoaZGV2",
            "ZXhfd2VpZ2h0c19yZXNldF9wZXJpb2QYISABKAU6AzE1MBIfChF1c2VfcHJl",
            "cHJvY2Vzc2luZxgiIAEoCDoEdHJ1ZRIsCh51c2VfbWlkZGxlX3Byb2R1Y3Rf",
            "Zm9ybV91cGRhdGUYIyABKAg6BHRydWUSMAoiaW5pdGlhbGl6ZV9kZXZleF93",
            "aXRoX2NvbHVtbl9ub3JtcxgkIAEoCDoEdHJ1ZRI3CilleHBsb2l0X3Npbmds",
            "ZXRvbl9jb2x1bW5faW5faW5pdGlhbF9iYXNpcxglIAEoCDoEdHJ1ZRIqChpk",
            "dWFsX3NtYWxsX3Bpdm90X3RocmVzaG9sZBgmIAEoAToGMC4wMDAxEioKG3By",
            "ZXByb2Nlc3Nvcl96ZXJvX3RvbGVyYW5jZRgnIAEoAToFMWUtMDkSIwoVb2Jq",
            "ZWN0aXZlX2xvd2VyX2xpbWl0GCggASgBOgQtaW5mEiIKFW9iamVjdGl2ZV91",
            "cHBlcl9saW1pdBgpIAEoAToDaW5mEigKGmRlZ2VuZXJhdGVfbWluaXN0ZXBf",
            "ZmFjdG9yGCogASgBOgQwLjAxEhYKC3JhbmRvbV9zZWVkGCsgASgFOgExEhoK",
            "D251bV9vbXBfdGhyZWFkcxgsIAEoBToBMRIsCh1wZXJ0dXJiX2Nvc3RzX2lu",
            "X2R1YWxfc2ltcGxleBg1IAEoCDoFZmFsc2USNgoodXNlX2RlZGljYXRlZF9k",
            "dWFsX2ZlYXNpYmlsaXR5X2FsZ29yaXRobRg+IAEoCDoEdHJ1ZRIpChpyZWxh",
            "dGl2ZV9jb3N0X3BlcnR1cmJhdGlvbhg2IAEoAToFMWUtMDUSLQoecmVsYXRp",
            "dmVfbWF4X2Nvc3RfcGVydHVyYmF0aW9uGDcgASgBOgUxZS0wNxIxCiJpbml0",
            "aWFsX2NvbmRpdGlvbl9udW1iZXJfdGhyZXNob2xkGDsgASgBOgUxZSs1MBIi",
            "ChNsb2dfc2VhcmNoX3Byb2dyZXNzGD0gASgIOgVmYWxzZRIbCg1sb2dfdG9f",
            "c3Rkb3V0GEIgASgIOgR0cnVlEi4KIWNyb3Nzb3Zlcl9ib3VuZF9zbmFwcGlu",
            "Z19kaXN0YW5jZRhAIAEoAToDaW5mEhwKDnB1c2hfdG9fdmVydGV4GEEgASgI",
            "OgR0cnVlEisKHXVzZV9pbXBsaWVkX2ZyZWVfcHJlcHJvY2Vzc29yGEMgASgI",
            "OgR0cnVlEiIKE21heF92YWxpZF9tYWduaXR1ZGUYRiABKAE6BTFlKzMwEh0K",
            "DmRyb3BfbWFnbml0dWRlGEcgASgBOgUxZS0zMBIpChpkdWFsX3ByaWNlX3By",
            "aW9yaXRpemVfbm9ybRhFIAEoCDoFZmFsc2UiRgoQU2NhbGluZ0FsZ29yaXRo",
            "bRILCgdERUZBVUxUEAASEQoNRVFVSUxJQlJBVElPThABEhIKDkxJTkVBUl9Q",
            "Uk9HUkFNEAIiRAoOU29sdmVyQmVoYXZpb3ISDQoJQUxXQVlTX0RPEAASDAoI",
            "TkVWRVJfRE8QARIVChFMRVRfU09MVkVSX0RFQ0lERRACIjgKC1ByaWNpbmdS",
            "dWxlEgsKB0RBTlRaSUcQABIRCg1TVEVFUEVTVF9FREdFEAESCQoFREVWRVgQ",
            "AiJHChVJbml0aWFsQmFzaXNIZXVyaXN0aWMSCAoETk9ORRAAEgkKBUJJWEJZ",
            "EAESDgoKVFJJQU5HVUxBUhACEgkKBU1BUk9TEAMieQoUQ29zdFNjYWxpbmdB",
            "bGdvcml0aG0SEwoPTk9fQ09TVF9TQ0FMSU5HEAASHAoYQ09OVEFJTl9PTkVf",
            "Q09TVF9TQ0FMSU5HEAESFQoRTUVBTl9DT1NUX1NDQUxJTkcQAhIXChNNRURJ",
            "QU5fQ09TVF9TQ0FMSU5HEANCMQoXY29tLmdvb2dsZS5vcnRvb2xzLmdsb3BQ",
            "AaoCE0dvb2dsZS5PclRvb2xzLkdsb3A="));
      descriptor = pbr::FileDescriptor.FromGeneratedCode(descriptorData,
          new pbr::FileDescriptor[] { },
          new pbr::GeneratedClrTypeInfo(null, null, new pbr::GeneratedClrTypeInfo[] {
            new pbr::GeneratedClrTypeInfo(typeof(global::Google.OrTools.Glop.GlopParameters), global::Google.OrTools.Glop.GlopParameters.Parser, new[]{ "ScalingMethod", "FeasibilityRule", "OptimizationRule", "RefactorizationThreshold", "RecomputeReducedCostsThreshold", "RecomputeEdgesNormThreshold", "PrimalFeasibilityTolerance", "DualFeasibilityTolerance", "RatioTestZeroThreshold", "HarrisToleranceRatio", "SmallPivotThreshold", "MinimumAcceptablePivot", "DropTolerance", "UseScaling", "CostScaling", "InitialBasis", "UseTransposedMatrix", "BasisRefactorizationPeriod", "DynamicallyAdjustRefactorizationPeriod", "SolveDualProblem", "DualizerThreshold", "SolutionFeasibilityTolerance", "ProvideStrongOptimalGuarantee", "ChangeStatusToImprecise", "MaxNumberOfReoptimizations", "LuFactorizationPivotThreshold", "MaxTimeInSeconds", "MaxDeterministicTime", "MaxNumberOfIterations", "MarkowitzZlatevParameter", "MarkowitzSingularityThreshold", "UseDualSimplex", "AllowSimplexAlgorithmChange", "DevexWeightsResetPeriod", "UsePreprocessing", "UseMiddleProductFormUpdate", "InitializeDevexWithColumnNorms", "ExploitSingletonColumnInInitialBasis", "DualSmallPivotThreshold", "PreprocessorZeroTolerance", "ObjectiveLowerLimit", "ObjectiveUpperLimit", "DegenerateMinistepFactor", "RandomSeed", "NumOmpThreads", "PerturbCostsInDualSimplex", "UseDedicatedDualFeasibilityAlgorithm", "RelativeCostPerturbation", "RelativeMaxCostPerturbation", "InitialConditionNumberThreshold", "LogSearchProgress", "LogToStdout", "CrossoverBoundSnappingDistance", "PushToVertex", "UseImpliedFreePreprocessor", "MaxValidMagnitude", "DropMagnitude", "DualPricePrioritizeNorm" }, null, new[]{ typeof(global::Google.OrTools.Glop.GlopParameters.Types.ScalingAlgorithm), typeof(global::Google.OrTools.Glop.GlopParameters.Types.SolverBehavior), typeof(global::Google.OrTools.Glop.GlopParameters.Types.PricingRule), typeof(global::Google.OrTools.Glop.GlopParameters.Types.InitialBasisHeuristic), typeof(global::Google.OrTools.Glop.GlopParameters.Types.CostScalingAlgorithm) }, null, null)
          }));
    }
    #endregion
 
  }
  #region Messages
  [global::System.Diagnostics.DebuggerDisplayAttribute("{ToString(),nq}")]
  public sealed partial class GlopParameters : pb::IMessage<GlopParameters>
  #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
      , pb::IBufferMessage
  #endif
  {
    private static readonly pb::MessageParser<GlopParameters> _parser = new pb::MessageParser<GlopParameters>(() => new GlopParameters());
    private pb::UnknownFieldSet _unknownFields;
    private int _hasBits0;
    private int _hasBits1;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public static pb::MessageParser<GlopParameters> Parser { get { return _parser; } }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public static pbr::MessageDescriptor Descriptor {
      get { return global::Google.OrTools.Glop.ParametersReflection.Descriptor.MessageTypes[0]; }
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    pbr::MessageDescriptor pb::IMessage.Descriptor {
      get { return Descriptor; }
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public GlopParameters() {
      OnConstruction();
    }
 
    partial void OnConstruction();
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public GlopParameters(GlopParameters other) : this() {
      _hasBits0 = other._hasBits0;
      _hasBits1 = other._hasBits1;
      scalingMethod_ = other.scalingMethod_;
      feasibilityRule_ = other.feasibilityRule_;
      optimizationRule_ = other.optimizationRule_;
      refactorizationThreshold_ = other.refactorizationThreshold_;
      recomputeReducedCostsThreshold_ = other.recomputeReducedCostsThreshold_;
      recomputeEdgesNormThreshold_ = other.recomputeEdgesNormThreshold_;
      primalFeasibilityTolerance_ = other.primalFeasibilityTolerance_;
      dualFeasibilityTolerance_ = other.dualFeasibilityTolerance_;
      ratioTestZeroThreshold_ = other.ratioTestZeroThreshold_;
      harrisToleranceRatio_ = other.harrisToleranceRatio_;
      smallPivotThreshold_ = other.smallPivotThreshold_;
      minimumAcceptablePivot_ = other.minimumAcceptablePivot_;
      dropTolerance_ = other.dropTolerance_;
      useScaling_ = other.useScaling_;
      costScaling_ = other.costScaling_;
      initialBasis_ = other.initialBasis_;
      useTransposedMatrix_ = other.useTransposedMatrix_;
      basisRefactorizationPeriod_ = other.basisRefactorizationPeriod_;
      dynamicallyAdjustRefactorizationPeriod_ = other.dynamicallyAdjustRefactorizationPeriod_;
      solveDualProblem_ = other.solveDualProblem_;
      dualizerThreshold_ = other.dualizerThreshold_;
      solutionFeasibilityTolerance_ = other.solutionFeasibilityTolerance_;
      provideStrongOptimalGuarantee_ = other.provideStrongOptimalGuarantee_;
      changeStatusToImprecise_ = other.changeStatusToImprecise_;
      maxNumberOfReoptimizations_ = other.maxNumberOfReoptimizations_;
      luFactorizationPivotThreshold_ = other.luFactorizationPivotThreshold_;
      maxTimeInSeconds_ = other.maxTimeInSeconds_;
      maxDeterministicTime_ = other.maxDeterministicTime_;
      maxNumberOfIterations_ = other.maxNumberOfIterations_;
      markowitzZlatevParameter_ = other.markowitzZlatevParameter_;
      markowitzSingularityThreshold_ = other.markowitzSingularityThreshold_;
      useDualSimplex_ = other.useDualSimplex_;
      allowSimplexAlgorithmChange_ = other.allowSimplexAlgorithmChange_;
      devexWeightsResetPeriod_ = other.devexWeightsResetPeriod_;
      usePreprocessing_ = other.usePreprocessing_;
      useMiddleProductFormUpdate_ = other.useMiddleProductFormUpdate_;
      initializeDevexWithColumnNorms_ = other.initializeDevexWithColumnNorms_;
      exploitSingletonColumnInInitialBasis_ = other.exploitSingletonColumnInInitialBasis_;
      dualSmallPivotThreshold_ = other.dualSmallPivotThreshold_;
      preprocessorZeroTolerance_ = other.preprocessorZeroTolerance_;
      objectiveLowerLimit_ = other.objectiveLowerLimit_;
      objectiveUpperLimit_ = other.objectiveUpperLimit_;
      degenerateMinistepFactor_ = other.degenerateMinistepFactor_;
      randomSeed_ = other.randomSeed_;
      numOmpThreads_ = other.numOmpThreads_;
      perturbCostsInDualSimplex_ = other.perturbCostsInDualSimplex_;
      useDedicatedDualFeasibilityAlgorithm_ = other.useDedicatedDualFeasibilityAlgorithm_;
      relativeCostPerturbation_ = other.relativeCostPerturbation_;
      relativeMaxCostPerturbation_ = other.relativeMaxCostPerturbation_;
      initialConditionNumberThreshold_ = other.initialConditionNumberThreshold_;
      logSearchProgress_ = other.logSearchProgress_;
      logToStdout_ = other.logToStdout_;
      crossoverBoundSnappingDistance_ = other.crossoverBoundSnappingDistance_;
      pushToVertex_ = other.pushToVertex_;
      useImpliedFreePreprocessor_ = other.useImpliedFreePreprocessor_;
      maxValidMagnitude_ = other.maxValidMagnitude_;
      dropMagnitude_ = other.dropMagnitude_;
      dualPricePrioritizeNorm_ = other.dualPricePrioritizeNorm_;
      _unknownFields = pb::UnknownFieldSet.Clone(other._unknownFields);
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public GlopParameters Clone() {
      return new GlopParameters(this);
    }

    public const int ScalingMethodFieldNumber = 57;
    private readonly static global::Google.OrTools.Glop.GlopParameters.Types.ScalingAlgorithm ScalingMethodDefaultValue = global::Google.OrTools.Glop.GlopParameters.Types.ScalingAlgorithm.Equilibration;
 
    private global::Google.OrTools.Glop.GlopParameters.Types.ScalingAlgorithm scalingMethod_;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public global::Google.OrTools.Glop.GlopParameters.Types.ScalingAlgorithm ScalingMethod {
      get { if ((_hasBits1 & 4096) != 0) { return scalingMethod_; } else { return ScalingMethodDefaultValue; } }
      set {
        _hasBits1 |= 4096;
        scalingMethod_ = value;
      }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public bool HasScalingMethod {
      get { return (_hasBits1 & 4096) != 0; }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public void ClearScalingMethod() {
      _hasBits1 &= ~4096;
    }

    public const int FeasibilityRuleFieldNumber = 1;
    private readonly static global::Google.OrTools.Glop.GlopParameters.Types.PricingRule FeasibilityRuleDefaultValue = global::Google.OrTools.Glop.GlopParameters.Types.PricingRule.SteepestEdge;
 
    private global::Google.OrTools.Glop.GlopParameters.Types.PricingRule feasibilityRule_;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public global::Google.OrTools.Glop.GlopParameters.Types.PricingRule FeasibilityRule {
      get { if ((_hasBits0 & 1) != 0) { return feasibilityRule_; } else { return FeasibilityRuleDefaultValue; } }
      set {
        _hasBits0 |= 1;
        feasibilityRule_ = value;
      }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public bool HasFeasibilityRule {
      get { return (_hasBits0 & 1) != 0; }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public void ClearFeasibilityRule() {
      _hasBits0 &= ~1;
    }

    public const int OptimizationRuleFieldNumber = 2;
    private readonly static global::Google.OrTools.Glop.GlopParameters.Types.PricingRule OptimizationRuleDefaultValue = global::Google.OrTools.Glop.GlopParameters.Types.PricingRule.SteepestEdge;
 
    private global::Google.OrTools.Glop.GlopParameters.Types.PricingRule optimizationRule_;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public global::Google.OrTools.Glop.GlopParameters.Types.PricingRule OptimizationRule {
      get { if ((_hasBits0 & 2) != 0) { return optimizationRule_; } else { return OptimizationRuleDefaultValue; } }
      set {
        _hasBits0 |= 2;
        optimizationRule_ = value;
      }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public bool HasOptimizationRule {
      get { return (_hasBits0 & 2) != 0; }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public void ClearOptimizationRule() {
      _hasBits0 &= ~2;
    }

    public const int RefactorizationThresholdFieldNumber = 6;
    private readonly static double RefactorizationThresholdDefaultValue = 1e-09D;
 
    private double refactorizationThreshold_;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public double RefactorizationThreshold {
      get { if ((_hasBits0 & 4) != 0) { return refactorizationThreshold_; } else { return RefactorizationThresholdDefaultValue; } }
      set {
        _hasBits0 |= 4;
        refactorizationThreshold_ = value;
      }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public bool HasRefactorizationThreshold {
      get { return (_hasBits0 & 4) != 0; }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public void ClearRefactorizationThreshold() {
      _hasBits0 &= ~4;
    }

    public const int RecomputeReducedCostsThresholdFieldNumber = 8;
    private readonly static double RecomputeReducedCostsThresholdDefaultValue = 1e-08D;
 
    private double recomputeReducedCostsThreshold_;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public double RecomputeReducedCostsThreshold {
      get { if ((_hasBits0 & 8) != 0) { return recomputeReducedCostsThreshold_; } else { return RecomputeReducedCostsThresholdDefaultValue; } }
      set {
        _hasBits0 |= 8;
        recomputeReducedCostsThreshold_ = value;
      }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public bool HasRecomputeReducedCostsThreshold {
      get { return (_hasBits0 & 8) != 0; }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public void ClearRecomputeReducedCostsThreshold() {
      _hasBits0 &= ~8;
    }

    public const int RecomputeEdgesNormThresholdFieldNumber = 9;
    private readonly static double RecomputeEdgesNormThresholdDefaultValue = 100D;
 
    private double recomputeEdgesNormThreshold_;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public double RecomputeEdgesNormThreshold {
      get { if ((_hasBits0 & 16) != 0) { return recomputeEdgesNormThreshold_; } else { return RecomputeEdgesNormThresholdDefaultValue; } }
      set {
        _hasBits0 |= 16;
        recomputeEdgesNormThreshold_ = value;
      }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public bool HasRecomputeEdgesNormThreshold {
      get { return (_hasBits0 & 16) != 0; }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public void ClearRecomputeEdgesNormThreshold() {
      _hasBits0 &= ~16;
    }

    public const int PrimalFeasibilityToleranceFieldNumber = 10;
    private readonly static double PrimalFeasibilityToleranceDefaultValue = 1e-08D;
 
    private double primalFeasibilityTolerance_;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public double PrimalFeasibilityTolerance {
      get { if ((_hasBits0 & 32) != 0) { return primalFeasibilityTolerance_; } else { return PrimalFeasibilityToleranceDefaultValue; } }
      set {
        _hasBits0 |= 32;
        primalFeasibilityTolerance_ = value;
      }
    }
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public bool HasPrimalFeasibilityTolerance {
      get { return (_hasBits0 & 32) != 0; }
    }
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public void ClearPrimalFeasibilityTolerance() {
      _hasBits0 &= ~32;
    }


    public const int DualFeasibilityToleranceFieldNumber = 11;
    private readonly static double DualFeasibilityToleranceDefaultValue = 1e-08D;
 
    private double dualFeasibilityTolerance_;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public double DualFeasibilityTolerance {
      get { if ((_hasBits0 & 64) != 0) { return dualFeasibilityTolerance_; } else { return DualFeasibilityToleranceDefaultValue; } }
      set {
        _hasBits0 |= 64;
        dualFeasibilityTolerance_ = value;
      }
    }
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public bool HasDualFeasibilityTolerance {
      get { return (_hasBits0 & 64) != 0; }
    }
    /// <summary>Clears the value of the "dual_feasibility_tolerance" field</summary>
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public void ClearDualFeasibilityTolerance() {
      _hasBits0 &= ~64;
    }

    public const int RatioTestZeroThresholdFieldNumber = 12;
    private readonly static double RatioTestZeroThresholdDefaultValue = 1e-09D;
 
    private double ratioTestZeroThreshold_;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public double RatioTestZeroThreshold {
      get { if ((_hasBits0 & 128) != 0) { return ratioTestZeroThreshold_; } else { return RatioTestZeroThresholdDefaultValue; } }
      set {
        _hasBits0 |= 128;
        ratioTestZeroThreshold_ = value;
      }
    }
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public bool HasRatioTestZeroThreshold {
      get { return (_hasBits0 & 128) != 0; }
    }
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public void ClearRatioTestZeroThreshold() {
      _hasBits0 &= ~128;
    }

    /// <summary>Field number for the "harris_tolerance_ratio" field.</summary>
    public const int HarrisToleranceRatioFieldNumber = 13;
    private readonly static double HarrisToleranceRatioDefaultValue = 0.5D;
 
    private double harrisToleranceRatio_;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public double HarrisToleranceRatio {
      get { if ((_hasBits0 & 256) != 0) { return harrisToleranceRatio_; } else { return HarrisToleranceRatioDefaultValue; } }
      set {
        _hasBits0 |= 256;
        harrisToleranceRatio_ = value;
      }
    }
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public bool HasHarrisToleranceRatio {
      get { return (_hasBits0 & 256) != 0; }
    }
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public void ClearHarrisToleranceRatio() {
      _hasBits0 &= ~256;
    }

    public const int SmallPivotThresholdFieldNumber = 14;
    private readonly static double SmallPivotThresholdDefaultValue = 1e-06D;
 
    private double smallPivotThreshold_;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public double SmallPivotThreshold {
      get { if ((_hasBits0 & 512) != 0) { return smallPivotThreshold_; } else { return SmallPivotThresholdDefaultValue; } }
      set {
        _hasBits0 |= 512;
        smallPivotThreshold_ = value;
      }
    }
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public bool HasSmallPivotThreshold {
      get { return (_hasBits0 & 512) != 0; }
    }
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public void ClearSmallPivotThreshold() {
      _hasBits0 &= ~512;
    }

    public const int MinimumAcceptablePivotFieldNumber = 15;
    private readonly static double MinimumAcceptablePivotDefaultValue = 1e-06D;
 
    private double minimumAcceptablePivot_;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public double MinimumAcceptablePivot {
      get { if ((_hasBits0 & 1024) != 0) { return minimumAcceptablePivot_; } else { return MinimumAcceptablePivotDefaultValue; } }
      set {
        _hasBits0 |= 1024;
        minimumAcceptablePivot_ = value;
      }
    }
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public bool HasMinimumAcceptablePivot {
      get { return (_hasBits0 & 1024) != 0; }
    }
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public void ClearMinimumAcceptablePivot() {
      _hasBits0 &= ~1024;
    }

    public const int DropToleranceFieldNumber = 52;
    private readonly static double DropToleranceDefaultValue = 1e-14D;
 
    private double dropTolerance_;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public double DropTolerance {
      get { if ((_hasBits1 & 128) != 0) { return dropTolerance_; } else { return DropToleranceDefaultValue; } }
      set {
        _hasBits1 |= 128;
        dropTolerance_ = value;
      }
    }
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public bool HasDropTolerance {
      get { return (_hasBits1 & 128) != 0; }
    }
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public void ClearDropTolerance() {
      _hasBits1 &= ~128;
    }

    public const int UseScalingFieldNumber = 16;
    private readonly static bool UseScalingDefaultValue = true;
 
    private bool useScaling_;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public bool UseScaling {
      get { if ((_hasBits0 & 2048) != 0) { return useScaling_; } else { return UseScalingDefaultValue; } }
      set {
        _hasBits0 |= 2048;
        useScaling_ = value;
      }
    }
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public bool HasUseScaling {
      get { return (_hasBits0 & 2048) != 0; }
    }
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public void ClearUseScaling() {
      _hasBits0 &= ~2048;
    }

    public const int CostScalingFieldNumber = 60;
    private readonly static global::Google.OrTools.Glop.GlopParameters.Types.CostScalingAlgorithm CostScalingDefaultValue = global::Google.OrTools.Glop.GlopParameters.Types.CostScalingAlgorithm.ContainOneCostScaling;
 
    private global::Google.OrTools.Glop.GlopParameters.Types.CostScalingAlgorithm costScaling_;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public global::Google.OrTools.Glop.GlopParameters.Types.CostScalingAlgorithm CostScaling {
      get { if ((_hasBits1 & 32768) != 0) { return costScaling_; } else { return CostScalingDefaultValue; } }
      set {
        _hasBits1 |= 32768;
        costScaling_ = value;
      }
    }
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public bool HasCostScaling {
      get { return (_hasBits1 & 32768) != 0; }
    }
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public void ClearCostScaling() {
      _hasBits1 &= ~32768;
    }

    public const int InitialBasisFieldNumber = 17;
    private readonly static global::Google.OrTools.Glop.GlopParameters.Types.InitialBasisHeuristic InitialBasisDefaultValue = global::Google.OrTools.Glop.GlopParameters.Types.InitialBasisHeuristic.Triangular;
 
    private global::Google.OrTools.Glop.GlopParameters.Types.InitialBasisHeuristic initialBasis_;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public global::Google.OrTools.Glop.GlopParameters.Types.InitialBasisHeuristic InitialBasis {
      get { if ((_hasBits0 & 4096) != 0) { return initialBasis_; } else { return InitialBasisDefaultValue; } }
      set {
        _hasBits0 |= 4096;
        initialBasis_ = value;
      }
    }
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public bool HasInitialBasis {
      get { return (_hasBits0 & 4096) != 0; }
    }
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public void ClearInitialBasis() {
      _hasBits0 &= ~4096;
    }

    public const int UseTransposedMatrixFieldNumber = 18;
    private readonly static bool UseTransposedMatrixDefaultValue = true;
 
    private bool useTransposedMatrix_;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public bool UseTransposedMatrix {
      get { if ((_hasBits0 & 8192) != 0) { return useTransposedMatrix_; } else { return UseTransposedMatrixDefaultValue; } }
      set {
        _hasBits0 |= 8192;
        useTransposedMatrix_ = value;
      }
    }
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public bool HasUseTransposedMatrix {
      get { return (_hasBits0 & 8192) != 0; }
    }
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public void ClearUseTransposedMatrix() {
      _hasBits0 &= ~8192;
    }

    public const int BasisRefactorizationPeriodFieldNumber = 19;
    private readonly static int BasisRefactorizationPeriodDefaultValue = 64;
 
    private int basisRefactorizationPeriod_;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public int BasisRefactorizationPeriod {
      get { if ((_hasBits0 & 16384) != 0) { return basisRefactorizationPeriod_; } else { return BasisRefactorizationPeriodDefaultValue; } }
      set {
        _hasBits0 |= 16384;
        basisRefactorizationPeriod_ = value;
      }
    }
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public bool HasBasisRefactorizationPeriod {
      get { return (_hasBits0 & 16384) != 0; }
    }
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public void ClearBasisRefactorizationPeriod() {
      _hasBits0 &= ~16384;
    }

    public const int DynamicallyAdjustRefactorizationPeriodFieldNumber = 63;
    private readonly static bool DynamicallyAdjustRefactorizationPeriodDefaultValue = true;
 
    private bool dynamicallyAdjustRefactorizationPeriod_;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public bool DynamicallyAdjustRefactorizationPeriod {
      get { if ((_hasBits1 & 262144) != 0) { return dynamicallyAdjustRefactorizationPeriod_; } else { return DynamicallyAdjustRefactorizationPeriodDefaultValue; } }
      set {
        _hasBits1 |= 262144;
        dynamicallyAdjustRefactorizationPeriod_ = value;
      }
    }
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public bool HasDynamicallyAdjustRefactorizationPeriod {
      get { return (_hasBits1 & 262144) != 0; }
    }
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public void ClearDynamicallyAdjustRefactorizationPeriod() {
      _hasBits1 &= ~262144;
    }

    public const int SolveDualProblemFieldNumber = 20;
    private readonly static global::Google.OrTools.Glop.GlopParameters.Types.SolverBehavior SolveDualProblemDefaultValue = global::Google.OrTools.Glop.GlopParameters.Types.SolverBehavior.LetSolverDecide;
 
    private global::Google.OrTools.Glop.GlopParameters.Types.SolverBehavior solveDualProblem_;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public global::Google.OrTools.Glop.GlopParameters.Types.SolverBehavior SolveDualProblem {
      get { if ((_hasBits0 & 32768) != 0) { return solveDualProblem_; } else { return SolveDualProblemDefaultValue; } }
      set {
        _hasBits0 |= 32768;
        solveDualProblem_ = value;
      }
    }
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public bool HasSolveDualProblem {
      get { return (_hasBits0 & 32768) != 0; }
    }
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public void ClearSolveDualProblem() {
      _hasBits0 &= ~32768;
    }

    public const int DualizerThresholdFieldNumber = 21;
    private readonly static double DualizerThresholdDefaultValue = 1.5D;
 
    private double dualizerThreshold_;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public double DualizerThreshold {
      get { if ((_hasBits0 & 65536) != 0) { return dualizerThreshold_; } else { return DualizerThresholdDefaultValue; } }
      set {
        _hasBits0 |= 65536;
        dualizerThreshold_ = value;
      }
    }
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public bool HasDualizerThreshold {
      get { return (_hasBits0 & 65536) != 0; }
    }
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public void ClearDualizerThreshold() {
      _hasBits0 &= ~65536;
    }

    public const int SolutionFeasibilityToleranceFieldNumber = 22;
    private readonly static double SolutionFeasibilityToleranceDefaultValue = 1e-06D;
 
    private double solutionFeasibilityTolerance_;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public double SolutionFeasibilityTolerance {
      get { if ((_hasBits0 & 131072) != 0) { return solutionFeasibilityTolerance_; } else { return SolutionFeasibilityToleranceDefaultValue; } }
      set {
        _hasBits0 |= 131072;
        solutionFeasibilityTolerance_ = value;
      }
    }
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public bool HasSolutionFeasibilityTolerance {
      get { return (_hasBits0 & 131072) != 0; }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public void ClearSolutionFeasibilityTolerance() {
      _hasBits0 &= ~131072;
    }

    public const int ProvideStrongOptimalGuaranteeFieldNumber = 24;
    private readonly static bool ProvideStrongOptimalGuaranteeDefaultValue = true;
 
    private bool provideStrongOptimalGuarantee_;

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public bool ProvideStrongOptimalGuarantee {
      get { if ((_hasBits0 & 262144) != 0) { return provideStrongOptimalGuarantee_; } else { return ProvideStrongOptimalGuaranteeDefaultValue; } }
      set {
        _hasBits0 |= 262144;
        provideStrongOptimalGuarantee_ = value;
      }
    }
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public bool HasProvideStrongOptimalGuarantee {
      get { return (_hasBits0 & 262144) != 0; }
    }
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public void ClearProvideStrongOptimalGuarantee() {
      _hasBits0 &= ~262144;
    }

    public const int ChangeStatusToImpreciseFieldNumber = 58;
    private readonly static bool ChangeStatusToImpreciseDefaultValue = true;
 
    private bool changeStatusToImprecise_;

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public bool ChangeStatusToImprecise {
      get { if ((_hasBits1 & 8192) != 0) { return changeStatusToImprecise_; } else { return ChangeStatusToImpreciseDefaultValue; } }
      set {
        _hasBits1 |= 8192;
        changeStatusToImprecise_ = value;
      }
    }
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public bool HasChangeStatusToImprecise {
      get { return (_hasBits1 & 8192) != 0; }
    }
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public void ClearChangeStatusToImprecise() {
      _hasBits1 &= ~8192;
    }

    public const int MaxNumberOfReoptimizationsFieldNumber = 56;
    private readonly static double MaxNumberOfReoptimizationsDefaultValue = 40D;
 
    private double maxNumberOfReoptimizations_;

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public double MaxNumberOfReoptimizations {
      get { if ((_hasBits1 & 2048) != 0) { return maxNumberOfReoptimizations_; } else { return MaxNumberOfReoptimizationsDefaultValue; } }
      set {
        _hasBits1 |= 2048;
        maxNumberOfReoptimizations_ = value;
      }
    }
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public bool HasMaxNumberOfReoptimizations {
      get { return (_hasBits1 & 2048) != 0; }
    }
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public void ClearMaxNumberOfReoptimizations() {
      _hasBits1 &= ~2048;
    }

    public const int LuFactorizationPivotThresholdFieldNumber = 25;
    private readonly static double LuFactorizationPivotThresholdDefaultValue = 0.01D;
 
    private double luFactorizationPivotThreshold_;

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public double LuFactorizationPivotThreshold {
      get { if ((_hasBits0 & 524288) != 0) { return luFactorizationPivotThreshold_; } else { return LuFactorizationPivotThresholdDefaultValue; } }
      set {
        _hasBits0 |= 524288;
        luFactorizationPivotThreshold_ = value;
      }
    }
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public bool HasLuFactorizationPivotThreshold {
      get { return (_hasBits0 & 524288) != 0; }
    }
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public void ClearLuFactorizationPivotThreshold() {
      _hasBits0 &= ~524288;
    }

    public const int MaxTimeInSecondsFieldNumber = 26;
    private readonly static double MaxTimeInSecondsDefaultValue = double.PositiveInfinity;
 
    private double maxTimeInSeconds_;

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public double MaxTimeInSeconds {
      get { if ((_hasBits0 & 1048576) != 0) { return maxTimeInSeconds_; } else { return MaxTimeInSecondsDefaultValue; } }
      set {
        _hasBits0 |= 1048576;
        maxTimeInSeconds_ = value;
      }
    }
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public bool HasMaxTimeInSeconds {
      get { return (_hasBits0 & 1048576) != 0; }
    }
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public void ClearMaxTimeInSeconds() {
      _hasBits0 &= ~1048576;
    }

    public const int MaxDeterministicTimeFieldNumber = 45;
    private readonly static double MaxDeterministicTimeDefaultValue = double.PositiveInfinity;
 
    private double maxDeterministicTime_;

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public double MaxDeterministicTime {
      get { if ((_hasBits1 & 64) != 0) { return maxDeterministicTime_; } else { return MaxDeterministicTimeDefaultValue; } }
      set {
        _hasBits1 |= 64;
        maxDeterministicTime_ = value;
      }
    }
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public bool HasMaxDeterministicTime {
      get { return (_hasBits1 & 64) != 0; }
    }
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public void ClearMaxDeterministicTime() {
      _hasBits1 &= ~64;
    }

    public const int MaxNumberOfIterationsFieldNumber = 27;
    private readonly static long MaxNumberOfIterationsDefaultValue = -1L;
 
    private long maxNumberOfIterations_;
    /// <summary>
    /// Maximum number of simplex iterations to solve a problem.
    /// A value of -1 means no limit.
    /// </summary>
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public long MaxNumberOfIterations {
      get { if ((_hasBits0 & 2097152) != 0) { return maxNumberOfIterations_; } else { return MaxNumberOfIterationsDefaultValue; } }
      set {
        _hasBits0 |= 2097152;
        maxNumberOfIterations_ = value;
      }
    }
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public bool HasMaxNumberOfIterations {
      get { return (_hasBits0 & 2097152) != 0; }
    }
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public void ClearMaxNumberOfIterations() {
      _hasBits0 &= ~2097152;
    }

    public const int MarkowitzZlatevParameterFieldNumber = 29;
    private readonly static int MarkowitzZlatevParameterDefaultValue = 3;
 
    private int markowitzZlatevParameter_;
    /// <summary>
    /// How many columns do we look at in the Markowitz pivoting rule to find
    /// a good pivot. See markowitz.h.
    /// </summary>
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public int MarkowitzZlatevParameter {
      get { if ((_hasBits0 & 4194304) != 0) { return markowitzZlatevParameter_; } else { return MarkowitzZlatevParameterDefaultValue; } }
      set {
        _hasBits0 |= 4194304;
        markowitzZlatevParameter_ = value;
      }
    }
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public bool HasMarkowitzZlatevParameter {
      get { return (_hasBits0 & 4194304) != 0; }
    }
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public void ClearMarkowitzZlatevParameter() {
      _hasBits0 &= ~4194304;
    }

    public const int MarkowitzSingularityThresholdFieldNumber = 30;
    private readonly static double MarkowitzSingularityThresholdDefaultValue = 1e-15D;
 
    private double markowitzSingularityThreshold_;
    /// <summary>
    /// If a pivot magnitude is smaller than this during the Markowitz LU
    /// factorization, then the matrix is assumed to be singular. Note that
    /// this is an absolute threshold and is not relative to the other possible
    /// pivots on the same column (see lu_factorization_pivot_threshold).
    /// </summary>
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public double MarkowitzSingularityThreshold {
      get { if ((_hasBits0 & 8388608) != 0) { return markowitzSingularityThreshold_; } else { return MarkowitzSingularityThresholdDefaultValue; } }
      set {
        _hasBits0 |= 8388608;
        markowitzSingularityThreshold_ = value;
      }
    }
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public bool HasMarkowitzSingularityThreshold {
      get { return (_hasBits0 & 8388608) != 0; }
    }
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public void ClearMarkowitzSingularityThreshold() {
      _hasBits0 &= ~8388608;
    }

    public const int UseDualSimplexFieldNumber = 31;
    private readonly static bool UseDualSimplexDefaultValue = false;
 
    private bool useDualSimplex_;
    /// <summary>
    /// Whether or not we use the dual simplex algorithm instead of the primal.
    /// </summary>
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public bool UseDualSimplex {
      get { if ((_hasBits0 & 16777216) != 0) { return useDualSimplex_; } else { return UseDualSimplexDefaultValue; } }
      set {
        _hasBits0 |= 16777216;
        useDualSimplex_ = value;
      }
    }
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public bool HasUseDualSimplex {
      get { return (_hasBits0 & 16777216) != 0; }
    }
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public void ClearUseDualSimplex() {
      _hasBits0 &= ~16777216;
    }

    public const int AllowSimplexAlgorithmChangeFieldNumber = 32;
    private readonly static bool AllowSimplexAlgorithmChangeDefaultValue = false;
 
    private bool allowSimplexAlgorithmChange_;
    /// <summary>
    /// During incremental solve, let the solver decide if it use the primal or
    /// dual simplex algorithm depending on the current solution and on the new
    /// problem. Note that even if this is true, the value of use_dual_simplex
    /// still indicates the default algorithm that the solver will use.
    /// </summary>
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public bool AllowSimplexAlgorithmChange {
      get { if ((_hasBits0 & 33554432) != 0) { return allowSimplexAlgorithmChange_; } else { return AllowSimplexAlgorithmChangeDefaultValue; } }
      set {
        _hasBits0 |= 33554432;
        allowSimplexAlgorithmChange_ = value;
      }
    }
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public bool HasAllowSimplexAlgorithmChange {
      get { return (_hasBits0 & 33554432) != 0; }
    }
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public void ClearAllowSimplexAlgorithmChange() {
      _hasBits0 &= ~33554432;
    }

    public const int DevexWeightsResetPeriodFieldNumber = 33;
    private readonly static int DevexWeightsResetPeriodDefaultValue = 150;
 
    private int devexWeightsResetPeriod_;
    /// <summary>
    /// Devex weights will be reset to 1.0 after that number of updates.
    /// </summary>
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public int DevexWeightsResetPeriod {
      get { if ((_hasBits0 & 67108864) != 0) { return devexWeightsResetPeriod_; } else { return DevexWeightsResetPeriodDefaultValue; } }
      set {
        _hasBits0 |= 67108864;
        devexWeightsResetPeriod_ = value;
      }
    }
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public bool HasDevexWeightsResetPeriod {
      get { return (_hasBits0 & 67108864) != 0; }
    }
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public void ClearDevexWeightsResetPeriod() {
      _hasBits0 &= ~67108864;
    }

    public const int UsePreprocessingFieldNumber = 34;
    private readonly static bool UsePreprocessingDefaultValue = true;
 
    private bool usePreprocessing_;
    /// <summary>
    /// Whether or not we use advanced preprocessing techniques.
    /// </summary>
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public bool UsePreprocessing {
      get { if ((_hasBits0 & 134217728) != 0) { return usePreprocessing_; } else { return UsePreprocessingDefaultValue; } }
      set {
        _hasBits0 |= 134217728;
        usePreprocessing_ = value;
      }
    }
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public bool HasUsePreprocessing {
      get { return (_hasBits0 & 134217728) != 0; }
    }
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public void ClearUsePreprocessing() {
      _hasBits0 &= ~134217728;
    }

    public const int UseMiddleProductFormUpdateFieldNumber = 35;
    private readonly static bool UseMiddleProductFormUpdateDefaultValue = true;
 
    private bool useMiddleProductFormUpdate_;
    /// <summary>
    /// Whether or not to use the middle product form update rather than the
    /// standard eta LU update. The middle form product update should be a lot more
    /// efficient (close to the Forrest-Tomlin update, a bit slower but easier to
    /// implement). See for more details:
    /// Qi Huangfu, J. A. Julian Hall, "Novel update techniques for the revised
    /// simplex method", 28 january 2013, Technical Report ERGO-13-0001
    /// http://www.maths.ed.ac.uk/hall/HuHa12/ERGO-13-001.pdf
    /// </summary>
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public bool UseMiddleProductFormUpdate {
      get { if ((_hasBits0 & 268435456) != 0) { return useMiddleProductFormUpdate_; } else { return UseMiddleProductFormUpdateDefaultValue; } }
      set {
        _hasBits0 |= 268435456;
        useMiddleProductFormUpdate_ = value;
      }
    }
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public bool HasUseMiddleProductFormUpdate {
      get { return (_hasBits0 & 268435456) != 0; }
    }
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public void ClearUseMiddleProductFormUpdate() {
      _hasBits0 &= ~268435456;
    }

    public const int InitializeDevexWithColumnNormsFieldNumber = 36;
    private readonly static bool InitializeDevexWithColumnNormsDefaultValue = true;
 
    private bool initializeDevexWithColumnNorms_;
    /// <summary>
    /// Whether we initialize devex weights to 1.0 or to the norms of the matrix
    /// columns.
    /// </summary>
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public bool InitializeDevexWithColumnNorms {
      get { if ((_hasBits0 & 536870912) != 0) { return initializeDevexWithColumnNorms_; } else { return InitializeDevexWithColumnNormsDefaultValue; } }
      set {
        _hasBits0 |= 536870912;
        initializeDevexWithColumnNorms_ = value;
      }
    }
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public bool HasInitializeDevexWithColumnNorms {
      get { return (_hasBits0 & 536870912) != 0; }
    }
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public void ClearInitializeDevexWithColumnNorms() {
      _hasBits0 &= ~536870912;
    }

    public const int ExploitSingletonColumnInInitialBasisFieldNumber = 37;
    private readonly static bool ExploitSingletonColumnInInitialBasisDefaultValue = true;
 
    private bool exploitSingletonColumnInInitialBasis_;
    /// <summary>
    /// Whether or not we exploit the singleton columns already present in the
    /// problem when we create the initial basis.
    /// </summary>
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public bool ExploitSingletonColumnInInitialBasis {
      get { if ((_hasBits0 & 1073741824) != 0) { return exploitSingletonColumnInInitialBasis_; } else { return ExploitSingletonColumnInInitialBasisDefaultValue; } }
      set {
        _hasBits0 |= 1073741824;
        exploitSingletonColumnInInitialBasis_ = value;
      }
    }
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public bool HasExploitSingletonColumnInInitialBasis {
      get { return (_hasBits0 & 1073741824) != 0; }
    }
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public void ClearExploitSingletonColumnInInitialBasis() {
      _hasBits0 &= ~1073741824;
    }

    public const int DualSmallPivotThresholdFieldNumber = 38;
    private readonly static double DualSmallPivotThresholdDefaultValue = 0.0001D;
 
    private double dualSmallPivotThreshold_;
    /// <summary>
    /// Like small_pivot_threshold but for the dual simplex. This is needed because
    /// the dual algorithm does not interpret this value in the same way.
    /// TODO(user): Clean this up and use the same small pivot detection.
    /// </summary>
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public double DualSmallPivotThreshold {
      get { if ((_hasBits0 & -2147483648) != 0) { return dualSmallPivotThreshold_; } else { return DualSmallPivotThresholdDefaultValue; } }
      set {
        _hasBits0 |= -2147483648;
        dualSmallPivotThreshold_ = value;
      }
    }
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public bool HasDualSmallPivotThreshold {
      get { return (_hasBits0 & -2147483648) != 0; }
    }
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public void ClearDualSmallPivotThreshold() {
      _hasBits0 &= ~-2147483648;
    }

    public const int PreprocessorZeroToleranceFieldNumber = 39;
    private readonly static double PreprocessorZeroToleranceDefaultValue = 1e-09D;
 
    private double preprocessorZeroTolerance_;
    /// <summary>
    /// A floating point tolerance used by the preprocessors. This is used for
    /// things like detecting if two columns/rows are proportional or if an
    /// interval is empty.
    ///
    /// Note that the preprocessors also use solution_feasibility_tolerance() to
    /// detect if a problem is infeasible.
    /// </summary>
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public double PreprocessorZeroTolerance {
      get { if ((_hasBits1 & 1) != 0) { return preprocessorZeroTolerance_; } else { return PreprocessorZeroToleranceDefaultValue; } }
      set {
        _hasBits1 |= 1;
        preprocessorZeroTolerance_ = value;
      }
    }
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public bool HasPreprocessorZeroTolerance {
      get { return (_hasBits1 & 1) != 0; }
    }
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public void ClearPreprocessorZeroTolerance() {
      _hasBits1 &= ~1;
    }

    /// <summary>Field number for the "objective_lower_limit" field.</summary>
    public const int ObjectiveLowerLimitFieldNumber = 40;
    private readonly static double ObjectiveLowerLimitDefaultValue = double.NegativeInfinity;
 
    private double objectiveLowerLimit_;
    /// The solver will stop as soon as it has proven that the objective is smaller
    /// than objective_lower_limit or greater than objective_upper_limit. Depending
    /// on the simplex algorithm (primal or dual) and the optimization direction,
    /// note that only one bound will be used at the time.
    ///
    /// Important: The solver does not add any tolerances to these values, and as
    /// soon as the objective (as computed by the solver, so with some imprecision)
    /// crosses one of these bounds (strictly), the search will stop. It is up to
    /// the client to add any tolerance if needed.
    /// </summary>
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public double ObjectiveLowerLimit {
      get { if ((_hasBits1 & 2) != 0) { return objectiveLowerLimit_; } else { return ObjectiveLowerLimitDefaultValue; } }
      set {
        _hasBits1 |= 2;
        objectiveLowerLimit_ = value;
      }
    }
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public bool HasObjectiveLowerLimit {
      get { return (_hasBits1 & 2) != 0; }
    }
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public void ClearObjectiveLowerLimit() {
      _hasBits1 &= ~2;
    }

    public const int ObjectiveUpperLimitFieldNumber = 41;
    private readonly static double ObjectiveUpperLimitDefaultValue = double.PositiveInfinity;
 
    private double objectiveUpperLimit_;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public double ObjectiveUpperLimit {
      get { if ((_hasBits1 & 4) != 0) { return objectiveUpperLimit_; } else { return ObjectiveUpperLimitDefaultValue; } }
      set {
        _hasBits1 |= 4;
        objectiveUpperLimit_ = value;
      }
    }
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public bool HasObjectiveUpperLimit {
      get { return (_hasBits1 & 4) != 0; }
    }
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public void ClearObjectiveUpperLimit() {
      _hasBits1 &= ~4;
    }

    public const int DegenerateMinistepFactorFieldNumber = 42;
    private readonly static double DegenerateMinistepFactorDefaultValue = 0.01D;
 
    private double degenerateMinistepFactor_;
    /// step of length zero (while shifting the bound of the leaving variable).
    /// That is, the variable values are unchanged for the primal simplex or the
    /// reduced cost are unchanged for the dual simplex. However, instead of doing
    /// a step of length zero, it seems to be better on degenerate problems to do a
    /// small positive step. This is what is recommended in the EXPAND procedure
    /// described in:
    /// P. E. Gill, W. Murray, M. A. Saunders, and M. H. Wright. "A practical anti-
    /// cycling procedure for linearly constrained optimization".
    /// Mathematical Programming, 45:437\u2013474, 1989.
    ///
    /// Here, during a degenerate iteration we do a small positive step of this
    /// factor times the primal (resp. dual) tolerance. In the primal simplex, this
    /// may effectively push variable values (very slightly) further out of their
    /// bounds (resp. reduced costs for the dual simplex).
    ///
    /// Setting this to zero reverts to the more conservative approach of a zero
    /// step during degenerate iterations.
    /// </summary>
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public double DegenerateMinistepFactor {
      get { if ((_hasBits1 & 8) != 0) { return degenerateMinistepFactor_; } else { return DegenerateMinistepFactorDefaultValue; } }
      set {
        _hasBits1 |= 8;
        degenerateMinistepFactor_ = value;
      }
    }
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public bool HasDegenerateMinistepFactor {
      get { return (_hasBits1 & 8) != 0; }
    }
    /// <summary>Clears the value of the "degenerate_ministep_factor" field</summary>
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public void ClearDegenerateMinistepFactor() {
      _hasBits1 &= ~8;
    }


    public const int RandomSeedFieldNumber = 43;
    private readonly static int RandomSeedDefaultValue = 1;
 
    private int randomSeed_;

    /// Note that this may lead to a different solution, for example a different
    /// optimal basis.
    ///
    /// For some problems, the running time may vary a lot depending on small
    /// change in the solving algorithm. Running the solver with different seeds
    /// enables to have more robust benchmarks when evaluating new features.
    ///
    /// Also note that the solver is fully deterministic: two runs of the same
    /// binary, on the same machine, on the exact same data and with the same
    /// parameters will go through the exact same iterations. If they hit a time
    /// limit, they might of course yield different results because one will have
    /// advanced farther than the other.
    /// </summary>
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public int RandomSeed {
      get { if ((_hasBits1 & 16) != 0) { return randomSeed_; } else { return RandomSeedDefaultValue; } }
      set {
        _hasBits1 |= 16;
        randomSeed_ = value;
      }
    }
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public bool HasRandomSeed {
      get { return (_hasBits1 & 16) != 0; }
    }
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public void ClearRandomSeed() {
      _hasBits1 &= ~16;
    }

    public const int NumOmpThreadsFieldNumber = 44;
    private readonly static int NumOmpThreadsDefaultValue = 1;
 
    private int numOmpThreads_;
    /// <summary>
    /// Number of threads in the OMP parallel sections. If left to 1, the code will
    /// not create any OMP threads and will remain single-threaded.
    /// </summary>
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public int NumOmpThreads {
      get { if ((_hasBits1 & 32) != 0) { return numOmpThreads_; } else { return NumOmpThreadsDefaultValue; } }
      set {
        _hasBits1 |= 32;
        numOmpThreads_ = value;
      }
    }
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public bool HasNumOmpThreads {
      get { return (_hasBits1 & 32) != 0; }
    }
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public void ClearNumOmpThreads() {
      _hasBits1 &= ~32;
    }

    public const int PerturbCostsInDualSimplexFieldNumber = 53;
    private readonly static bool PerturbCostsInDualSimplexDefaultValue = false;
 
    private bool perturbCostsInDualSimplex_;
    /// <summary>
    /// When this is true, then the costs are randomly perturbed before the dual
    /// simplex is even started. This has been shown to improve the dual simplex
    /// performance. For a good reference, see Huangfu Q (2013) "High performance
    /// simplex solver", Ph.D, dissertation, University of Edinburgh.
    /// </summary>
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public bool PerturbCostsInDualSimplex {
      get { if ((_hasBits1 & 256) != 0) { return perturbCostsInDualSimplex_; } else { return PerturbCostsInDualSimplexDefaultValue; } }
      set {
        _hasBits1 |= 256;
        perturbCostsInDualSimplex_ = value;
      }
    }
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public bool HasPerturbCostsInDualSimplex {
      get { return (_hasBits1 & 256) != 0; }
    }
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public void ClearPerturbCostsInDualSimplex() {
      _hasBits1 &= ~256;
    }

    public const int UseDedicatedDualFeasibilityAlgorithmFieldNumber = 62;
    private readonly static bool UseDedicatedDualFeasibilityAlgorithmDefaultValue = true;
 
    private bool useDedicatedDualFeasibilityAlgorithm_;
    /// <summary>
    /// We have two possible dual phase I algorithms. Both work on an LP that
    /// minimize the sum of dual infeasiblities. One use dedicated code (when this
    /// param is true), the other one use exactly the same code as the dual phase
    /// II but on an auxiliary problem where the variable bounds of the original
    /// problem are changed.
    ///
    /// TODO(user): For now we have both, but ideally the non-dedicated version
    /// will win since it is a lot less code to maintain.
    /// </summary>
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public bool UseDedicatedDualFeasibilityAlgorithm {
      get { if ((_hasBits1 & 131072) != 0) { return useDedicatedDualFeasibilityAlgorithm_; } else { return UseDedicatedDualFeasibilityAlgorithmDefaultValue; } }
      set {
        _hasBits1 |= 131072;
        useDedicatedDualFeasibilityAlgorithm_ = value;
      }
    }
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public bool HasUseDedicatedDualFeasibilityAlgorithm {
      get { return (_hasBits1 & 131072) != 0; }
    }
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public void ClearUseDedicatedDualFeasibilityAlgorithm() {
      _hasBits1 &= ~131072;
    }

    public const int RelativeCostPerturbationFieldNumber = 54;
    private readonly static double RelativeCostPerturbationDefaultValue = 1e-05D;
 
    private double relativeCostPerturbation_;
    /// The magnitude of the cost perturbation is given by
    /// RandomIn(1.0, 2.0) * (
    ///     relative_cost_perturbation * cost
    ///   + relative_max_cost_perturbation * max_cost);
    /// </summary>
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public double RelativeCostPerturbation {
      get { if ((_hasBits1 & 512) != 0) { return relativeCostPerturbation_; } else { return RelativeCostPerturbationDefaultValue; } }
      set {
        _hasBits1 |= 512;
        relativeCostPerturbation_ = value;
      }
    }
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public bool HasRelativeCostPerturbation {
      get { return (_hasBits1 & 512) != 0; }
    }
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public void ClearRelativeCostPerturbation() {
      _hasBits1 &= ~512;
    }

    public const int RelativeMaxCostPerturbationFieldNumber = 55;
    private readonly static double RelativeMaxCostPerturbationDefaultValue = 1e-07D;
 
    private double relativeMaxCostPerturbation_;
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public double RelativeMaxCostPerturbation {
      get { if ((_hasBits1 & 1024) != 0) { return relativeMaxCostPerturbation_; } else { return RelativeMaxCostPerturbationDefaultValue; } }
      set {
        _hasBits1 |= 1024;
        relativeMaxCostPerturbation_ = value;
      }
    }
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public bool HasRelativeMaxCostPerturbation {
      get { return (_hasBits1 & 1024) != 0; }
    }
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public void ClearRelativeMaxCostPerturbation() {
      _hasBits1 &= ~1024;
    }

    public const int InitialConditionNumberThresholdFieldNumber = 59;
    private readonly static double InitialConditionNumberThresholdDefaultValue = 1e+50D;
 
    private double initialConditionNumberThreshold_;
    /// If our upper bound on the condition number of the initial basis (from our
    /// heurisitic or a warm start) is above this threshold, we revert to an all
    /// slack basis.
    /// </summary>
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public double InitialConditionNumberThreshold {
      get { if ((_hasBits1 & 16384) != 0) { return initialConditionNumberThreshold_; } else { return InitialConditionNumberThresholdDefaultValue; } }
      set {
        _hasBits1 |= 16384;
        initialConditionNumberThreshold_ = value;
      }
    }
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public bool HasInitialConditionNumberThreshold {
      get { return (_hasBits1 & 16384) != 0; }
    }
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public void ClearInitialConditionNumberThreshold() {
      _hasBits1 &= ~16384;
    }

    public const int LogSearchProgressFieldNumber = 61;
    private readonly static bool LogSearchProgressDefaultValue = false;
 
    private bool logSearchProgress_;
    /// If true, logs the progress of a solve to LOG(INFO). Note that the same
    /// messages can also be turned on by displaying logs at level 1 for the
    /// relevant files.
    /// </summary>
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public bool LogSearchProgress {
      get { if ((_hasBits1 & 65536) != 0) { return logSearchProgress_; } else { return LogSearchProgressDefaultValue; } }
      set {
        _hasBits1 |= 65536;
        logSearchProgress_ = value;
      }
    }
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public bool HasLogSearchProgress {
      get { return (_hasBits1 & 65536) != 0; }
    }
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public void ClearLogSearchProgress() {
      _hasBits1 &= ~65536;
    }

    public const int LogToStdoutFieldNumber = 66;
    private readonly static bool LogToStdoutDefaultValue = true;
 
    private bool logToStdout_;
    /// If true, logs will be displayed to stdout instead of using Google log info.
    /// </summary>
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public bool LogToStdout {
      get { if ((_hasBits1 & 2097152) != 0) { return logToStdout_; } else { return LogToStdoutDefaultValue; } }
      set {
        _hasBits1 |= 2097152;
        logToStdout_ = value;
      }
    }
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public bool HasLogToStdout {
      get { return (_hasBits1 & 2097152) != 0; }
    }
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public void ClearLogToStdout() {
      _hasBits1 &= ~2097152;
    }

    public const int CrossoverBoundSnappingDistanceFieldNumber = 64;
    private readonly static double CrossoverBoundSnappingDistanceDefaultValue = double.PositiveInfinity;
 
    private double crossoverBoundSnappingDistance_;
    /// If the starting basis contains FREE variable with bounds, we will move
    /// any such variable to their closer bounds if the distance is smaller than
    /// this parameter.
    ///
    /// The starting statuses can contains FREE variables with bounds, if a user
    /// set it like this externally. Also, any variable with an initial BASIC
    /// status that was not kept in the initial basis is marked as FREE before this
    /// step is applied.
    ///
    /// Note that by default a FREE variable is assumed to be zero unless a
    /// starting value was specified via SetStartingVariableValuesForNextSolve().
    ///
    /// Note that, at the end of the solve, some of these FREE variable with bounds
    /// and an interior point value might still be left in the final solution.
    /// Enable push_to_vertex to clean these up.
    /// </summary>
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public double CrossoverBoundSnappingDistance {
      get { if ((_hasBits1 & 524288) != 0) { return crossoverBoundSnappingDistance_; } else { return CrossoverBoundSnappingDistanceDefaultValue; } }
      set {
        _hasBits1 |= 524288;
        crossoverBoundSnappingDistance_ = value;
      }
    }
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public bool HasCrossoverBoundSnappingDistance {
      get { return (_hasBits1 & 524288) != 0; }
    }
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public void ClearCrossoverBoundSnappingDistance() {
      _hasBits1 &= ~524288;
    }

    public const int PushToVertexFieldNumber = 65;
    private readonly static bool PushToVertexDefaultValue = true;
 
    private bool pushToVertex_;

    /// phase to push these variables to bounds, obtaining a vertex solution. Note
    /// this situation can happen only if a starting value was specified via
    /// SetStartingVariableValuesForNextSolve().
    /// </summary>
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public bool PushToVertex {
      get { if ((_hasBits1 & 1048576) != 0) { return pushToVertex_; } else { return PushToVertexDefaultValue; } }
      set {
        _hasBits1 |= 1048576;
        pushToVertex_ = value;
      }
    }
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public bool HasPushToVertex {
      get { return (_hasBits1 & 1048576) != 0; }
    }
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public void ClearPushToVertex() {
      _hasBits1 &= ~1048576;
    }

    public const int UseImpliedFreePreprocessorFieldNumber = 67;
    private readonly static bool UseImpliedFreePreprocessorDefaultValue = true;
 
    private bool useImpliedFreePreprocessor_;

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public bool UseImpliedFreePreprocessor {
      get { if ((_hasBits1 & 4194304) != 0) { return useImpliedFreePreprocessor_; } else { return UseImpliedFreePreprocessorDefaultValue; } }
      set {
        _hasBits1 |= 4194304;
        useImpliedFreePreprocessor_ = value;
      }
    }
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public bool HasUseImpliedFreePreprocessor {
      get { return (_hasBits1 & 4194304) != 0; }
    }
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public void ClearUseImpliedFreePreprocessor() {
      _hasBits1 &= ~4194304;
    }

    public const int MaxValidMagnitudeFieldNumber = 70;
    private readonly static double MaxValidMagnitudeDefaultValue = 1e+30D;
 
    private double maxValidMagnitude_;

    /// shouldn't use super large values in an LP. With the default threshold, even
    /// evaluating large constraint with variables at their bound shouldn't cause
    /// any overflow.
    /// </summary>
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public double MaxValidMagnitude {
      get { if ((_hasBits1 & 16777216) != 0) { return maxValidMagnitude_; } else { return MaxValidMagnitudeDefaultValue; } }
      set {
        _hasBits1 |= 16777216;
        maxValidMagnitude_ = value;
      }
    }
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public bool HasMaxValidMagnitude {
      get { return (_hasBits1 & 16777216) != 0; }
    }
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public void ClearMaxValidMagnitude() {
      _hasBits1 &= ~16777216;
    }

    public const int DropMagnitudeFieldNumber = 71;
    private readonly static double DropMagnitudeDefaultValue = 1e-30D;
 
    private double dropMagnitude_;

    /// a * b == 0 iff a or b is zero and things like this.
    /// </summary>
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public double DropMagnitude {
      get { if ((_hasBits1 & 33554432) != 0) { return dropMagnitude_; } else { return DropMagnitudeDefaultValue; } }
      set {
        _hasBits1 |= 33554432;
        dropMagnitude_ = value;
      }
    }
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public bool HasDropMagnitude {
      get { return (_hasBits1 & 33554432) != 0; }
    }
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public void ClearDropMagnitude() {
      _hasBits1 &= ~33554432;
    }

    public const int DualPricePrioritizeNormFieldNumber = 69;
    private readonly static bool DualPricePrioritizeNormDefaultValue = false;
 
    private bool dualPricePrioritizeNorm_;

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public bool DualPricePrioritizeNorm {
      get { if ((_hasBits1 & 8388608) != 0) { return dualPricePrioritizeNorm_; } else { return DualPricePrioritizeNormDefaultValue; } }
      set {
        _hasBits1 |= 8388608;
        dualPricePrioritizeNorm_ = value;
      }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public bool HasDualPricePrioritizeNorm {
      get { return (_hasBits1 & 8388608) != 0; }
    }
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public void ClearDualPricePrioritizeNorm() {
      _hasBits1 &= ~8388608;
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public override bool Equals(object other) {
      return Equals(other as GlopParameters);
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public bool Equals(GlopParameters other) {
      if (ReferenceEquals(other, null)) {
        return false;
      }
      if (ReferenceEquals(other, this)) {
        return true;
      }
      if (ScalingMethod != other.ScalingMethod) return false;
      if (FeasibilityRule != other.FeasibilityRule) return false;
      if (OptimizationRule != other.OptimizationRule) return false;
      if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(RefactorizationThreshold, other.RefactorizationThreshold)) return false;
      if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(RecomputeReducedCostsThreshold, other.RecomputeReducedCostsThreshold)) return false;
      if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(RecomputeEdgesNormThreshold, other.RecomputeEdgesNormThreshold)) return false;
      if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(PrimalFeasibilityTolerance, other.PrimalFeasibilityTolerance)) return false;
      if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(DualFeasibilityTolerance, other.DualFeasibilityTolerance)) return false;
      if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(RatioTestZeroThreshold, other.RatioTestZeroThreshold)) return false;
      if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(HarrisToleranceRatio, other.HarrisToleranceRatio)) return false;
      if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(SmallPivotThreshold, other.SmallPivotThreshold)) return false;
      if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(MinimumAcceptablePivot, other.MinimumAcceptablePivot)) return false;
      if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(DropTolerance, other.DropTolerance)) return false;
      if (UseScaling != other.UseScaling) return false;
      if (CostScaling != other.CostScaling) return false;
      if (InitialBasis != other.InitialBasis) return false;
      if (UseTransposedMatrix != other.UseTransposedMatrix) return false;
      if (BasisRefactorizationPeriod != other.BasisRefactorizationPeriod) return false;
      if (DynamicallyAdjustRefactorizationPeriod != other.DynamicallyAdjustRefactorizationPeriod) return false;
      if (SolveDualProblem != other.SolveDualProblem) return false;
      if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(DualizerThreshold, other.DualizerThreshold)) return false;
      if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(SolutionFeasibilityTolerance, other.SolutionFeasibilityTolerance)) return false;
      if (ProvideStrongOptimalGuarantee != other.ProvideStrongOptimalGuarantee) return false;
      if (ChangeStatusToImprecise != other.ChangeStatusToImprecise) return false;
      if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(MaxNumberOfReoptimizations, other.MaxNumberOfReoptimizations)) return false;
      if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(LuFactorizationPivotThreshold, other.LuFactorizationPivotThreshold)) return false;
      if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(MaxTimeInSeconds, other.MaxTimeInSeconds)) return false;
      if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(MaxDeterministicTime, other.MaxDeterministicTime)) return false;
      if (MaxNumberOfIterations != other.MaxNumberOfIterations) return false;
      if (MarkowitzZlatevParameter != other.MarkowitzZlatevParameter) return false;
      if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(MarkowitzSingularityThreshold, other.MarkowitzSingularityThreshold)) return false;
      if (UseDualSimplex != other.UseDualSimplex) return false;
      if (AllowSimplexAlgorithmChange != other.AllowSimplexAlgorithmChange) return false;
      if (DevexWeightsResetPeriod != other.DevexWeightsResetPeriod) return false;
      if (UsePreprocessing != other.UsePreprocessing) return false;
      if (UseMiddleProductFormUpdate != other.UseMiddleProductFormUpdate) return false;
      if (InitializeDevexWithColumnNorms != other.InitializeDevexWithColumnNorms) return false;
      if (ExploitSingletonColumnInInitialBasis != other.ExploitSingletonColumnInInitialBasis) return false;
      if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(DualSmallPivotThreshold, other.DualSmallPivotThreshold)) return false;
      if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(PreprocessorZeroTolerance, other.PreprocessorZeroTolerance)) return false;
      if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(ObjectiveLowerLimit, other.ObjectiveLowerLimit)) return false;
      if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(ObjectiveUpperLimit, other.ObjectiveUpperLimit)) return false;
      if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(DegenerateMinistepFactor, other.DegenerateMinistepFactor)) return false;
      if (RandomSeed != other.RandomSeed) return false;
      if (NumOmpThreads != other.NumOmpThreads) return false;
      if (PerturbCostsInDualSimplex != other.PerturbCostsInDualSimplex) return false;
      if (UseDedicatedDualFeasibilityAlgorithm != other.UseDedicatedDualFeasibilityAlgorithm) return false;
      if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(RelativeCostPerturbation, other.RelativeCostPerturbation)) return false;
      if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(RelativeMaxCostPerturbation, other.RelativeMaxCostPerturbation)) return false;
      if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(InitialConditionNumberThreshold, other.InitialConditionNumberThreshold)) return false;
      if (LogSearchProgress != other.LogSearchProgress) return false;
      if (LogToStdout != other.LogToStdout) return false;
      if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(CrossoverBoundSnappingDistance, other.CrossoverBoundSnappingDistance)) return false;
      if (PushToVertex != other.PushToVertex) return false;
      if (UseImpliedFreePreprocessor != other.UseImpliedFreePreprocessor) return false;
      if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(MaxValidMagnitude, other.MaxValidMagnitude)) return false;
      if (!pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(DropMagnitude, other.DropMagnitude)) return false;
      if (DualPricePrioritizeNorm != other.DualPricePrioritizeNorm) return false;
      return Equals(_unknownFields, other._unknownFields);
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public override int GetHashCode() {
      int hash = 1;
      if (HasScalingMethod) hash ^= ScalingMethod.GetHashCode();
      if (HasFeasibilityRule) hash ^= FeasibilityRule.GetHashCode();
      if (HasOptimizationRule) hash ^= OptimizationRule.GetHashCode();
      if (HasRefactorizationThreshold) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(RefactorizationThreshold);
      if (HasRecomputeReducedCostsThreshold) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(RecomputeReducedCostsThreshold);
      if (HasRecomputeEdgesNormThreshold) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(RecomputeEdgesNormThreshold);
      if (HasPrimalFeasibilityTolerance) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(PrimalFeasibilityTolerance);
      if (HasDualFeasibilityTolerance) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(DualFeasibilityTolerance);
      if (HasRatioTestZeroThreshold) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(RatioTestZeroThreshold);
      if (HasHarrisToleranceRatio) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(HarrisToleranceRatio);
      if (HasSmallPivotThreshold) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(SmallPivotThreshold);
      if (HasMinimumAcceptablePivot) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(MinimumAcceptablePivot);
      if (HasDropTolerance) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(DropTolerance);
      if (HasUseScaling) hash ^= UseScaling.GetHashCode();
      if (HasCostScaling) hash ^= CostScaling.GetHashCode();
      if (HasInitialBasis) hash ^= InitialBasis.GetHashCode();
      if (HasUseTransposedMatrix) hash ^= UseTransposedMatrix.GetHashCode();
      if (HasBasisRefactorizationPeriod) hash ^= BasisRefactorizationPeriod.GetHashCode();
      if (HasDynamicallyAdjustRefactorizationPeriod) hash ^= DynamicallyAdjustRefactorizationPeriod.GetHashCode();
      if (HasSolveDualProblem) hash ^= SolveDualProblem.GetHashCode();
      if (HasDualizerThreshold) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(DualizerThreshold);
      if (HasSolutionFeasibilityTolerance) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(SolutionFeasibilityTolerance);
      if (HasProvideStrongOptimalGuarantee) hash ^= ProvideStrongOptimalGuarantee.GetHashCode();
      if (HasChangeStatusToImprecise) hash ^= ChangeStatusToImprecise.GetHashCode();
      if (HasMaxNumberOfReoptimizations) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(MaxNumberOfReoptimizations);
      if (HasLuFactorizationPivotThreshold) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(LuFactorizationPivotThreshold);
      if (HasMaxTimeInSeconds) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(MaxTimeInSeconds);
      if (HasMaxDeterministicTime) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(MaxDeterministicTime);
      if (HasMaxNumberOfIterations) hash ^= MaxNumberOfIterations.GetHashCode();
      if (HasMarkowitzZlatevParameter) hash ^= MarkowitzZlatevParameter.GetHashCode();
      if (HasMarkowitzSingularityThreshold) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(MarkowitzSingularityThreshold);
      if (HasUseDualSimplex) hash ^= UseDualSimplex.GetHashCode();
      if (HasAllowSimplexAlgorithmChange) hash ^= AllowSimplexAlgorithmChange.GetHashCode();
      if (HasDevexWeightsResetPeriod) hash ^= DevexWeightsResetPeriod.GetHashCode();
      if (HasUsePreprocessing) hash ^= UsePreprocessing.GetHashCode();
      if (HasUseMiddleProductFormUpdate) hash ^= UseMiddleProductFormUpdate.GetHashCode();
      if (HasInitializeDevexWithColumnNorms) hash ^= InitializeDevexWithColumnNorms.GetHashCode();
      if (HasExploitSingletonColumnInInitialBasis) hash ^= ExploitSingletonColumnInInitialBasis.GetHashCode();
      if (HasDualSmallPivotThreshold) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(DualSmallPivotThreshold);
      if (HasPreprocessorZeroTolerance) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(PreprocessorZeroTolerance);
      if (HasObjectiveLowerLimit) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(ObjectiveLowerLimit);
      if (HasObjectiveUpperLimit) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(ObjectiveUpperLimit);
      if (HasDegenerateMinistepFactor) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(DegenerateMinistepFactor);
      if (HasRandomSeed) hash ^= RandomSeed.GetHashCode();
      if (HasNumOmpThreads) hash ^= NumOmpThreads.GetHashCode();
      if (HasPerturbCostsInDualSimplex) hash ^= PerturbCostsInDualSimplex.GetHashCode();
      if (HasUseDedicatedDualFeasibilityAlgorithm) hash ^= UseDedicatedDualFeasibilityAlgorithm.GetHashCode();
      if (HasRelativeCostPerturbation) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(RelativeCostPerturbation);
      if (HasRelativeMaxCostPerturbation) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(RelativeMaxCostPerturbation);
      if (HasInitialConditionNumberThreshold) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(InitialConditionNumberThreshold);
      if (HasLogSearchProgress) hash ^= LogSearchProgress.GetHashCode();
      if (HasLogToStdout) hash ^= LogToStdout.GetHashCode();
      if (HasCrossoverBoundSnappingDistance) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(CrossoverBoundSnappingDistance);
      if (HasPushToVertex) hash ^= PushToVertex.GetHashCode();
      if (HasUseImpliedFreePreprocessor) hash ^= UseImpliedFreePreprocessor.GetHashCode();
      if (HasMaxValidMagnitude) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(MaxValidMagnitude);
      if (HasDropMagnitude) hash ^= pbc::ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(DropMagnitude);
      if (HasDualPricePrioritizeNorm) hash ^= DualPricePrioritizeNorm.GetHashCode();
      if (_unknownFields != null) {
        hash ^= _unknownFields.GetHashCode();
      }
      return hash;
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public override string ToString() {
      return pb::JsonFormatter.ToDiagnosticString(this);
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public void WriteTo(pb::CodedOutputStream output) {
    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
      output.WriteRawMessage(this);
    #else
      if (HasFeasibilityRule) {
        output.WriteRawTag(8);
        output.WriteEnum((int) FeasibilityRule);
      }
      if (HasOptimizationRule) {
        output.WriteRawTag(16);
        output.WriteEnum((int) OptimizationRule);
      }
      if (HasRefactorizationThreshold) {
        output.WriteRawTag(49);
        output.WriteDouble(RefactorizationThreshold);
      }
      if (HasRecomputeReducedCostsThreshold) {
        output.WriteRawTag(65);
        output.WriteDouble(RecomputeReducedCostsThreshold);
      }
      if (HasRecomputeEdgesNormThreshold) {
        output.WriteRawTag(73);
        output.WriteDouble(RecomputeEdgesNormThreshold);
      }
      if (HasPrimalFeasibilityTolerance) {
        output.WriteRawTag(81);
        output.WriteDouble(PrimalFeasibilityTolerance);
      }
      if (HasDualFeasibilityTolerance) {
        output.WriteRawTag(89);
        output.WriteDouble(DualFeasibilityTolerance);
      }
      if (HasRatioTestZeroThreshold) {
        output.WriteRawTag(97);
        output.WriteDouble(RatioTestZeroThreshold);
      }
      if (HasHarrisToleranceRatio) {
        output.WriteRawTag(105);
        output.WriteDouble(HarrisToleranceRatio);
      }
      if (HasSmallPivotThreshold) {
        output.WriteRawTag(113);
        output.WriteDouble(SmallPivotThreshold);
      }
      if (HasMinimumAcceptablePivot) {
        output.WriteRawTag(121);
        output.WriteDouble(MinimumAcceptablePivot);
      }
      if (HasUseScaling) {
        output.WriteRawTag(128, 1);
        output.WriteBool(UseScaling);
      }
      if (HasInitialBasis) {
        output.WriteRawTag(136, 1);
        output.WriteEnum((int) InitialBasis);
      }
      if (HasUseTransposedMatrix) {
        output.WriteRawTag(144, 1);
        output.WriteBool(UseTransposedMatrix);
      }
      if (HasBasisRefactorizationPeriod) {
        output.WriteRawTag(152, 1);
        output.WriteInt32(BasisRefactorizationPeriod);
      }
      if (HasSolveDualProblem) {
        output.WriteRawTag(160, 1);
        output.WriteEnum((int) SolveDualProblem);
      }
      if (HasDualizerThreshold) {
        output.WriteRawTag(169, 1);
        output.WriteDouble(DualizerThreshold);
      }
      if (HasSolutionFeasibilityTolerance) {
        output.WriteRawTag(177, 1);
        output.WriteDouble(SolutionFeasibilityTolerance);
      }
      if (HasProvideStrongOptimalGuarantee) {
        output.WriteRawTag(192, 1);
        output.WriteBool(ProvideStrongOptimalGuarantee);
      }
      if (HasLuFactorizationPivotThreshold) {
        output.WriteRawTag(201, 1);
        output.WriteDouble(LuFactorizationPivotThreshold);
      }
      if (HasMaxTimeInSeconds) {
        output.WriteRawTag(209, 1);
        output.WriteDouble(MaxTimeInSeconds);
      }
      if (HasMaxNumberOfIterations) {
        output.WriteRawTag(216, 1);
        output.WriteInt64(MaxNumberOfIterations);
      }
      if (HasMarkowitzZlatevParameter) {
        output.WriteRawTag(232, 1);
        output.WriteInt32(MarkowitzZlatevParameter);
      }
      if (HasMarkowitzSingularityThreshold) {
        output.WriteRawTag(241, 1);
        output.WriteDouble(MarkowitzSingularityThreshold);
      }
      if (HasUseDualSimplex) {
        output.WriteRawTag(248, 1);
        output.WriteBool(UseDualSimplex);
      }
      if (HasAllowSimplexAlgorithmChange) {
        output.WriteRawTag(128, 2);
        output.WriteBool(AllowSimplexAlgorithmChange);
      }
      if (HasDevexWeightsResetPeriod) {
        output.WriteRawTag(136, 2);
        output.WriteInt32(DevexWeightsResetPeriod);
      }
      if (HasUsePreprocessing) {
        output.WriteRawTag(144, 2);
        output.WriteBool(UsePreprocessing);
      }
      if (HasUseMiddleProductFormUpdate) {
        output.WriteRawTag(152, 2);
        output.WriteBool(UseMiddleProductFormUpdate);
      }
      if (HasInitializeDevexWithColumnNorms) {
        output.WriteRawTag(160, 2);
        output.WriteBool(InitializeDevexWithColumnNorms);
      }
      if (HasExploitSingletonColumnInInitialBasis) {
        output.WriteRawTag(168, 2);
        output.WriteBool(ExploitSingletonColumnInInitialBasis);
      }
      if (HasDualSmallPivotThreshold) {
        output.WriteRawTag(177, 2);
        output.WriteDouble(DualSmallPivotThreshold);
      }
      if (HasPreprocessorZeroTolerance) {
        output.WriteRawTag(185, 2);
        output.WriteDouble(PreprocessorZeroTolerance);
      }
      if (HasObjectiveLowerLimit) {
        output.WriteRawTag(193, 2);
        output.WriteDouble(ObjectiveLowerLimit);
      }
      if (HasObjectiveUpperLimit) {
        output.WriteRawTag(201, 2);
        output.WriteDouble(ObjectiveUpperLimit);
      }
      if (HasDegenerateMinistepFactor) {
        output.WriteRawTag(209, 2);
        output.WriteDouble(DegenerateMinistepFactor);
      }
      if (HasRandomSeed) {
        output.WriteRawTag(216, 2);
        output.WriteInt32(RandomSeed);
      }
      if (HasNumOmpThreads) {
        output.WriteRawTag(224, 2);
        output.WriteInt32(NumOmpThreads);
      }
      if (HasMaxDeterministicTime) {
        output.WriteRawTag(233, 2);
        output.WriteDouble(MaxDeterministicTime);
      }
      if (HasDropTolerance) {
        output.WriteRawTag(161, 3);
        output.WriteDouble(DropTolerance);
      }
      if (HasPerturbCostsInDualSimplex) {
        output.WriteRawTag(168, 3);
        output.WriteBool(PerturbCostsInDualSimplex);
      }
      if (HasRelativeCostPerturbation) {
        output.WriteRawTag(177, 3);
        output.WriteDouble(RelativeCostPerturbation);
      }
      if (HasRelativeMaxCostPerturbation) {
        output.WriteRawTag(185, 3);
        output.WriteDouble(RelativeMaxCostPerturbation);
      }
      if (HasMaxNumberOfReoptimizations) {
        output.WriteRawTag(193, 3);
        output.WriteDouble(MaxNumberOfReoptimizations);
      }
      if (HasScalingMethod) {
        output.WriteRawTag(200, 3);
        output.WriteEnum((int) ScalingMethod);
      }
      if (HasChangeStatusToImprecise) {
        output.WriteRawTag(208, 3);
        output.WriteBool(ChangeStatusToImprecise);
      }
      if (HasInitialConditionNumberThreshold) {
        output.WriteRawTag(217, 3);
        output.WriteDouble(InitialConditionNumberThreshold);
      }
      if (HasCostScaling) {
        output.WriteRawTag(224, 3);
        output.WriteEnum((int) CostScaling);
      }
      if (HasLogSearchProgress) {
        output.WriteRawTag(232, 3);
        output.WriteBool(LogSearchProgress);
      }
      if (HasUseDedicatedDualFeasibilityAlgorithm) {
        output.WriteRawTag(240, 3);
        output.WriteBool(UseDedicatedDualFeasibilityAlgorithm);
      }
      if (HasDynamicallyAdjustRefactorizationPeriod) {
        output.WriteRawTag(248, 3);
        output.WriteBool(DynamicallyAdjustRefactorizationPeriod);
      }
      if (HasCrossoverBoundSnappingDistance) {
        output.WriteRawTag(129, 4);
        output.WriteDouble(CrossoverBoundSnappingDistance);
      }
      if (HasPushToVertex) {
        output.WriteRawTag(136, 4);
        output.WriteBool(PushToVertex);
      }
      if (HasLogToStdout) {
        output.WriteRawTag(144, 4);
        output.WriteBool(LogToStdout);
      }
      if (HasUseImpliedFreePreprocessor) {
        output.WriteRawTag(152, 4);
        output.WriteBool(UseImpliedFreePreprocessor);
      }
      if (HasDualPricePrioritizeNorm) {
        output.WriteRawTag(168, 4);
        output.WriteBool(DualPricePrioritizeNorm);
      }
      if (HasMaxValidMagnitude) {
        output.WriteRawTag(177, 4);
        output.WriteDouble(MaxValidMagnitude);
      }
      if (HasDropMagnitude) {
        output.WriteRawTag(185, 4);
        output.WriteDouble(DropMagnitude);
      }
      if (_unknownFields != null) {
        _unknownFields.WriteTo(output);
      }
    #endif
    }
 
    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    void pb::IBufferMessage.InternalWriteTo(ref pb::WriteContext output) {
      if (HasFeasibilityRule) {
        output.WriteRawTag(8);
        output.WriteEnum((int) FeasibilityRule);
      }
      if (HasOptimizationRule) {
        output.WriteRawTag(16);
        output.WriteEnum((int) OptimizationRule);
      }
      if (HasRefactorizationThreshold) {
        output.WriteRawTag(49);
        output.WriteDouble(RefactorizationThreshold);
      }
      if (HasRecomputeReducedCostsThreshold) {
        output.WriteRawTag(65);
        output.WriteDouble(RecomputeReducedCostsThreshold);
      }
      if (HasRecomputeEdgesNormThreshold) {
        output.WriteRawTag(73);
        output.WriteDouble(RecomputeEdgesNormThreshold);
      }
      if (HasPrimalFeasibilityTolerance) {
        output.WriteRawTag(81);
        output.WriteDouble(PrimalFeasibilityTolerance);
      }
      if (HasDualFeasibilityTolerance) {
        output.WriteRawTag(89);
        output.WriteDouble(DualFeasibilityTolerance);
      }
      if (HasRatioTestZeroThreshold) {
        output.WriteRawTag(97);
        output.WriteDouble(RatioTestZeroThreshold);
      }
      if (HasHarrisToleranceRatio) {
        output.WriteRawTag(105);
        output.WriteDouble(HarrisToleranceRatio);
      }
      if (HasSmallPivotThreshold) {
        output.WriteRawTag(113);
        output.WriteDouble(SmallPivotThreshold);
      }
      if (HasMinimumAcceptablePivot) {
        output.WriteRawTag(121);
        output.WriteDouble(MinimumAcceptablePivot);
      }
      if (HasUseScaling) {
        output.WriteRawTag(128, 1);
        output.WriteBool(UseScaling);
      }
      if (HasInitialBasis) {
        output.WriteRawTag(136, 1);
        output.WriteEnum((int) InitialBasis);
      }
      if (HasUseTransposedMatrix) {
        output.WriteRawTag(144, 1);
        output.WriteBool(UseTransposedMatrix);
      }
      if (HasBasisRefactorizationPeriod) {
        output.WriteRawTag(152, 1);
        output.WriteInt32(BasisRefactorizationPeriod);
      }
      if (HasSolveDualProblem) {
        output.WriteRawTag(160, 1);
        output.WriteEnum((int) SolveDualProblem);
      }
      if (HasDualizerThreshold) {
        output.WriteRawTag(169, 1);
        output.WriteDouble(DualizerThreshold);
      }
      if (HasSolutionFeasibilityTolerance) {
        output.WriteRawTag(177, 1);
        output.WriteDouble(SolutionFeasibilityTolerance);
      }
      if (HasProvideStrongOptimalGuarantee) {
        output.WriteRawTag(192, 1);
        output.WriteBool(ProvideStrongOptimalGuarantee);
      }
      if (HasLuFactorizationPivotThreshold) {
        output.WriteRawTag(201, 1);
        output.WriteDouble(LuFactorizationPivotThreshold);
      }
      if (HasMaxTimeInSeconds) {
        output.WriteRawTag(209, 1);
        output.WriteDouble(MaxTimeInSeconds);
      }
      if (HasMaxNumberOfIterations) {
        output.WriteRawTag(216, 1);
        output.WriteInt64(MaxNumberOfIterations);
      }
      if (HasMarkowitzZlatevParameter) {
        output.WriteRawTag(232, 1);
        output.WriteInt32(MarkowitzZlatevParameter);
      }
      if (HasMarkowitzSingularityThreshold) {
        output.WriteRawTag(241, 1);
        output.WriteDouble(MarkowitzSingularityThreshold);
      }
      if (HasUseDualSimplex) {
        output.WriteRawTag(248, 1);
        output.WriteBool(UseDualSimplex);
      }
      if (HasAllowSimplexAlgorithmChange) {
        output.WriteRawTag(128, 2);
        output.WriteBool(AllowSimplexAlgorithmChange);
      }
      if (HasDevexWeightsResetPeriod) {
        output.WriteRawTag(136, 2);
        output.WriteInt32(DevexWeightsResetPeriod);
      }
      if (HasUsePreprocessing) {
        output.WriteRawTag(144, 2);
        output.WriteBool(UsePreprocessing);
      }
      if (HasUseMiddleProductFormUpdate) {
        output.WriteRawTag(152, 2);
        output.WriteBool(UseMiddleProductFormUpdate);
      }
      if (HasInitializeDevexWithColumnNorms) {
        output.WriteRawTag(160, 2);
        output.WriteBool(InitializeDevexWithColumnNorms);
      }
      if (HasExploitSingletonColumnInInitialBasis) {
        output.WriteRawTag(168, 2);
        output.WriteBool(ExploitSingletonColumnInInitialBasis);
      }
      if (HasDualSmallPivotThreshold) {
        output.WriteRawTag(177, 2);
        output.WriteDouble(DualSmallPivotThreshold);
      }
      if (HasPreprocessorZeroTolerance) {
        output.WriteRawTag(185, 2);
        output.WriteDouble(PreprocessorZeroTolerance);
      }
      if (HasObjectiveLowerLimit) {
        output.WriteRawTag(193, 2);
        output.WriteDouble(ObjectiveLowerLimit);
      }
      if (HasObjectiveUpperLimit) {
        output.WriteRawTag(201, 2);
        output.WriteDouble(ObjectiveUpperLimit);
      }
      if (HasDegenerateMinistepFactor) {
        output.WriteRawTag(209, 2);
        output.WriteDouble(DegenerateMinistepFactor);
      }
      if (HasRandomSeed) {
        output.WriteRawTag(216, 2);
        output.WriteInt32(RandomSeed);
      }
      if (HasNumOmpThreads) {
        output.WriteRawTag(224, 2);
        output.WriteInt32(NumOmpThreads);
      }
      if (HasMaxDeterministicTime) {
        output.WriteRawTag(233, 2);
        output.WriteDouble(MaxDeterministicTime);
      }
      if (HasDropTolerance) {
        output.WriteRawTag(161, 3);
        output.WriteDouble(DropTolerance);
      }
      if (HasPerturbCostsInDualSimplex) {
        output.WriteRawTag(168, 3);
        output.WriteBool(PerturbCostsInDualSimplex);
      }
      if (HasRelativeCostPerturbation) {
        output.WriteRawTag(177, 3);
        output.WriteDouble(RelativeCostPerturbation);
      }
      if (HasRelativeMaxCostPerturbation) {
        output.WriteRawTag(185, 3);
        output.WriteDouble(RelativeMaxCostPerturbation);
      }
      if (HasMaxNumberOfReoptimizations) {
        output.WriteRawTag(193, 3);
        output.WriteDouble(MaxNumberOfReoptimizations);
      }
      if (HasScalingMethod) {
        output.WriteRawTag(200, 3);
        output.WriteEnum((int) ScalingMethod);
      }
      if (HasChangeStatusToImprecise) {
        output.WriteRawTag(208, 3);
        output.WriteBool(ChangeStatusToImprecise);
      }
      if (HasInitialConditionNumberThreshold) {
        output.WriteRawTag(217, 3);
        output.WriteDouble(InitialConditionNumberThreshold);
      }
      if (HasCostScaling) {
        output.WriteRawTag(224, 3);
        output.WriteEnum((int) CostScaling);
      }
      if (HasLogSearchProgress) {
        output.WriteRawTag(232, 3);
        output.WriteBool(LogSearchProgress);
      }
      if (HasUseDedicatedDualFeasibilityAlgorithm) {
        output.WriteRawTag(240, 3);
        output.WriteBool(UseDedicatedDualFeasibilityAlgorithm);
      }
      if (HasDynamicallyAdjustRefactorizationPeriod) {
        output.WriteRawTag(248, 3);
        output.WriteBool(DynamicallyAdjustRefactorizationPeriod);
      }
      if (HasCrossoverBoundSnappingDistance) {
        output.WriteRawTag(129, 4);
        output.WriteDouble(CrossoverBoundSnappingDistance);
      }
      if (HasPushToVertex) {
        output.WriteRawTag(136, 4);
        output.WriteBool(PushToVertex);
      }
      if (HasLogToStdout) {
        output.WriteRawTag(144, 4);
        output.WriteBool(LogToStdout);
      }
      if (HasUseImpliedFreePreprocessor) {
        output.WriteRawTag(152, 4);
        output.WriteBool(UseImpliedFreePreprocessor);
      }
      if (HasDualPricePrioritizeNorm) {
        output.WriteRawTag(168, 4);
        output.WriteBool(DualPricePrioritizeNorm);
      }
      if (HasMaxValidMagnitude) {
        output.WriteRawTag(177, 4);
        output.WriteDouble(MaxValidMagnitude);
      }
      if (HasDropMagnitude) {
        output.WriteRawTag(185, 4);
        output.WriteDouble(DropMagnitude);
      }
      if (_unknownFields != null) {
        _unknownFields.WriteTo(ref output);
      }
    }
    #endif
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public int CalculateSize() {
      int size = 0;
      if (HasScalingMethod) {
        size += 2 + pb::CodedOutputStream.ComputeEnumSize((int) ScalingMethod);
      }
      if (HasFeasibilityRule) {
        size += 1 + pb::CodedOutputStream.ComputeEnumSize((int) FeasibilityRule);
      }
      if (HasOptimizationRule) {
        size += 1 + pb::CodedOutputStream.ComputeEnumSize((int) OptimizationRule);
      }
      if (HasRefactorizationThreshold) {
        size += 1 + 8;
      }
      if (HasRecomputeReducedCostsThreshold) {
        size += 1 + 8;
      }
      if (HasRecomputeEdgesNormThreshold) {
        size += 1 + 8;
      }
      if (HasPrimalFeasibilityTolerance) {
        size += 1 + 8;
      }
      if (HasDualFeasibilityTolerance) {
        size += 1 + 8;
      }
      if (HasRatioTestZeroThreshold) {
        size += 1 + 8;
      }
      if (HasHarrisToleranceRatio) {
        size += 1 + 8;
      }
      if (HasSmallPivotThreshold) {
        size += 1 + 8;
      }
      if (HasMinimumAcceptablePivot) {
        size += 1 + 8;
      }
      if (HasDropTolerance) {
        size += 2 + 8;
      }
      if (HasUseScaling) {
        size += 2 + 1;
      }
      if (HasCostScaling) {
        size += 2 + pb::CodedOutputStream.ComputeEnumSize((int) CostScaling);
      }
      if (HasInitialBasis) {
        size += 2 + pb::CodedOutputStream.ComputeEnumSize((int) InitialBasis);
      }
      if (HasUseTransposedMatrix) {
        size += 2 + 1;
      }
      if (HasBasisRefactorizationPeriod) {
        size += 2 + pb::CodedOutputStream.ComputeInt32Size(BasisRefactorizationPeriod);
      }
      if (HasDynamicallyAdjustRefactorizationPeriod) {
        size += 2 + 1;
      }
      if (HasSolveDualProblem) {
        size += 2 + pb::CodedOutputStream.ComputeEnumSize((int) SolveDualProblem);
      }
      if (HasDualizerThreshold) {
        size += 2 + 8;
      }
      if (HasSolutionFeasibilityTolerance) {
        size += 2 + 8;
      }
      if (HasProvideStrongOptimalGuarantee) {
        size += 2 + 1;
      }
      if (HasChangeStatusToImprecise) {
        size += 2 + 1;
      }
      if (HasMaxNumberOfReoptimizations) {
        size += 2 + 8;
      }
      if (HasLuFactorizationPivotThreshold) {
        size += 2 + 8;
      }
      if (HasMaxTimeInSeconds) {
        size += 2 + 8;
      }
      if (HasMaxDeterministicTime) {
        size += 2 + 8;
      }
      if (HasMaxNumberOfIterations) {
        size += 2 + pb::CodedOutputStream.ComputeInt64Size(MaxNumberOfIterations);
      }
      if (HasMarkowitzZlatevParameter) {
        size += 2 + pb::CodedOutputStream.ComputeInt32Size(MarkowitzZlatevParameter);
      }
      if (HasMarkowitzSingularityThreshold) {
        size += 2 + 8;
      }
      if (HasUseDualSimplex) {
        size += 2 + 1;
      }
      if (HasAllowSimplexAlgorithmChange) {
        size += 2 + 1;
      }
      if (HasDevexWeightsResetPeriod) {
        size += 2 + pb::CodedOutputStream.ComputeInt32Size(DevexWeightsResetPeriod);
      }
      if (HasUsePreprocessing) {
        size += 2 + 1;
      }
      if (HasUseMiddleProductFormUpdate) {
        size += 2 + 1;
      }
      if (HasInitializeDevexWithColumnNorms) {
        size += 2 + 1;
      }
      if (HasExploitSingletonColumnInInitialBasis) {
        size += 2 + 1;
      }
      if (HasDualSmallPivotThreshold) {
        size += 2 + 8;
      }
      if (HasPreprocessorZeroTolerance) {
        size += 2 + 8;
      }
      if (HasObjectiveLowerLimit) {
        size += 2 + 8;
      }
      if (HasObjectiveUpperLimit) {
        size += 2 + 8;
      }
      if (HasDegenerateMinistepFactor) {
        size += 2 + 8;
      }
      if (HasRandomSeed) {
        size += 2 + pb::CodedOutputStream.ComputeInt32Size(RandomSeed);
      }
      if (HasNumOmpThreads) {
        size += 2 + pb::CodedOutputStream.ComputeInt32Size(NumOmpThreads);
      }
      if (HasPerturbCostsInDualSimplex) {
        size += 2 + 1;
      }
      if (HasUseDedicatedDualFeasibilityAlgorithm) {
        size += 2 + 1;
      }
      if (HasRelativeCostPerturbation) {
        size += 2 + 8;
      }
      if (HasRelativeMaxCostPerturbation) {
        size += 2 + 8;
      }
      if (HasInitialConditionNumberThreshold) {
        size += 2 + 8;
      }
      if (HasLogSearchProgress) {
        size += 2 + 1;
      }
      if (HasLogToStdout) {
        size += 2 + 1;
      }
      if (HasCrossoverBoundSnappingDistance) {
        size += 2 + 8;
      }
      if (HasPushToVertex) {
        size += 2 + 1;
      }
      if (HasUseImpliedFreePreprocessor) {
        size += 2 + 1;
      }
      if (HasMaxValidMagnitude) {
        size += 2 + 8;
      }
      if (HasDropMagnitude) {
        size += 2 + 8;
      }
      if (HasDualPricePrioritizeNorm) {
        size += 2 + 1;
      }
      if (_unknownFields != null) {
        size += _unknownFields.CalculateSize();
      }
      return size;
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public void MergeFrom(GlopParameters other) {
      if (other == null) {
        return;
      }
      if (other.HasScalingMethod) {
        ScalingMethod = other.ScalingMethod;
      }
      if (other.HasFeasibilityRule) {
        FeasibilityRule = other.FeasibilityRule;
      }
      if (other.HasOptimizationRule) {
        OptimizationRule = other.OptimizationRule;
      }
      if (other.HasRefactorizationThreshold) {
        RefactorizationThreshold = other.RefactorizationThreshold;
      }
      if (other.HasRecomputeReducedCostsThreshold) {
        RecomputeReducedCostsThreshold = other.RecomputeReducedCostsThreshold;
      }
      if (other.HasRecomputeEdgesNormThreshold) {
        RecomputeEdgesNormThreshold = other.RecomputeEdgesNormThreshold;
      }
      if (other.HasPrimalFeasibilityTolerance) {
        PrimalFeasibilityTolerance = other.PrimalFeasibilityTolerance;
      }
      if (other.HasDualFeasibilityTolerance) {
        DualFeasibilityTolerance = other.DualFeasibilityTolerance;
      }
      if (other.HasRatioTestZeroThreshold) {
        RatioTestZeroThreshold = other.RatioTestZeroThreshold;
      }
      if (other.HasHarrisToleranceRatio) {
        HarrisToleranceRatio = other.HarrisToleranceRatio;
      }
      if (other.HasSmallPivotThreshold) {
        SmallPivotThreshold = other.SmallPivotThreshold;
      }
      if (other.HasMinimumAcceptablePivot) {
        MinimumAcceptablePivot = other.MinimumAcceptablePivot;
      }
      if (other.HasDropTolerance) {
        DropTolerance = other.DropTolerance;
      }
      if (other.HasUseScaling) {
        UseScaling = other.UseScaling;
      }
      if (other.HasCostScaling) {
        CostScaling = other.CostScaling;
      }
      if (other.HasInitialBasis) {
        InitialBasis = other.InitialBasis;
      }
      if (other.HasUseTransposedMatrix) {
        UseTransposedMatrix = other.UseTransposedMatrix;
      }
      if (other.HasBasisRefactorizationPeriod) {
        BasisRefactorizationPeriod = other.BasisRefactorizationPeriod;
      }
      if (other.HasDynamicallyAdjustRefactorizationPeriod) {
        DynamicallyAdjustRefactorizationPeriod = other.DynamicallyAdjustRefactorizationPeriod;
      }
      if (other.HasSolveDualProblem) {
        SolveDualProblem = other.SolveDualProblem;
      }
      if (other.HasDualizerThreshold) {
        DualizerThreshold = other.DualizerThreshold;
      }
      if (other.HasSolutionFeasibilityTolerance) {
        SolutionFeasibilityTolerance = other.SolutionFeasibilityTolerance;
      }
      if (other.HasProvideStrongOptimalGuarantee) {
        ProvideStrongOptimalGuarantee = other.ProvideStrongOptimalGuarantee;
      }
      if (other.HasChangeStatusToImprecise) {
        ChangeStatusToImprecise = other.ChangeStatusToImprecise;
      }
      if (other.HasMaxNumberOfReoptimizations) {
        MaxNumberOfReoptimizations = other.MaxNumberOfReoptimizations;
      }
      if (other.HasLuFactorizationPivotThreshold) {
        LuFactorizationPivotThreshold = other.LuFactorizationPivotThreshold;
      }
      if (other.HasMaxTimeInSeconds) {
        MaxTimeInSeconds = other.MaxTimeInSeconds;
      }
      if (other.HasMaxDeterministicTime) {
        MaxDeterministicTime = other.MaxDeterministicTime;
      }
      if (other.HasMaxNumberOfIterations) {
        MaxNumberOfIterations = other.MaxNumberOfIterations;
      }
      if (other.HasMarkowitzZlatevParameter) {
        MarkowitzZlatevParameter = other.MarkowitzZlatevParameter;
      }
      if (other.HasMarkowitzSingularityThreshold) {
        MarkowitzSingularityThreshold = other.MarkowitzSingularityThreshold;
      }
      if (other.HasUseDualSimplex) {
        UseDualSimplex = other.UseDualSimplex;
      }
      if (other.HasAllowSimplexAlgorithmChange) {
        AllowSimplexAlgorithmChange = other.AllowSimplexAlgorithmChange;
      }
      if (other.HasDevexWeightsResetPeriod) {
        DevexWeightsResetPeriod = other.DevexWeightsResetPeriod;
      }
      if (other.HasUsePreprocessing) {
        UsePreprocessing = other.UsePreprocessing;
      }
      if (other.HasUseMiddleProductFormUpdate) {
        UseMiddleProductFormUpdate = other.UseMiddleProductFormUpdate;
      }
      if (other.HasInitializeDevexWithColumnNorms) {
        InitializeDevexWithColumnNorms = other.InitializeDevexWithColumnNorms;
      }
      if (other.HasExploitSingletonColumnInInitialBasis) {
        ExploitSingletonColumnInInitialBasis = other.ExploitSingletonColumnInInitialBasis;
      }
      if (other.HasDualSmallPivotThreshold) {
        DualSmallPivotThreshold = other.DualSmallPivotThreshold;
      }
      if (other.HasPreprocessorZeroTolerance) {
        PreprocessorZeroTolerance = other.PreprocessorZeroTolerance;
      }
      if (other.HasObjectiveLowerLimit) {
        ObjectiveLowerLimit = other.ObjectiveLowerLimit;
      }
      if (other.HasObjectiveUpperLimit) {
        ObjectiveUpperLimit = other.ObjectiveUpperLimit;
      }
      if (other.HasDegenerateMinistepFactor) {
        DegenerateMinistepFactor = other.DegenerateMinistepFactor;
      }
      if (other.HasRandomSeed) {
        RandomSeed = other.RandomSeed;
      }
      if (other.HasNumOmpThreads) {
        NumOmpThreads = other.NumOmpThreads;
      }
      if (other.HasPerturbCostsInDualSimplex) {
        PerturbCostsInDualSimplex = other.PerturbCostsInDualSimplex;
      }
      if (other.HasUseDedicatedDualFeasibilityAlgorithm) {
        UseDedicatedDualFeasibilityAlgorithm = other.UseDedicatedDualFeasibilityAlgorithm;
      }
      if (other.HasRelativeCostPerturbation) {
        RelativeCostPerturbation = other.RelativeCostPerturbation;
      }
      if (other.HasRelativeMaxCostPerturbation) {
        RelativeMaxCostPerturbation = other.RelativeMaxCostPerturbation;
      }
      if (other.HasInitialConditionNumberThreshold) {
        InitialConditionNumberThreshold = other.InitialConditionNumberThreshold;
      }
      if (other.HasLogSearchProgress) {
        LogSearchProgress = other.LogSearchProgress;
      }
      if (other.HasLogToStdout) {
        LogToStdout = other.LogToStdout;
      }
      if (other.HasCrossoverBoundSnappingDistance) {
        CrossoverBoundSnappingDistance = other.CrossoverBoundSnappingDistance;
      }
      if (other.HasPushToVertex) {
        PushToVertex = other.PushToVertex;
      }
      if (other.HasUseImpliedFreePreprocessor) {
        UseImpliedFreePreprocessor = other.UseImpliedFreePreprocessor;
      }
      if (other.HasMaxValidMagnitude) {
        MaxValidMagnitude = other.MaxValidMagnitude;
      }
      if (other.HasDropMagnitude) {
        DropMagnitude = other.DropMagnitude;
      }
      if (other.HasDualPricePrioritizeNorm) {
        DualPricePrioritizeNorm = other.DualPricePrioritizeNorm;
      }
      _unknownFields = pb::UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
    }
 
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public void MergeFrom(pb::CodedInputStream input) {
    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
      input.ReadRawMessage(this);
    #else
      uint tag;
      while ((tag = input.ReadTag()) != 0) {
      if ((tag & 7) == 4) {
        // Abort on any end group tag.
        return;
      }
      switch(tag) {
          default:
            _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
            break;
          case 8: {
            FeasibilityRule = (global::Google.OrTools.Glop.GlopParameters.Types.PricingRule) input.ReadEnum();
            break;
          }
          case 16: {
            OptimizationRule = (global::Google.OrTools.Glop.GlopParameters.Types.PricingRule) input.ReadEnum();
            break;
          }
          case 49: {
            RefactorizationThreshold = input.ReadDouble();
            break;
          }
          case 65: {
            RecomputeReducedCostsThreshold = input.ReadDouble();
            break;
          }
          case 73: {
            RecomputeEdgesNormThreshold = input.ReadDouble();
            break;
          }
          case 81: {
            PrimalFeasibilityTolerance = input.ReadDouble();
            break;
          }
          case 89: {
            DualFeasibilityTolerance = input.ReadDouble();
            break;
          }
          case 97: {
            RatioTestZeroThreshold = input.ReadDouble();
            break;
          }
          case 105: {
            HarrisToleranceRatio = input.ReadDouble();
            break;
          }
          case 113: {
            SmallPivotThreshold = input.ReadDouble();
            break;
          }
          case 121: {
            MinimumAcceptablePivot = input.ReadDouble();
            break;
          }
          case 128: {
            UseScaling = input.ReadBool();
            break;
          }
          case 136: {
            InitialBasis = (global::Google.OrTools.Glop.GlopParameters.Types.InitialBasisHeuristic) input.ReadEnum();
            break;
          }
          case 144: {
            UseTransposedMatrix = input.ReadBool();
            break;
          }
          case 152: {
            BasisRefactorizationPeriod = input.ReadInt32();
            break;
          }
          case 160: {
            SolveDualProblem = (global::Google.OrTools.Glop.GlopParameters.Types.SolverBehavior) input.ReadEnum();
            break;
          }
          case 169: {
            DualizerThreshold = input.ReadDouble();
            break;
          }
          case 177: {
            SolutionFeasibilityTolerance = input.ReadDouble();
            break;
          }
          case 192: {
            ProvideStrongOptimalGuarantee = input.ReadBool();
            break;
          }
          case 201: {
            LuFactorizationPivotThreshold = input.ReadDouble();
            break;
          }
          case 209: {
            MaxTimeInSeconds = input.ReadDouble();
            break;
          }
          case 216: {
            MaxNumberOfIterations = input.ReadInt64();
            break;
          }
          case 232: {
            MarkowitzZlatevParameter = input.ReadInt32();
            break;
          }
          case 241: {
            MarkowitzSingularityThreshold = input.ReadDouble();
            break;
          }
          case 248: {
            UseDualSimplex = input.ReadBool();
            break;
          }
          case 256: {
            AllowSimplexAlgorithmChange = input.ReadBool();
            break;
          }
          case 264: {
            DevexWeightsResetPeriod = input.ReadInt32();
            break;
          }
          case 272: {
            UsePreprocessing = input.ReadBool();
            break;
          }
          case 280: {
            UseMiddleProductFormUpdate = input.ReadBool();
            break;
          }
          case 288: {
            InitializeDevexWithColumnNorms = input.ReadBool();
            break;
          }
          case 296: {
            ExploitSingletonColumnInInitialBasis = input.ReadBool();
            break;
          }
          case 305: {
            DualSmallPivotThreshold = input.ReadDouble();
            break;
          }
          case 313: {
            PreprocessorZeroTolerance = input.ReadDouble();
            break;
          }
          case 321: {
            ObjectiveLowerLimit = input.ReadDouble();
            break;
          }
          case 329: {
            ObjectiveUpperLimit = input.ReadDouble();
            break;
          }
          case 337: {
            DegenerateMinistepFactor = input.ReadDouble();
            break;
          }
          case 344: {
            RandomSeed = input.ReadInt32();
            break;
          }
          case 352: {
            NumOmpThreads = input.ReadInt32();
            break;
          }
          case 361: {
            MaxDeterministicTime = input.ReadDouble();
            break;
          }
          case 417: {
            DropTolerance = input.ReadDouble();
            break;
          }
          case 424: {
            PerturbCostsInDualSimplex = input.ReadBool();
            break;
          }
          case 433: {
            RelativeCostPerturbation = input.ReadDouble();
            break;
          }
          case 441: {
            RelativeMaxCostPerturbation = input.ReadDouble();
            break;
          }
          case 449: {
            MaxNumberOfReoptimizations = input.ReadDouble();
            break;
          }
          case 456: {
            ScalingMethod = (global::Google.OrTools.Glop.GlopParameters.Types.ScalingAlgorithm) input.ReadEnum();
            break;
          }
          case 464: {
            ChangeStatusToImprecise = input.ReadBool();
            break;
          }
          case 473: {
            InitialConditionNumberThreshold = input.ReadDouble();
            break;
          }
          case 480: {
            CostScaling = (global::Google.OrTools.Glop.GlopParameters.Types.CostScalingAlgorithm) input.ReadEnum();
            break;
          }
          case 488: {
            LogSearchProgress = input.ReadBool();
            break;
          }
          case 496: {
            UseDedicatedDualFeasibilityAlgorithm = input.ReadBool();
            break;
          }
          case 504: {
            DynamicallyAdjustRefactorizationPeriod = input.ReadBool();
            break;
          }
          case 513: {
            CrossoverBoundSnappingDistance = input.ReadDouble();
            break;
          }
          case 520: {
            PushToVertex = input.ReadBool();
            break;
          }
          case 528: {
            LogToStdout = input.ReadBool();
            break;
          }
          case 536: {
            UseImpliedFreePreprocessor = input.ReadBool();
            break;
          }
          case 552: {
            DualPricePrioritizeNorm = input.ReadBool();
            break;
          }
          case 561: {
            MaxValidMagnitude = input.ReadDouble();
            break;
          }
          case 569: {
            DropMagnitude = input.ReadDouble();
            break;
          }
        }
      }
    #endif
    }
 
    #if !GOOGLE_PROTOBUF_REFSTRUCT_COMPATIBILITY_MODE
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    void pb::IBufferMessage.InternalMergeFrom(ref pb::ParseContext input) {
      uint tag;
      while ((tag = input.ReadTag()) != 0) {
      if ((tag & 7) == 4) {
        // Abort on any end group tag.
        return;
      }
      switch(tag) {
          default:
            _unknownFields = pb::UnknownFieldSet.MergeFieldFrom(_unknownFields, ref input);
            break;
          case 8: {
            FeasibilityRule = (global::Google.OrTools.Glop.GlopParameters.Types.PricingRule) input.ReadEnum();
            break;
          }
          case 16: {
            OptimizationRule = (global::Google.OrTools.Glop.GlopParameters.Types.PricingRule) input.ReadEnum();
            break;
          }
          case 49: {
            RefactorizationThreshold = input.ReadDouble();
            break;
          }
          case 65: {
            RecomputeReducedCostsThreshold = input.ReadDouble();
            break;
          }
          case 73: {
            RecomputeEdgesNormThreshold = input.ReadDouble();
            break;
          }
          case 81: {
            PrimalFeasibilityTolerance = input.ReadDouble();
            break;
          }
          case 89: {
            DualFeasibilityTolerance = input.ReadDouble();
            break;
          }
          case 97: {
            RatioTestZeroThreshold = input.ReadDouble();
            break;
          }
          case 105: {
            HarrisToleranceRatio = input.ReadDouble();
            break;
          }
          case 113: {
            SmallPivotThreshold = input.ReadDouble();
            break;
          }
          case 121: {
            MinimumAcceptablePivot = input.ReadDouble();
            break;
          }
          case 128: {
            UseScaling = input.ReadBool();
            break;
          }
          case 136: {
            InitialBasis = (global::Google.OrTools.Glop.GlopParameters.Types.InitialBasisHeuristic) input.ReadEnum();
            break;
          }
          case 144: {
            UseTransposedMatrix = input.ReadBool();
            break;
          }
          case 152: {
            BasisRefactorizationPeriod = input.ReadInt32();
            break;
          }
          case 160: {
            SolveDualProblem = (global::Google.OrTools.Glop.GlopParameters.Types.SolverBehavior) input.ReadEnum();
            break;
          }
          case 169: {
            DualizerThreshold = input.ReadDouble();
            break;
          }
          case 177: {
            SolutionFeasibilityTolerance = input.ReadDouble();
            break;
          }
          case 192: {
            ProvideStrongOptimalGuarantee = input.ReadBool();
            break;
          }
          case 201: {
            LuFactorizationPivotThreshold = input.ReadDouble();
            break;
          }
          case 209: {
            MaxTimeInSeconds = input.ReadDouble();
            break;
          }
          case 216: {
            MaxNumberOfIterations = input.ReadInt64();
            break;
          }
          case 232: {
            MarkowitzZlatevParameter = input.ReadInt32();
            break;
          }
          case 241: {
            MarkowitzSingularityThreshold = input.ReadDouble();
            break;
          }
          case 248: {
            UseDualSimplex = input.ReadBool();
            break;
          }
          case 256: {
            AllowSimplexAlgorithmChange = input.ReadBool();
            break;
          }
          case 264: {
            DevexWeightsResetPeriod = input.ReadInt32();
            break;
          }
          case 272: {
            UsePreprocessing = input.ReadBool();
            break;
          }
          case 280: {
            UseMiddleProductFormUpdate = input.ReadBool();
            break;
          }
          case 288: {
            InitializeDevexWithColumnNorms = input.ReadBool();
            break;
          }
          case 296: {
            ExploitSingletonColumnInInitialBasis = input.ReadBool();
            break;
          }
          case 305: {
            DualSmallPivotThreshold = input.ReadDouble();
            break;
          }
          case 313: {
            PreprocessorZeroTolerance = input.ReadDouble();
            break;
          }
          case 321: {
            ObjectiveLowerLimit = input.ReadDouble();
            break;
          }
          case 329: {
            ObjectiveUpperLimit = input.ReadDouble();
            break;
          }
          case 337: {
            DegenerateMinistepFactor = input.ReadDouble();
            break;
          }
          case 344: {
            RandomSeed = input.ReadInt32();
            break;
          }
          case 352: {
            NumOmpThreads = input.ReadInt32();
            break;
          }
          case 361: {
            MaxDeterministicTime = input.ReadDouble();
            break;
          }
          case 417: {
            DropTolerance = input.ReadDouble();
            break;
          }
          case 424: {
            PerturbCostsInDualSimplex = input.ReadBool();
            break;
          }
          case 433: {
            RelativeCostPerturbation = input.ReadDouble();
            break;
          }
          case 441: {
            RelativeMaxCostPerturbation = input.ReadDouble();
            break;
          }
          case 449: {
            MaxNumberOfReoptimizations = input.ReadDouble();
            break;
          }
          case 456: {
            ScalingMethod = (global::Google.OrTools.Glop.GlopParameters.Types.ScalingAlgorithm) input.ReadEnum();
            break;
          }
          case 464: {
            ChangeStatusToImprecise = input.ReadBool();
            break;
          }
          case 473: {
            InitialConditionNumberThreshold = input.ReadDouble();
            break;
          }
          case 480: {
            CostScaling = (global::Google.OrTools.Glop.GlopParameters.Types.CostScalingAlgorithm) input.ReadEnum();
            break;
          }
          case 488: {
            LogSearchProgress = input.ReadBool();
            break;
          }
          case 496: {
            UseDedicatedDualFeasibilityAlgorithm = input.ReadBool();
            break;
          }
          case 504: {
            DynamicallyAdjustRefactorizationPeriod = input.ReadBool();
            break;
          }
          case 513: {
            CrossoverBoundSnappingDistance = input.ReadDouble();
            break;
          }
          case 520: {
            PushToVertex = input.ReadBool();
            break;
          }
          case 528: {
            LogToStdout = input.ReadBool();
            break;
          }
          case 536: {
            UseImpliedFreePreprocessor = input.ReadBool();
            break;
          }
          case 552: {
            DualPricePrioritizeNorm = input.ReadBool();
            break;
          }
          case 561: {
            MaxValidMagnitude = input.ReadDouble();
            break;
          }
          case 569: {
            DropMagnitude = input.ReadDouble();
            break;
          }
        }
      }
    }
    #endif
 
    #region Nested types
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    [global::System.CodeDom.Compiler.GeneratedCode("protoc", null)]
    public static partial class Types {
      public enum ScalingAlgorithm {
        [pbr::OriginalName("DEFAULT")] Default = 0,
        [pbr::OriginalName("EQUILIBRATION")] Equilibration = 1,
        [pbr::OriginalName("LINEAR_PROGRAM")] LinearProgram = 2,
      }

      public enum SolverBehavior {
        [pbr::OriginalName("ALWAYS_DO")] AlwaysDo = 0,
        [pbr::OriginalName("NEVER_DO")] NeverDo = 1,
        [pbr::OriginalName("LET_SOLVER_DECIDE")] LetSolverDecide = 2,
      }

      public enum PricingRule {

        [pbr::OriginalName("DANTZIG")] Dantzig = 0,
        /// <summary>
        /// Normalize the reduced costs by the norm of the edges. Since computing
        /// norms at each step is too expensive, reduced costs and norms are
        /// updated iteratively from one iteration to the next.
        /// </summary>
        [pbr::OriginalName("STEEPEST_EDGE")] SteepestEdge = 1,
        /// </summary>
        [pbr::OriginalName("DEVEX")] Devex = 2,
      }

      public enum InitialBasisHeuristic {
        [pbr::OriginalName("NONE")] None = 0,
        [pbr::OriginalName("BIXBY")] Bixby = 1,

        /// </summary>
        [pbr::OriginalName("TRIANGULAR")] Triangular = 2,
        [pbr::OriginalName("MAROS")] Maros = 3,
      }

      public enum CostScalingAlgorithm {
        [pbr::OriginalName("NO_COST_SCALING")] NoCostScaling = 0,
        [pbr::OriginalName("CONTAIN_ONE_COST_SCALING")] ContainOneCostScaling = 1,

        [pbr::OriginalName("MEAN_COST_SCALING")] MeanCostScaling = 2,
        [pbr::OriginalName("MEDIAN_COST_SCALING")] MedianCostScaling = 3,
      }
 
    }
    #endregion
 
  }
 
  #endregion
 
}
 
#endregion Designer generated code