linear_solver.pb.cc

Go to the documentation of this file.

// Generated by the protocol buffer compiler.  DO NOT EDIT!
// source: ortools/linear_solver/linear_solver.proto

#include "ortools/linear_solver/linear_solver.pb.h"

#include <algorithm>

#include <google/protobuf/io/coded_stream.h>
#include <google/protobuf/extension_set.h>
#include <google/protobuf/wire_format_lite.h>
#include <google/protobuf/descriptor.h>
#include <google/protobuf/generated_message_reflection.h>
#include <google/protobuf/reflection_ops.h>
#include <google/protobuf/wire_format.h>
// @@protoc_insertion_point(includes)
#include <google/protobuf/port_def.inc>

PROTOBUF_PRAGMA_INIT_SEG
namespace operations_research {
constexpr MPVariableProto::MPVariableProto(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : name_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
  , objective_coefficient_(0)
  , is_integer_(false)
  , branching_priority_(0)
  , lower_bound_(-std::numeric_limits<double>::infinity())
  , upper_bound_(std::numeric_limits<double>::infinity()){}
struct MPVariableProtoDefaultTypeInternal {
  constexpr MPVariableProtoDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~MPVariableProtoDefaultTypeInternal() {}
  union {
    MPVariableProto _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT MPVariableProtoDefaultTypeInternal _MPVariableProto_default_instance_;
constexpr MPConstraintProto::MPConstraintProto(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : var_index_()
  , _var_index_cached_byte_size_(0)
  , coefficient_()
  , name_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
  , is_lazy_(false)
  , lower_bound_(-std::numeric_limits<double>::infinity())
  , upper_bound_(std::numeric_limits<double>::infinity()){}
struct MPConstraintProtoDefaultTypeInternal {
  constexpr MPConstraintProtoDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~MPConstraintProtoDefaultTypeInternal() {}
  union {
    MPConstraintProto _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT MPConstraintProtoDefaultTypeInternal _MPConstraintProto_default_instance_;
constexpr MPGeneralConstraintProto::MPGeneralConstraintProto(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : name_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
  , _oneof_case_{}{}
struct MPGeneralConstraintProtoDefaultTypeInternal {
  constexpr MPGeneralConstraintProtoDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~MPGeneralConstraintProtoDefaultTypeInternal() {}
  union {
    MPGeneralConstraintProto _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT MPGeneralConstraintProtoDefaultTypeInternal _MPGeneralConstraintProto_default_instance_;
constexpr MPIndicatorConstraint::MPIndicatorConstraint(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : constraint_(nullptr)
  , var_index_(0)
  , var_value_(0){}
struct MPIndicatorConstraintDefaultTypeInternal {
  constexpr MPIndicatorConstraintDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~MPIndicatorConstraintDefaultTypeInternal() {}
  union {
    MPIndicatorConstraint _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT MPIndicatorConstraintDefaultTypeInternal _MPIndicatorConstraint_default_instance_;
constexpr MPSosConstraint::MPSosConstraint(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : var_index_()
  , weight_()
  , type_(0)
{}
struct MPSosConstraintDefaultTypeInternal {
  constexpr MPSosConstraintDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~MPSosConstraintDefaultTypeInternal() {}
  union {
    MPSosConstraint _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT MPSosConstraintDefaultTypeInternal _MPSosConstraint_default_instance_;
constexpr MPQuadraticConstraint::MPQuadraticConstraint(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : var_index_()
  , coefficient_()
  , qvar1_index_()
  , qvar2_index_()
  , qcoefficient_()
  , lower_bound_(-std::numeric_limits<double>::infinity())
  , upper_bound_(std::numeric_limits<double>::infinity()){}
struct MPQuadraticConstraintDefaultTypeInternal {
  constexpr MPQuadraticConstraintDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~MPQuadraticConstraintDefaultTypeInternal() {}
  union {
    MPQuadraticConstraint _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT MPQuadraticConstraintDefaultTypeInternal _MPQuadraticConstraint_default_instance_;
constexpr MPAbsConstraint::MPAbsConstraint(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : var_index_(0)
  , resultant_var_index_(0){}
struct MPAbsConstraintDefaultTypeInternal {
  constexpr MPAbsConstraintDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~MPAbsConstraintDefaultTypeInternal() {}
  union {
    MPAbsConstraint _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT MPAbsConstraintDefaultTypeInternal _MPAbsConstraint_default_instance_;
constexpr MPArrayConstraint::MPArrayConstraint(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : var_index_()
  , resultant_var_index_(0){}
struct MPArrayConstraintDefaultTypeInternal {
  constexpr MPArrayConstraintDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~MPArrayConstraintDefaultTypeInternal() {}
  union {
    MPArrayConstraint _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT MPArrayConstraintDefaultTypeInternal _MPArrayConstraint_default_instance_;
constexpr MPArrayWithConstantConstraint::MPArrayWithConstantConstraint(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : var_index_()
  , constant_(0)
  , resultant_var_index_(0){}
struct MPArrayWithConstantConstraintDefaultTypeInternal {
  constexpr MPArrayWithConstantConstraintDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~MPArrayWithConstantConstraintDefaultTypeInternal() {}
  union {
    MPArrayWithConstantConstraint _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT MPArrayWithConstantConstraintDefaultTypeInternal _MPArrayWithConstantConstraint_default_instance_;
constexpr MPQuadraticObjective::MPQuadraticObjective(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : qvar1_index_()
  , qvar2_index_()
  , coefficient_(){}
struct MPQuadraticObjectiveDefaultTypeInternal {
  constexpr MPQuadraticObjectiveDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~MPQuadraticObjectiveDefaultTypeInternal() {}
  union {
    MPQuadraticObjective _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT MPQuadraticObjectiveDefaultTypeInternal _MPQuadraticObjective_default_instance_;
constexpr PartialVariableAssignment::PartialVariableAssignment(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : var_index_()
  , _var_index_cached_byte_size_(0)
  , var_value_(){}
struct PartialVariableAssignmentDefaultTypeInternal {
  constexpr PartialVariableAssignmentDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~PartialVariableAssignmentDefaultTypeInternal() {}
  union {
    PartialVariableAssignment _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PartialVariableAssignmentDefaultTypeInternal _PartialVariableAssignment_default_instance_;
constexpr MPModelProto::MPModelProto(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : variable_()
  , constraint_()
  , general_constraint_()
  , name_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
  , solution_hint_(nullptr)
  , quadratic_objective_(nullptr)
  , objective_offset_(0)
  , maximize_(false){}
struct MPModelProtoDefaultTypeInternal {
  constexpr MPModelProtoDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~MPModelProtoDefaultTypeInternal() {}
  union {
    MPModelProto _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT MPModelProtoDefaultTypeInternal _MPModelProto_default_instance_;
constexpr OptionalDouble::OptionalDouble(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : value_(0){}
struct OptionalDoubleDefaultTypeInternal {
  constexpr OptionalDoubleDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~OptionalDoubleDefaultTypeInternal() {}
  union {
    OptionalDouble _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT OptionalDoubleDefaultTypeInternal _OptionalDouble_default_instance_;
constexpr MPSolverCommonParameters::MPSolverCommonParameters(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : relative_mip_gap_(nullptr)
  , primal_tolerance_(nullptr)
  , dual_tolerance_(nullptr)
  , lp_algorithm_(0)

  , presolve_(0)

  , scaling_(0)
{}
struct MPSolverCommonParametersDefaultTypeInternal {
  constexpr MPSolverCommonParametersDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~MPSolverCommonParametersDefaultTypeInternal() {}
  union {
    MPSolverCommonParameters _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT MPSolverCommonParametersDefaultTypeInternal _MPSolverCommonParameters_default_instance_;
constexpr MPModelDeltaProto_VariableOverridesEntry_DoNotUse::MPModelDeltaProto_VariableOverridesEntry_DoNotUse(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized){}
struct MPModelDeltaProto_VariableOverridesEntry_DoNotUseDefaultTypeInternal {
  constexpr MPModelDeltaProto_VariableOverridesEntry_DoNotUseDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~MPModelDeltaProto_VariableOverridesEntry_DoNotUseDefaultTypeInternal() {}
  union {
    MPModelDeltaProto_VariableOverridesEntry_DoNotUse _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT MPModelDeltaProto_VariableOverridesEntry_DoNotUseDefaultTypeInternal _MPModelDeltaProto_VariableOverridesEntry_DoNotUse_default_instance_;
constexpr MPModelDeltaProto_ConstraintOverridesEntry_DoNotUse::MPModelDeltaProto_ConstraintOverridesEntry_DoNotUse(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized){}
struct MPModelDeltaProto_ConstraintOverridesEntry_DoNotUseDefaultTypeInternal {
  constexpr MPModelDeltaProto_ConstraintOverridesEntry_DoNotUseDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~MPModelDeltaProto_ConstraintOverridesEntry_DoNotUseDefaultTypeInternal() {}
  union {
    MPModelDeltaProto_ConstraintOverridesEntry_DoNotUse _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT MPModelDeltaProto_ConstraintOverridesEntry_DoNotUseDefaultTypeInternal _MPModelDeltaProto_ConstraintOverridesEntry_DoNotUse_default_instance_;
constexpr MPModelDeltaProto::MPModelDeltaProto(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : variable_overrides_(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{})
  , constraint_overrides_(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{})
  , baseline_model_file_path_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string){}
struct MPModelDeltaProtoDefaultTypeInternal {
  constexpr MPModelDeltaProtoDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~MPModelDeltaProtoDefaultTypeInternal() {}
  union {
    MPModelDeltaProto _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT MPModelDeltaProtoDefaultTypeInternal _MPModelDeltaProto_default_instance_;
constexpr MPModelRequest::MPModelRequest(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : solver_specific_parameters_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
  , model_(nullptr)
  , model_delta_(nullptr)
  , solver_time_limit_seconds_(0)
  , enable_internal_solver_output_(false)
  , ignore_solver_specific_parameters_failure_(false)
  , populate_additional_solutions_up_to_(0)
  , solver_type_(2)
{}
struct MPModelRequestDefaultTypeInternal {
  constexpr MPModelRequestDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~MPModelRequestDefaultTypeInternal() {}
  union {
    MPModelRequest _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT MPModelRequestDefaultTypeInternal _MPModelRequest_default_instance_;
constexpr MPSolution::MPSolution(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : variable_value_()
  , objective_value_(0){}
struct MPSolutionDefaultTypeInternal {
  constexpr MPSolutionDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~MPSolutionDefaultTypeInternal() {}
  union {
    MPSolution _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT MPSolutionDefaultTypeInternal _MPSolution_default_instance_;
constexpr MPSolveInfo::MPSolveInfo(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : solve_wall_time_seconds_(0)
  , solve_user_time_seconds_(0){}
struct MPSolveInfoDefaultTypeInternal {
  constexpr MPSolveInfoDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~MPSolveInfoDefaultTypeInternal() {}
  union {
    MPSolveInfo _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT MPSolveInfoDefaultTypeInternal _MPSolveInfo_default_instance_;
constexpr MPSolutionResponse::MPSolutionResponse(
  ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
  : variable_value_()
  , dual_value_()
  , reduced_cost_()
  , additional_solutions_()
  , status_str_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
  , solve_info_(nullptr)
  , objective_value_(0)
  , best_objective_bound_(0)
  , status_(99)
{}
struct MPSolutionResponseDefaultTypeInternal {
  constexpr MPSolutionResponseDefaultTypeInternal()
    : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
  ~MPSolutionResponseDefaultTypeInternal() {}
  union {
    MPSolutionResponse _instance;
  };
};
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT MPSolutionResponseDefaultTypeInternal _MPSolutionResponse_default_instance_;
}  // namespace operations_research
static ::PROTOBUF_NAMESPACE_ID::Metadata file_level_metadata_ortools_2flinear_5fsolver_2flinear_5fsolver_2eproto[21];
static const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* file_level_enum_descriptors_ortools_2flinear_5fsolver_2flinear_5fsolver_2eproto[4];
static constexpr ::PROTOBUF_NAMESPACE_ID::ServiceDescriptor const** file_level_service_descriptors_ortools_2flinear_5fsolver_2flinear_5fsolver_2eproto = nullptr;

const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_ortools_2flinear_5fsolver_2flinear_5fsolver_2eproto::offsets[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = {
  PROTOBUF_FIELD_OFFSET(::operations_research::MPVariableProto, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::operations_research::MPVariableProto, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::operations_research::MPVariableProto, lower_bound_),
  PROTOBUF_FIELD_OFFSET(::operations_research::MPVariableProto, upper_bound_),
  PROTOBUF_FIELD_OFFSET(::operations_research::MPVariableProto, objective_coefficient_),
  PROTOBUF_FIELD_OFFSET(::operations_research::MPVariableProto, is_integer_),
  PROTOBUF_FIELD_OFFSET(::operations_research::MPVariableProto, name_),
  PROTOBUF_FIELD_OFFSET(::operations_research::MPVariableProto, branching_priority_),
  4,
  5,
  1,
  2,
  0,
  3,
  PROTOBUF_FIELD_OFFSET(::operations_research::MPConstraintProto, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::operations_research::MPConstraintProto, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::operations_research::MPConstraintProto, var_index_),
  PROTOBUF_FIELD_OFFSET(::operations_research::MPConstraintProto, coefficient_),
  PROTOBUF_FIELD_OFFSET(::operations_research::MPConstraintProto, lower_bound_),
  PROTOBUF_FIELD_OFFSET(::operations_research::MPConstraintProto, upper_bound_),
  PROTOBUF_FIELD_OFFSET(::operations_research::MPConstraintProto, name_),
  PROTOBUF_FIELD_OFFSET(::operations_research::MPConstraintProto, is_lazy_),
  ~0u,
  ~0u,
  2,
  3,
  0,
  1,
  PROTOBUF_FIELD_OFFSET(::operations_research::MPGeneralConstraintProto, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::operations_research::MPGeneralConstraintProto, _internal_metadata_),
  ~0u,  // no _extensions_
  PROTOBUF_FIELD_OFFSET(::operations_research::MPGeneralConstraintProto, _oneof_case_[0]),
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::operations_research::MPGeneralConstraintProto, name_),
  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
  ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
  PROTOBUF_FIELD_OFFSET(::operations_research::MPGeneralConstraintProto, general_constraint_),
  0,
  ~0u,
  ~0u,
  ~0u,
  ~0u,
  ~0u,
  ~0u,
  ~0u,
  ~0u,
  PROTOBUF_FIELD_OFFSET(::operations_research::MPIndicatorConstraint, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::operations_research::MPIndicatorConstraint, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::operations_research::MPIndicatorConstraint, var_index_),
  PROTOBUF_FIELD_OFFSET(::operations_research::MPIndicatorConstraint, var_value_),
  PROTOBUF_FIELD_OFFSET(::operations_research::MPIndicatorConstraint, constraint_),
  1,
  2,
  0,
  PROTOBUF_FIELD_OFFSET(::operations_research::MPSosConstraint, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::operations_research::MPSosConstraint, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::operations_research::MPSosConstraint, type_),
  PROTOBUF_FIELD_OFFSET(::operations_research::MPSosConstraint, var_index_),
  PROTOBUF_FIELD_OFFSET(::operations_research::MPSosConstraint, weight_),
  0,
  ~0u,
  ~0u,
  PROTOBUF_FIELD_OFFSET(::operations_research::MPQuadraticConstraint, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::operations_research::MPQuadraticConstraint, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::operations_research::MPQuadraticConstraint, var_index_),
  PROTOBUF_FIELD_OFFSET(::operations_research::MPQuadraticConstraint, coefficient_),
  PROTOBUF_FIELD_OFFSET(::operations_research::MPQuadraticConstraint, qvar1_index_),
  PROTOBUF_FIELD_OFFSET(::operations_research::MPQuadraticConstraint, qvar2_index_),
  PROTOBUF_FIELD_OFFSET(::operations_research::MPQuadraticConstraint, qcoefficient_),
  PROTOBUF_FIELD_OFFSET(::operations_research::MPQuadraticConstraint, lower_bound_),
  PROTOBUF_FIELD_OFFSET(::operations_research::MPQuadraticConstraint, upper_bound_),
  ~0u,
  ~0u,
  ~0u,
  ~0u,
  ~0u,
  0,
  1,
  PROTOBUF_FIELD_OFFSET(::operations_research::MPAbsConstraint, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::operations_research::MPAbsConstraint, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::operations_research::MPAbsConstraint, var_index_),
  PROTOBUF_FIELD_OFFSET(::operations_research::MPAbsConstraint, resultant_var_index_),
  0,
  1,
  PROTOBUF_FIELD_OFFSET(::operations_research::MPArrayConstraint, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::operations_research::MPArrayConstraint, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::operations_research::MPArrayConstraint, var_index_),
  PROTOBUF_FIELD_OFFSET(::operations_research::MPArrayConstraint, resultant_var_index_),
  ~0u,
  0,
  PROTOBUF_FIELD_OFFSET(::operations_research::MPArrayWithConstantConstraint, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::operations_research::MPArrayWithConstantConstraint, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::operations_research::MPArrayWithConstantConstraint, var_index_),
  PROTOBUF_FIELD_OFFSET(::operations_research::MPArrayWithConstantConstraint, constant_),
  PROTOBUF_FIELD_OFFSET(::operations_research::MPArrayWithConstantConstraint, resultant_var_index_),
  ~0u,
  0,
  1,
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::operations_research::MPQuadraticObjective, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::operations_research::MPQuadraticObjective, qvar1_index_),
  PROTOBUF_FIELD_OFFSET(::operations_research::MPQuadraticObjective, qvar2_index_),
  PROTOBUF_FIELD_OFFSET(::operations_research::MPQuadraticObjective, coefficient_),
  ~0u,  // no _has_bits_
  PROTOBUF_FIELD_OFFSET(::operations_research::PartialVariableAssignment, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::operations_research::PartialVariableAssignment, var_index_),
  PROTOBUF_FIELD_OFFSET(::operations_research::PartialVariableAssignment, var_value_),
  PROTOBUF_FIELD_OFFSET(::operations_research::MPModelProto, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::operations_research::MPModelProto, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::operations_research::MPModelProto, variable_),
  PROTOBUF_FIELD_OFFSET(::operations_research::MPModelProto, constraint_),
  PROTOBUF_FIELD_OFFSET(::operations_research::MPModelProto, general_constraint_),
  PROTOBUF_FIELD_OFFSET(::operations_research::MPModelProto, maximize_),
  PROTOBUF_FIELD_OFFSET(::operations_research::MPModelProto, objective_offset_),
  PROTOBUF_FIELD_OFFSET(::operations_research::MPModelProto, quadratic_objective_),
  PROTOBUF_FIELD_OFFSET(::operations_research::MPModelProto, name_),
  PROTOBUF_FIELD_OFFSET(::operations_research::MPModelProto, solution_hint_),
  ~0u,
  ~0u,
  ~0u,
  4,
  3,
  2,
  0,
  1,
  PROTOBUF_FIELD_OFFSET(::operations_research::OptionalDouble, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::operations_research::OptionalDouble, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::operations_research::OptionalDouble, value_),
  0,
  PROTOBUF_FIELD_OFFSET(::operations_research::MPSolverCommonParameters, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::operations_research::MPSolverCommonParameters, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::operations_research::MPSolverCommonParameters, relative_mip_gap_),
  PROTOBUF_FIELD_OFFSET(::operations_research::MPSolverCommonParameters, primal_tolerance_),
  PROTOBUF_FIELD_OFFSET(::operations_research::MPSolverCommonParameters, dual_tolerance_),
  PROTOBUF_FIELD_OFFSET(::operations_research::MPSolverCommonParameters, lp_algorithm_),
  PROTOBUF_FIELD_OFFSET(::operations_research::MPSolverCommonParameters, presolve_),
  PROTOBUF_FIELD_OFFSET(::operations_research::MPSolverCommonParameters, scaling_),
  0,
  1,
  2,
  3,
  4,
  5,
  PROTOBUF_FIELD_OFFSET(::operations_research::MPModelDeltaProto_VariableOverridesEntry_DoNotUse, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::operations_research::MPModelDeltaProto_VariableOverridesEntry_DoNotUse, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::operations_research::MPModelDeltaProto_VariableOverridesEntry_DoNotUse, key_),
  PROTOBUF_FIELD_OFFSET(::operations_research::MPModelDeltaProto_VariableOverridesEntry_DoNotUse, value_),
  0,
  1,
  PROTOBUF_FIELD_OFFSET(::operations_research::MPModelDeltaProto_ConstraintOverridesEntry_DoNotUse, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::operations_research::MPModelDeltaProto_ConstraintOverridesEntry_DoNotUse, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::operations_research::MPModelDeltaProto_ConstraintOverridesEntry_DoNotUse, key_),
  PROTOBUF_FIELD_OFFSET(::operations_research::MPModelDeltaProto_ConstraintOverridesEntry_DoNotUse, value_),
  0,
  1,
  PROTOBUF_FIELD_OFFSET(::operations_research::MPModelDeltaProto, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::operations_research::MPModelDeltaProto, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::operations_research::MPModelDeltaProto, baseline_model_file_path_),
  PROTOBUF_FIELD_OFFSET(::operations_research::MPModelDeltaProto, variable_overrides_),
  PROTOBUF_FIELD_OFFSET(::operations_research::MPModelDeltaProto, constraint_overrides_),
  0,
  ~0u,
  ~0u,
  PROTOBUF_FIELD_OFFSET(::operations_research::MPModelRequest, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::operations_research::MPModelRequest, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::operations_research::MPModelRequest, model_),
  PROTOBUF_FIELD_OFFSET(::operations_research::MPModelRequest, solver_type_),
  PROTOBUF_FIELD_OFFSET(::operations_research::MPModelRequest, solver_time_limit_seconds_),
  PROTOBUF_FIELD_OFFSET(::operations_research::MPModelRequest, enable_internal_solver_output_),
  PROTOBUF_FIELD_OFFSET(::operations_research::MPModelRequest, solver_specific_parameters_),
  PROTOBUF_FIELD_OFFSET(::operations_research::MPModelRequest, ignore_solver_specific_parameters_failure_),
  PROTOBUF_FIELD_OFFSET(::operations_research::MPModelRequest, model_delta_),
  PROTOBUF_FIELD_OFFSET(::operations_research::MPModelRequest, populate_additional_solutions_up_to_),
  1,
  7,
  3,
  4,
  0,
  5,
  2,
  6,
  PROTOBUF_FIELD_OFFSET(::operations_research::MPSolution, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::operations_research::MPSolution, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::operations_research::MPSolution, objective_value_),
  PROTOBUF_FIELD_OFFSET(::operations_research::MPSolution, variable_value_),
  0,
  ~0u,
  PROTOBUF_FIELD_OFFSET(::operations_research::MPSolveInfo, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::operations_research::MPSolveInfo, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::operations_research::MPSolveInfo, solve_wall_time_seconds_),
  PROTOBUF_FIELD_OFFSET(::operations_research::MPSolveInfo, solve_user_time_seconds_),
  0,
  1,
  PROTOBUF_FIELD_OFFSET(::operations_research::MPSolutionResponse, _has_bits_),
  PROTOBUF_FIELD_OFFSET(::operations_research::MPSolutionResponse, _internal_metadata_),
  ~0u,  // no _extensions_
  ~0u,  // no _oneof_case_
  ~0u,  // no _weak_field_map_
  PROTOBUF_FIELD_OFFSET(::operations_research::MPSolutionResponse, status_),
  PROTOBUF_FIELD_OFFSET(::operations_research::MPSolutionResponse, status_str_),
  PROTOBUF_FIELD_OFFSET(::operations_research::MPSolutionResponse, objective_value_),
  PROTOBUF_FIELD_OFFSET(::operations_research::MPSolutionResponse, best_objective_bound_),
  PROTOBUF_FIELD_OFFSET(::operations_research::MPSolutionResponse, variable_value_),
  PROTOBUF_FIELD_OFFSET(::operations_research::MPSolutionResponse, solve_info_),
  PROTOBUF_FIELD_OFFSET(::operations_research::MPSolutionResponse, dual_value_),
  PROTOBUF_FIELD_OFFSET(::operations_research::MPSolutionResponse, reduced_cost_),
  PROTOBUF_FIELD_OFFSET(::operations_research::MPSolutionResponse, additional_solutions_),
  4,
  0,
  2,
  3,
  ~0u,
  1,
  ~0u,
  ~0u,
  ~0u,
};
static const ::PROTOBUF_NAMESPACE_ID::internal::MigrationSchema schemas[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = {
  { 0, 11, sizeof(::operations_research::MPVariableProto)},
  { 17, 28, sizeof(::operations_research::MPConstraintProto)},
  { 34, 49, sizeof(::operations_research::MPGeneralConstraintProto)},
  { 58, 66, sizeof(::operations_research::MPIndicatorConstraint)},
  { 69, 77, sizeof(::operations_research::MPSosConstraint)},
  { 80, 92, sizeof(::operations_research::MPQuadraticConstraint)},
  { 99, 106, sizeof(::operations_research::MPAbsConstraint)},
  { 108, 115, sizeof(::operations_research::MPArrayConstraint)},
  { 117, 125, sizeof(::operations_research::MPArrayWithConstantConstraint)},
  { 128, -1, sizeof(::operations_research::MPQuadraticObjective)},
  { 136, -1, sizeof(::operations_research::PartialVariableAssignment)},
  { 143, 156, sizeof(::operations_research::MPModelProto)},
  { 164, 170, sizeof(::operations_research::OptionalDouble)},
  { 171, 182, sizeof(::operations_research::MPSolverCommonParameters)},
  { 188, 195, sizeof(::operations_research::MPModelDeltaProto_VariableOverridesEntry_DoNotUse)},
  { 197, 204, sizeof(::operations_research::MPModelDeltaProto_ConstraintOverridesEntry_DoNotUse)},
  { 206, 214, sizeof(::operations_research::MPModelDeltaProto)},
  { 217, 230, sizeof(::operations_research::MPModelRequest)},
  { 238, 245, sizeof(::operations_research::MPSolution)},
  { 247, 254, sizeof(::operations_research::MPSolveInfo)},
  { 256, 270, sizeof(::operations_research::MPSolutionResponse)},
};

static ::PROTOBUF_NAMESPACE_ID::Message const * const file_default_instances[] = {
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::operations_research::_MPVariableProto_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::operations_research::_MPConstraintProto_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::operations_research::_MPGeneralConstraintProto_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::operations_research::_MPIndicatorConstraint_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::operations_research::_MPSosConstraint_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::operations_research::_MPQuadraticConstraint_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::operations_research::_MPAbsConstraint_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::operations_research::_MPArrayConstraint_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::operations_research::_MPArrayWithConstantConstraint_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::operations_research::_MPQuadraticObjective_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::operations_research::_PartialVariableAssignment_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::operations_research::_MPModelProto_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::operations_research::_OptionalDouble_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::operations_research::_MPSolverCommonParameters_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::operations_research::_MPModelDeltaProto_VariableOverridesEntry_DoNotUse_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::operations_research::_MPModelDeltaProto_ConstraintOverridesEntry_DoNotUse_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::operations_research::_MPModelDeltaProto_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::operations_research::_MPModelRequest_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::operations_research::_MPSolution_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::operations_research::_MPSolveInfo_default_instance_),
  reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::operations_research::_MPSolutionResponse_default_instance_),
};

const char descriptor_table_protodef_ortools_2flinear_5fsolver_2flinear_5fsolver_2eproto[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) =
  "\n)ortools/linear_solver/linear_solver.pr"
  "oto\022\023operations_research\032#ortools/util/o"
  "ptional_boolean.proto\"\262\001\n\017MPVariableProt"
  "o\022\031\n\013lower_bound\030\001 \001(\001:\004-inf\022\030\n\013upper_bo"
  "und\030\002 \001(\001:\003inf\022 \n\025objective_coefficient\030"
  "\003 \001(\001:\0010\022\031\n\nis_integer\030\004 \001(\010:\005false\022\016\n\004n"
  "ame\030\005 \001(\t:\000\022\035\n\022branching_priority\030\006 \001(\005:"
  "\0010\"\240\001\n\021MPConstraintProto\022\025\n\tvar_index\030\006 "
  "\003(\005B\002\020\001\022\027\n\013coefficient\030\007 \003(\001B\002\020\001\022\031\n\013lowe"
  "r_bound\030\002 \001(\001:\004-inf\022\030\n\013upper_bound\030\003 \001(\001"
  ":\003inf\022\016\n\004name\030\004 \001(\t:\000\022\026\n\007is_lazy\030\005 \001(\010:\005"
  "false\"\367\004\n\030MPGeneralConstraintProto\022\016\n\004na"
  "me\030\001 \001(\t:\000\022J\n\024indicator_constraint\030\002 \001(\013"
  "2*.operations_research.MPIndicatorConstr"
  "aintH\000\022>\n\016sos_constraint\030\003 \001(\0132$.operati"
  "ons_research.MPSosConstraintH\000\022J\n\024quadra"
  "tic_constraint\030\004 \001(\0132*.operations_resear"
  "ch.MPQuadraticConstraintH\000\022>\n\016abs_constr"
  "aint\030\005 \001(\0132$.operations_research.MPAbsCo"
  "nstraintH\000\022@\n\016and_constraint\030\006 \001(\0132&.ope"
  "rations_research.MPArrayConstraintH\000\022\?\n\r"
  "or_constraint\030\007 \001(\0132&.operations_researc"
  "h.MPArrayConstraintH\000\022L\n\016min_constraint\030"
  "\010 \001(\01322.operations_research.MPArrayWithC"
  "onstantConstraintH\000\022L\n\016max_constraint\030\t "
  "\001(\01322.operations_research.MPArrayWithCon"
  "stantConstraintH\000B\024\n\022general_constraint\""
  "y\n\025MPIndicatorConstraint\022\021\n\tvar_index\030\001 "
  "\001(\005\022\021\n\tvar_value\030\002 \001(\005\022:\n\nconstraint\030\003 \001"
  "(\0132&.operations_research.MPConstraintPro"
  "to\"\237\001\n\017MPSosConstraint\022E\n\004type\030\001 \001(\0162).o"
  "perations_research.MPSosConstraint.Type:"
  "\014SOS1_DEFAULT\022\021\n\tvar_index\030\002 \003(\005\022\016\n\006weig"
  "ht\030\003 \003(\001\"\"\n\004Type\022\020\n\014SOS1_DEFAULT\020\000\022\010\n\004SO"
  "S2\020\001\"\264\001\n\025MPQuadraticConstraint\022\021\n\tvar_in"
  "dex\030\001 \003(\005\022\023\n\013coefficient\030\002 \003(\001\022\023\n\013qvar1_"
  "index\030\003 \003(\005\022\023\n\013qvar2_index\030\004 \003(\005\022\024\n\014qcoe"
  "fficient\030\005 \003(\001\022\031\n\013lower_bound\030\006 \001(\001:\004-in"
  "f\022\030\n\013upper_bound\030\007 \001(\001:\003inf\"A\n\017MPAbsCons"
  "traint\022\021\n\tvar_index\030\001 \001(\005\022\033\n\023resultant_v"
  "ar_index\030\002 \001(\005\"C\n\021MPArrayConstraint\022\021\n\tv"
  "ar_index\030\001 \003(\005\022\033\n\023resultant_var_index\030\002 "
  "\001(\005\"a\n\035MPArrayWithConstantConstraint\022\021\n\t"
  "var_index\030\001 \003(\005\022\020\n\010constant\030\002 \001(\001\022\033\n\023res"
  "ultant_var_index\030\003 \001(\005\"U\n\024MPQuadraticObj"
  "ective\022\023\n\013qvar1_index\030\001 \003(\005\022\023\n\013qvar2_ind"
  "ex\030\002 \003(\005\022\023\n\013coefficient\030\003 \003(\001\"I\n\031Partial"
  "VariableAssignment\022\025\n\tvar_index\030\001 \003(\005B\002\020"
  "\001\022\025\n\tvar_value\030\002 \003(\001B\002\020\001\"\242\003\n\014MPModelProt"
  "o\0226\n\010variable\030\003 \003(\0132$.operations_researc"
  "h.MPVariableProto\022:\n\nconstraint\030\004 \003(\0132&."
  "operations_research.MPConstraintProto\022I\n"
  "\022general_constraint\030\007 \003(\0132-.operations_r"
  "esearch.MPGeneralConstraintProto\022\027\n\010maxi"
  "mize\030\001 \001(\010:\005false\022\033\n\020objective_offset\030\002 "
  "\001(\001:\0010\022F\n\023quadratic_objective\030\010 \001(\0132).op"
  "erations_research.MPQuadraticObjective\022\016"
  "\n\004name\030\005 \001(\t:\000\022E\n\rsolution_hint\030\006 \001(\0132.."
  "operations_research.PartialVariableAssig"
  "nment\"\037\n\016OptionalDouble\022\r\n\005value\030\001 \001(\001\"\275"
  "\004\n\030MPSolverCommonParameters\022=\n\020relative_"
  "mip_gap\030\001 \001(\0132#.operations_research.Opti"
  "onalDouble\022=\n\020primal_tolerance\030\002 \001(\0132#.o"
  "perations_research.OptionalDouble\022;\n\016dua"
  "l_tolerance\030\003 \001(\0132#.operations_research."
  "OptionalDouble\022j\n\014lp_algorithm\030\004 \001(\0162\?.o"
  "perations_research.MPSolverCommonParamet"
  "ers.LPAlgorithmValues:\023LP_ALGO_UNSPECIFI"
  "ED\022H\n\010presolve\030\005 \001(\0162$.operations_resear"
  "ch.OptionalBoolean:\020BOOL_UNSPECIFIED\022G\n\007"
  "scaling\030\007 \001(\0162$.operations_research.Opti"
  "onalBoolean:\020BOOL_UNSPECIFIED\"g\n\021LPAlgor"
  "ithmValues\022\027\n\023LP_ALGO_UNSPECIFIED\020\000\022\020\n\014L"
  "P_ALGO_DUAL\020\001\022\022\n\016LP_ALGO_PRIMAL\020\002\022\023\n\017LP_"
  "ALGO_BARRIER\020\003\"\263\003\n\021MPModelDeltaProto\022 \n\030"
  "baseline_model_file_path\030\001 \001(\t\022Y\n\022variab"
  "le_overrides\030\002 \003(\0132=.operations_research"
  ".MPModelDeltaProto.VariableOverridesEntr"
  "y\022]\n\024constraint_overrides\030\003 \003(\0132\?.operat"
  "ions_research.MPModelDeltaProto.Constrai"
  "ntOverridesEntry\032^\n\026VariableOverridesEnt"
  "ry\022\013\n\003key\030\001 \001(\005\0223\n\005value\030\002 \001(\0132$.operati"
  "ons_research.MPVariableProto:\0028\001\032b\n\030Cons"
  "traintOverridesEntry\022\013\n\003key\030\001 \001(\005\0225\n\005val"
  "ue\030\002 \001(\0132&.operations_research.MPConstra"
  "intProto:\0028\001\"\242\007\n\016MPModelRequest\0220\n\005model"
  "\030\001 \001(\0132!.operations_research.MPModelProt"
  "o\022C\n\013solver_type\030\002 \001(\0162..operations_rese"
  "arch.MPModelRequest.SolverType\022!\n\031solver"
  "_time_limit_seconds\030\003 \001(\001\022,\n\035enable_inte"
  "rnal_solver_output\030\004 \001(\010:\005false\022\"\n\032solve"
  "r_specific_parameters\030\005 \001(\t\0228\n)ignore_so"
  "lver_specific_parameters_failure\030\t \001(\010:\005"
  "false\022;\n\013model_delta\030\010 \001(\0132&.operations_"
  "research.MPModelDeltaProto\022.\n#populate_a"
  "dditional_solutions_up_to\030\013 \001(\005:\0010\"\374\003\n\nS"
  "olverType\022\033\n\027GLOP_LINEAR_PROGRAMMING\020\002\022\032"
  "\n\026CLP_LINEAR_PROGRAMMING\020\000\022\033\n\027GLPK_LINEA"
  "R_PROGRAMMING\020\001\022\035\n\031GUROBI_LINEAR_PROGRAM"
  "MING\020\006\022\035\n\031XPRESS_LINEAR_PROGRAMMING\020e\022\034\n"
  "\030CPLEX_LINEAR_PROGRAMMING\020\n\022\"\n\036SCIP_MIXE"
  "D_INTEGER_PROGRAMMING\020\003\022\"\n\036GLPK_MIXED_IN"
  "TEGER_PROGRAMMING\020\004\022!\n\035CBC_MIXED_INTEGER"
  "_PROGRAMMING\020\005\022$\n GUROBI_MIXED_INTEGER_P"
  "ROGRAMMING\020\007\022$\n XPRESS_MIXED_INTEGER_PRO"
  "GRAMMING\020f\022#\n\037CPLEX_MIXED_INTEGER_PROGRA"
  "MMING\020\013\022\033\n\027BOP_INTEGER_PROGRAMMING\020\014\022\033\n\027"
  "SAT_INTEGER_PROGRAMMING\020\016\022&\n\"KNAPSACK_MI"
  "XED_INTEGER_PROGRAMMING\020\r\"A\n\nMPSolution\022"
  "\027\n\017objective_value\030\001 \001(\001\022\032\n\016variable_val"
  "ue\030\002 \003(\001B\002\020\001\"O\n\013MPSolveInfo\022\037\n\027solve_wal"
  "l_time_seconds\030\001 \001(\001\022\037\n\027solve_user_time_"
  "seconds\030\002 \001(\001\"\370\002\n\022MPSolutionResponse\022T\n\006"
  "status\030\001 \001(\0162+.operations_research.MPSol"
  "verResponseStatus:\027MPSOLVER_UNKNOWN_STAT"
  "US\022\022\n\nstatus_str\030\007 \001(\t\022\027\n\017objective_valu"
  "e\030\002 \001(\001\022\034\n\024best_objective_bound\030\005 \001(\001\022\032\n"
  "\016variable_value\030\003 \003(\001B\002\020\001\0224\n\nsolve_info\030"
  "\n \001(\0132 .operations_research.MPSolveInfo\022"
  "\026\n\ndual_value\030\004 \003(\001B\002\020\001\022\030\n\014reduced_cost\030"
  "\006 \003(\001B\002\020\001\022=\n\024additional_solutions\030\010 \003(\0132"
  "\037.operations_research.MPSolution*\275\003\n\026MPS"
  "olverResponseStatus\022\024\n\020MPSOLVER_OPTIMAL\020"
  "\000\022\025\n\021MPSOLVER_FEASIBLE\020\001\022\027\n\023MPSOLVER_INF"
  "EASIBLE\020\002\022\026\n\022MPSOLVER_UNBOUNDED\020\003\022\025\n\021MPS"
  "OLVER_ABNORMAL\020\004\022\027\n\023MPSOLVER_NOT_SOLVED\020"
  "\006\022\033\n\027MPSOLVER_MODEL_IS_VALID\020a\022\036\n\032MPSOLV"
  "ER_CANCELLED_BY_USER\020b\022\033\n\027MPSOLVER_UNKNO"
  "WN_STATUS\020c\022\032\n\026MPSOLVER_MODEL_INVALID\020\005\022"
  "(\n$MPSOLVER_MODEL_INVALID_SOLUTION_HINT\020"
  "T\022,\n(MPSOLVER_MODEL_INVALID_SOLVER_PARAM"
  "ETERS\020U\022$\n MPSOLVER_SOLVER_TYPE_UNAVAILA"
  "BLE\020\007\022!\n\035MPSOLVER_INCOMPATIBLE_OPTIONS\020q"
  "B#\n\037com.google.ortools.linearsolverP\001"
  ;
static const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable*const descriptor_table_ortools_2flinear_5fsolver_2flinear_5fsolver_2eproto_deps[1] = {
  &::descriptor_table_ortools_2futil_2foptional_5fboolean_2eproto,
};
static ::PROTOBUF_NAMESPACE_ID::internal::once_flag descriptor_table_ortools_2flinear_5fsolver_2flinear_5fsolver_2eproto_once;
const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_ortools_2flinear_5fsolver_2flinear_5fsolver_2eproto = {
  false, false, 5357, descriptor_table_protodef_ortools_2flinear_5fsolver_2flinear_5fsolver_2eproto, "ortools/linear_solver/linear_solver.proto", 
  &descriptor_table_ortools_2flinear_5fsolver_2flinear_5fsolver_2eproto_once, descriptor_table_ortools_2flinear_5fsolver_2flinear_5fsolver_2eproto_deps, 1, 21,
  schemas, file_default_instances, TableStruct_ortools_2flinear_5fsolver_2flinear_5fsolver_2eproto::offsets,
  file_level_metadata_ortools_2flinear_5fsolver_2flinear_5fsolver_2eproto, file_level_enum_descriptors_ortools_2flinear_5fsolver_2flinear_5fsolver_2eproto, file_level_service_descriptors_ortools_2flinear_5fsolver_2flinear_5fsolver_2eproto,
};
PROTOBUF_ATTRIBUTE_WEAK const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable* descriptor_table_ortools_2flinear_5fsolver_2flinear_5fsolver_2eproto_getter() {
  return &descriptor_table_ortools_2flinear_5fsolver_2flinear_5fsolver_2eproto;
}

// Force running AddDescriptors() at dynamic initialization time.
PROTOBUF_ATTRIBUTE_INIT_PRIORITY static ::PROTOBUF_NAMESPACE_ID::internal::AddDescriptorsRunner dynamic_init_dummy_ortools_2flinear_5fsolver_2flinear_5fsolver_2eproto(&descriptor_table_ortools_2flinear_5fsolver_2flinear_5fsolver_2eproto);
namespace operations_research {
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* MPSosConstraint_Type_descriptor() {
  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_ortools_2flinear_5fsolver_2flinear_5fsolver_2eproto);
  return file_level_enum_descriptors_ortools_2flinear_5fsolver_2flinear_5fsolver_2eproto[0];
}
bool MPSosConstraint_Type_IsValid(int value) {
  switch (value) {
    case 0:
    case 1:
      return true;
    default:
      return false;
  }
}

#if (__cplusplus < 201703) && (!defined(_MSC_VER) || _MSC_VER >= 1900)
constexpr MPSosConstraint_Type MPSosConstraint::SOS1_DEFAULT;
constexpr MPSosConstraint_Type MPSosConstraint::SOS2;
constexpr MPSosConstraint_Type MPSosConstraint::Type_MIN;
constexpr MPSosConstraint_Type MPSosConstraint::Type_MAX;
constexpr int MPSosConstraint::Type_ARRAYSIZE;
#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || _MSC_VER >= 1900)
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* MPSolverCommonParameters_LPAlgorithmValues_descriptor() {
  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_ortools_2flinear_5fsolver_2flinear_5fsolver_2eproto);
  return file_level_enum_descriptors_ortools_2flinear_5fsolver_2flinear_5fsolver_2eproto[1];
}
bool MPSolverCommonParameters_LPAlgorithmValues_IsValid(int value) {
  switch (value) {
    case 0:
    case 1:
    case 2:
    case 3:
      return true;
    default:
      return false;
  }
}

#if (__cplusplus < 201703) && (!defined(_MSC_VER) || _MSC_VER >= 1900)
constexpr MPSolverCommonParameters_LPAlgorithmValues MPSolverCommonParameters::LP_ALGO_UNSPECIFIED;
constexpr MPSolverCommonParameters_LPAlgorithmValues MPSolverCommonParameters::LP_ALGO_DUAL;
constexpr MPSolverCommonParameters_LPAlgorithmValues MPSolverCommonParameters::LP_ALGO_PRIMAL;
constexpr MPSolverCommonParameters_LPAlgorithmValues MPSolverCommonParameters::LP_ALGO_BARRIER;
constexpr MPSolverCommonParameters_LPAlgorithmValues MPSolverCommonParameters::LPAlgorithmValues_MIN;
constexpr MPSolverCommonParameters_LPAlgorithmValues MPSolverCommonParameters::LPAlgorithmValues_MAX;
constexpr int MPSolverCommonParameters::LPAlgorithmValues_ARRAYSIZE;
#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || _MSC_VER >= 1900)
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* MPModelRequest_SolverType_descriptor() {
  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_ortools_2flinear_5fsolver_2flinear_5fsolver_2eproto);
  return file_level_enum_descriptors_ortools_2flinear_5fsolver_2flinear_5fsolver_2eproto[2];
}
bool MPModelRequest_SolverType_IsValid(int value) {
  switch (value) {
    case 0:
    case 1:
    case 2:
    case 3:
    case 4:
    case 5:
    case 6:
    case 7:
    case 10:
    case 11:
    case 12:
    case 13:
    case 14:
    case 101:
    case 102:
      return true;
    default:
      return false;
  }
}

#if (__cplusplus < 201703) && (!defined(_MSC_VER) || _MSC_VER >= 1900)
constexpr MPModelRequest_SolverType MPModelRequest::GLOP_LINEAR_PROGRAMMING;
constexpr MPModelRequest_SolverType MPModelRequest::CLP_LINEAR_PROGRAMMING;
constexpr MPModelRequest_SolverType MPModelRequest::GLPK_LINEAR_PROGRAMMING;
constexpr MPModelRequest_SolverType MPModelRequest::GUROBI_LINEAR_PROGRAMMING;
constexpr MPModelRequest_SolverType MPModelRequest::XPRESS_LINEAR_PROGRAMMING;
constexpr MPModelRequest_SolverType MPModelRequest::CPLEX_LINEAR_PROGRAMMING;
constexpr MPModelRequest_SolverType MPModelRequest::SCIP_MIXED_INTEGER_PROGRAMMING;
constexpr MPModelRequest_SolverType MPModelRequest::GLPK_MIXED_INTEGER_PROGRAMMING;
constexpr MPModelRequest_SolverType MPModelRequest::CBC_MIXED_INTEGER_PROGRAMMING;
constexpr MPModelRequest_SolverType MPModelRequest::GUROBI_MIXED_INTEGER_PROGRAMMING;
constexpr MPModelRequest_SolverType MPModelRequest::XPRESS_MIXED_INTEGER_PROGRAMMING;
constexpr MPModelRequest_SolverType MPModelRequest::CPLEX_MIXED_INTEGER_PROGRAMMING;
constexpr MPModelRequest_SolverType MPModelRequest::BOP_INTEGER_PROGRAMMING;
constexpr MPModelRequest_SolverType MPModelRequest::SAT_INTEGER_PROGRAMMING;
constexpr MPModelRequest_SolverType MPModelRequest::KNAPSACK_MIXED_INTEGER_PROGRAMMING;
constexpr MPModelRequest_SolverType MPModelRequest::SolverType_MIN;
constexpr MPModelRequest_SolverType MPModelRequest::SolverType_MAX;
constexpr int MPModelRequest::SolverType_ARRAYSIZE;
#endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || _MSC_VER >= 1900)
const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* MPSolverResponseStatus_descriptor() {
  ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_ortools_2flinear_5fsolver_2flinear_5fsolver_2eproto);
  return file_level_enum_descriptors_ortools_2flinear_5fsolver_2flinear_5fsolver_2eproto[3];
}
bool MPSolverResponseStatus_IsValid(int value) {
  switch (value) {
    case 0:
    case 1:
    case 2:
    case 3:
    case 4:
    case 5:
    case 6:
    case 7:
    case 84:
    case 85:
    case 97:
    case 98:
    case 99:
    case 113:
      return true;
    default:
      return false;
  }
}


// ===================================================================

class MPVariableProto::_Internal {
 public:
  using HasBits = decltype(std::declval<MPVariableProto>()._has_bits_);
  static void set_has_lower_bound(HasBits* has_bits) {
    (*has_bits)[0] |= 16u;
  }
  static void set_has_upper_bound(HasBits* has_bits) {
    (*has_bits)[0] |= 32u;
  }
  static void set_has_objective_coefficient(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
  static void set_has_is_integer(HasBits* has_bits) {
    (*has_bits)[0] |= 4u;
  }
  static void set_has_name(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static void set_has_branching_priority(HasBits* has_bits) {
    (*has_bits)[0] |= 8u;
  }
};

MPVariableProto::MPVariableProto(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
  SharedCtor();
  if (!is_message_owned) {
    RegisterArenaDtor(arena);
  }
  // @@protoc_insertion_point(arena_constructor:operations_research.MPVariableProto)
}
MPVariableProto::MPVariableProto(const MPVariableProto& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from._internal_has_name()) {
    name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_name(), 
      GetArenaForAllocation());
  }
  ::memcpy(&objective_coefficient_, &from.objective_coefficient_,
    static_cast<size_t>(reinterpret_cast<char*>(&upper_bound_) -
    reinterpret_cast<char*>(&objective_coefficient_)) + sizeof(upper_bound_));
  // @@protoc_insertion_point(copy_constructor:operations_research.MPVariableProto)
}

inline void MPVariableProto::SharedCtor() {
name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
    reinterpret_cast<char*>(&objective_coefficient_) - reinterpret_cast<char*>(this)),
    0, static_cast<size_t>(reinterpret_cast<char*>(&branching_priority_) -
    reinterpret_cast<char*>(&objective_coefficient_)) + sizeof(branching_priority_));
lower_bound_ = -std::numeric_limits<double>::infinity();
upper_bound_ = std::numeric_limits<double>::infinity();
}

MPVariableProto::~MPVariableProto() {
  // @@protoc_insertion_point(destructor:operations_research.MPVariableProto)
  if (GetArenaForAllocation() != nullptr) return;
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

inline void MPVariableProto::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}

void MPVariableProto::ArenaDtor(void* object) {
  MPVariableProto* _this = reinterpret_cast< MPVariableProto* >(object);
  (void)_this;
}
void MPVariableProto::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void MPVariableProto::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void MPVariableProto::Clear() {
// @@protoc_insertion_point(message_clear_start:operations_research.MPVariableProto)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    name_.ClearNonDefaultToEmpty();
  }
  if (cached_has_bits & 0x0000003eu) {
    ::memset(&objective_coefficient_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&branching_priority_) -
        reinterpret_cast<char*>(&objective_coefficient_)) + sizeof(branching_priority_));
    lower_bound_ = -std::numeric_limits<double>::infinity();
    upper_bound_ = std::numeric_limits<double>::infinity();
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* MPVariableProto::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // optional double lower_bound = 1 [default = -inf];
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 9)) {
          _Internal::set_has_lower_bound(&has_bits);
          lower_bound_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<double>(ptr);
          ptr += sizeof(double);
        } else goto handle_unusual;
        continue;
      // optional double upper_bound = 2 [default = inf];
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 17)) {
          _Internal::set_has_upper_bound(&has_bits);
          upper_bound_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<double>(ptr);
          ptr += sizeof(double);
        } else goto handle_unusual;
        continue;
      // optional double objective_coefficient = 3 [default = 0];
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 25)) {
          _Internal::set_has_objective_coefficient(&has_bits);
          objective_coefficient_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<double>(ptr);
          ptr += sizeof(double);
        } else goto handle_unusual;
        continue;
      // optional bool is_integer = 4 [default = false];
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 32)) {
          _Internal::set_has_is_integer(&has_bits);
          is_integer_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional string name = 5 [default = ""];
      case 5:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 42)) {
          auto str = _internal_mutable_name();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          #ifndef NDEBUG
          ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "operations_research.MPVariableProto.name");
          #endif  // !NDEBUG
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional int32 branching_priority = 6 [default = 0];
      case 6:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 48)) {
          _Internal::set_has_branching_priority(&has_bits);
          branching_priority_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag == 0) || ((tag & 7) == 4)) {
          CHK_(ptr);
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag,
            _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
            ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* MPVariableProto::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:operations_research.MPVariableProto)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional double lower_bound = 1 [default = -inf];
  if (cached_has_bits & 0x00000010u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteDoubleToArray(1, this->_internal_lower_bound(), target);
  }

  // optional double upper_bound = 2 [default = inf];
  if (cached_has_bits & 0x00000020u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteDoubleToArray(2, this->_internal_upper_bound(), target);
  }

  // optional double objective_coefficient = 3 [default = 0];
  if (cached_has_bits & 0x00000002u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteDoubleToArray(3, this->_internal_objective_coefficient(), target);
  }

  // optional bool is_integer = 4 [default = false];
  if (cached_has_bits & 0x00000004u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(4, this->_internal_is_integer(), target);
  }

  // optional string name = 5 [default = ""];
  if (cached_has_bits & 0x00000001u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
      this->_internal_name().data(), static_cast<int>(this->_internal_name().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
      "operations_research.MPVariableProto.name");
    target = stream->WriteStringMaybeAliased(
        5, this->_internal_name(), target);
  }

  // optional int32 branching_priority = 6 [default = 0];
  if (cached_has_bits & 0x00000008u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(6, this->_internal_branching_priority(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:operations_research.MPVariableProto)
  return target;
}

size_t MPVariableProto::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:operations_research.MPVariableProto)
  size_t total_size = 0;

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x0000003fu) {
    // optional string name = 5 [default = ""];
    if (cached_has_bits & 0x00000001u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
          this->_internal_name());
    }

    // optional double objective_coefficient = 3 [default = 0];
    if (cached_has_bits & 0x00000002u) {
      total_size += 1 + 8;
    }

    // optional bool is_integer = 4 [default = false];
    if (cached_has_bits & 0x00000004u) {
      total_size += 1 + 1;
    }

    // optional int32 branching_priority = 6 [default = 0];
    if (cached_has_bits & 0x00000008u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
          this->_internal_branching_priority());
    }

    // optional double lower_bound = 1 [default = -inf];
    if (cached_has_bits & 0x00000010u) {
      total_size += 1 + 8;
    }

    // optional double upper_bound = 2 [default = inf];
    if (cached_has_bits & 0x00000020u) {
      total_size += 1 + 8;
    }

  }
  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize(
        _internal_metadata_, total_size, &_cached_size_);
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData MPVariableProto::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
    MPVariableProto::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*MPVariableProto::GetClassData() const { return &_class_data_; }

void MPVariableProto::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to,
                      const ::PROTOBUF_NAMESPACE_ID::Message&from) {
  static_cast<MPVariableProto *>(to)->MergeFrom(
      static_cast<const MPVariableProto &>(from));
}


void MPVariableProto::MergeFrom(const MPVariableProto& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:operations_research.MPVariableProto)
  GOOGLE_DCHECK_NE(&from, this);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 0x0000003fu) {
    if (cached_has_bits & 0x00000001u) {
      _internal_set_name(from._internal_name());
    }
    if (cached_has_bits & 0x00000002u) {
      objective_coefficient_ = from.objective_coefficient_;
    }
    if (cached_has_bits & 0x00000004u) {
      is_integer_ = from.is_integer_;
    }
    if (cached_has_bits & 0x00000008u) {
      branching_priority_ = from.branching_priority_;
    }
    if (cached_has_bits & 0x00000010u) {
      lower_bound_ = from.lower_bound_;
    }
    if (cached_has_bits & 0x00000020u) {
      upper_bound_ = from.upper_bound_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

void MPVariableProto::CopyFrom(const MPVariableProto& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:operations_research.MPVariableProto)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool MPVariableProto::IsInitialized() const {
  return true;
}

void MPVariableProto::InternalSwap(MPVariableProto* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
      &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      &name_, GetArenaForAllocation(),
      &other->name_, other->GetArenaForAllocation()
  );
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(MPVariableProto, branching_priority_)
      + sizeof(MPVariableProto::branching_priority_)
      - PROTOBUF_FIELD_OFFSET(MPVariableProto, objective_coefficient_)>(
          reinterpret_cast<char*>(&objective_coefficient_),
          reinterpret_cast<char*>(&other->objective_coefficient_));
  swap(lower_bound_, other->lower_bound_);
  swap(upper_bound_, other->upper_bound_);
}

::PROTOBUF_NAMESPACE_ID::Metadata MPVariableProto::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_ortools_2flinear_5fsolver_2flinear_5fsolver_2eproto_getter, &descriptor_table_ortools_2flinear_5fsolver_2flinear_5fsolver_2eproto_once,
      file_level_metadata_ortools_2flinear_5fsolver_2flinear_5fsolver_2eproto[0]);
}

// ===================================================================

class MPConstraintProto::_Internal {
 public:
  using HasBits = decltype(std::declval<MPConstraintProto>()._has_bits_);
  static void set_has_lower_bound(HasBits* has_bits) {
    (*has_bits)[0] |= 4u;
  }
  static void set_has_upper_bound(HasBits* has_bits) {
    (*has_bits)[0] |= 8u;
  }
  static void set_has_name(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static void set_has_is_lazy(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
};

MPConstraintProto::MPConstraintProto(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned),
  var_index_(arena),
  coefficient_(arena) {
  SharedCtor();
  if (!is_message_owned) {
    RegisterArenaDtor(arena);
  }
  // @@protoc_insertion_point(arena_constructor:operations_research.MPConstraintProto)
}
MPConstraintProto::MPConstraintProto(const MPConstraintProto& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _has_bits_(from._has_bits_),
      var_index_(from.var_index_),
      coefficient_(from.coefficient_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from._internal_has_name()) {
    name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_name(), 
      GetArenaForAllocation());
  }
  ::memcpy(&is_lazy_, &from.is_lazy_,
    static_cast<size_t>(reinterpret_cast<char*>(&upper_bound_) -
    reinterpret_cast<char*>(&is_lazy_)) + sizeof(upper_bound_));
  // @@protoc_insertion_point(copy_constructor:operations_research.MPConstraintProto)
}

inline void MPConstraintProto::SharedCtor() {
name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
is_lazy_ = false;
lower_bound_ = -std::numeric_limits<double>::infinity();
upper_bound_ = std::numeric_limits<double>::infinity();
}

MPConstraintProto::~MPConstraintProto() {
  // @@protoc_insertion_point(destructor:operations_research.MPConstraintProto)
  if (GetArenaForAllocation() != nullptr) return;
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

inline void MPConstraintProto::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}

void MPConstraintProto::ArenaDtor(void* object) {
  MPConstraintProto* _this = reinterpret_cast< MPConstraintProto* >(object);
  (void)_this;
}
void MPConstraintProto::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void MPConstraintProto::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void MPConstraintProto::Clear() {
// @@protoc_insertion_point(message_clear_start:operations_research.MPConstraintProto)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  var_index_.Clear();
  coefficient_.Clear();
  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    name_.ClearNonDefaultToEmpty();
  }
  if (cached_has_bits & 0x0000000eu) {
    is_lazy_ = false;
    lower_bound_ = -std::numeric_limits<double>::infinity();
    upper_bound_ = std::numeric_limits<double>::infinity();
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* MPConstraintProto::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // optional double lower_bound = 2 [default = -inf];
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 17)) {
          _Internal::set_has_lower_bound(&has_bits);
          lower_bound_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<double>(ptr);
          ptr += sizeof(double);
        } else goto handle_unusual;
        continue;
      // optional double upper_bound = 3 [default = inf];
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 25)) {
          _Internal::set_has_upper_bound(&has_bits);
          upper_bound_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<double>(ptr);
          ptr += sizeof(double);
        } else goto handle_unusual;
        continue;
      // optional string name = 4 [default = ""];
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) {
          auto str = _internal_mutable_name();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          #ifndef NDEBUG
          ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "operations_research.MPConstraintProto.name");
          #endif  // !NDEBUG
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional bool is_lazy = 5 [default = false];
      case 5:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 40)) {
          _Internal::set_has_is_lazy(&has_bits);
          is_lazy_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // repeated int32 var_index = 6 [packed = true];
      case 6:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 50)) {
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedInt32Parser(_internal_mutable_var_index(), ptr, ctx);
          CHK_(ptr);
        } else if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 48) {
          _internal_add_var_index(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr));
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // repeated double coefficient = 7 [packed = true];
      case 7:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 58)) {
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedDoubleParser(_internal_mutable_coefficient(), ptr, ctx);
          CHK_(ptr);
        } else if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 57) {
          _internal_add_coefficient(::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<double>(ptr));
          ptr += sizeof(double);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag == 0) || ((tag & 7) == 4)) {
          CHK_(ptr);
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag,
            _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
            ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* MPConstraintProto::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:operations_research.MPConstraintProto)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional double lower_bound = 2 [default = -inf];
  if (cached_has_bits & 0x00000004u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteDoubleToArray(2, this->_internal_lower_bound(), target);
  }

  // optional double upper_bound = 3 [default = inf];
  if (cached_has_bits & 0x00000008u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteDoubleToArray(3, this->_internal_upper_bound(), target);
  }

  // optional string name = 4 [default = ""];
  if (cached_has_bits & 0x00000001u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
      this->_internal_name().data(), static_cast<int>(this->_internal_name().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
      "operations_research.MPConstraintProto.name");
    target = stream->WriteStringMaybeAliased(
        4, this->_internal_name(), target);
  }

  // optional bool is_lazy = 5 [default = false];
  if (cached_has_bits & 0x00000002u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(5, this->_internal_is_lazy(), target);
  }

  // repeated int32 var_index = 6 [packed = true];
  {
    int byte_size = _var_index_cached_byte_size_.load(std::memory_order_relaxed);
    if (byte_size > 0) {
      target = stream->WriteInt32Packed(
          6, _internal_var_index(), byte_size, target);
    }
  }

  // repeated double coefficient = 7 [packed = true];
  if (this->_internal_coefficient_size() > 0) {
    target = stream->WriteFixedPacked(7, _internal_coefficient(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:operations_research.MPConstraintProto)
  return target;
}

size_t MPConstraintProto::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:operations_research.MPConstraintProto)
  size_t total_size = 0;

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // repeated int32 var_index = 6 [packed = true];
  {
    size_t data_size = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      Int32Size(this->var_index_);
    if (data_size > 0) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
            static_cast<::PROTOBUF_NAMESPACE_ID::int32>(data_size));
    }
    int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(data_size);
    _var_index_cached_byte_size_.store(cached_size,
                                    std::memory_order_relaxed);
    total_size += data_size;
  }

  // repeated double coefficient = 7 [packed = true];
  {
    unsigned int count = static_cast<unsigned int>(this->_internal_coefficient_size());
    size_t data_size = 8UL * count;
    if (data_size > 0) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
            static_cast<::PROTOBUF_NAMESPACE_ID::int32>(data_size));
    }
    total_size += data_size;
  }

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x0000000fu) {
    // optional string name = 4 [default = ""];
    if (cached_has_bits & 0x00000001u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
          this->_internal_name());
    }

    // optional bool is_lazy = 5 [default = false];
    if (cached_has_bits & 0x00000002u) {
      total_size += 1 + 1;
    }

    // optional double lower_bound = 2 [default = -inf];
    if (cached_has_bits & 0x00000004u) {
      total_size += 1 + 8;
    }

    // optional double upper_bound = 3 [default = inf];
    if (cached_has_bits & 0x00000008u) {
      total_size += 1 + 8;
    }

  }
  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize(
        _internal_metadata_, total_size, &_cached_size_);
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData MPConstraintProto::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
    MPConstraintProto::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*MPConstraintProto::GetClassData() const { return &_class_data_; }

void MPConstraintProto::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to,
                      const ::PROTOBUF_NAMESPACE_ID::Message&from) {
  static_cast<MPConstraintProto *>(to)->MergeFrom(
      static_cast<const MPConstraintProto &>(from));
}


void MPConstraintProto::MergeFrom(const MPConstraintProto& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:operations_research.MPConstraintProto)
  GOOGLE_DCHECK_NE(&from, this);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  var_index_.MergeFrom(from.var_index_);
  coefficient_.MergeFrom(from.coefficient_);
  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 0x0000000fu) {
    if (cached_has_bits & 0x00000001u) {
      _internal_set_name(from._internal_name());
    }
    if (cached_has_bits & 0x00000002u) {
      is_lazy_ = from.is_lazy_;
    }
    if (cached_has_bits & 0x00000004u) {
      lower_bound_ = from.lower_bound_;
    }
    if (cached_has_bits & 0x00000008u) {
      upper_bound_ = from.upper_bound_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

void MPConstraintProto::CopyFrom(const MPConstraintProto& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:operations_research.MPConstraintProto)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool MPConstraintProto::IsInitialized() const {
  return true;
}

void MPConstraintProto::InternalSwap(MPConstraintProto* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  var_index_.InternalSwap(&other->var_index_);
  coefficient_.InternalSwap(&other->coefficient_);
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
      &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      &name_, GetArenaForAllocation(),
      &other->name_, other->GetArenaForAllocation()
  );
  swap(is_lazy_, other->is_lazy_);
  swap(lower_bound_, other->lower_bound_);
  swap(upper_bound_, other->upper_bound_);
}

::PROTOBUF_NAMESPACE_ID::Metadata MPConstraintProto::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_ortools_2flinear_5fsolver_2flinear_5fsolver_2eproto_getter, &descriptor_table_ortools_2flinear_5fsolver_2flinear_5fsolver_2eproto_once,
      file_level_metadata_ortools_2flinear_5fsolver_2flinear_5fsolver_2eproto[1]);
}

// ===================================================================

class MPGeneralConstraintProto::_Internal {
 public:
  using HasBits = decltype(std::declval<MPGeneralConstraintProto>()._has_bits_);
  static void set_has_name(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static const ::operations_research::MPIndicatorConstraint& indicator_constraint(const MPGeneralConstraintProto* msg);
  static const ::operations_research::MPSosConstraint& sos_constraint(const MPGeneralConstraintProto* msg);
  static const ::operations_research::MPQuadraticConstraint& quadratic_constraint(const MPGeneralConstraintProto* msg);
  static const ::operations_research::MPAbsConstraint& abs_constraint(const MPGeneralConstraintProto* msg);
  static const ::operations_research::MPArrayConstraint& and_constraint(const MPGeneralConstraintProto* msg);
  static const ::operations_research::MPArrayConstraint& or_constraint(const MPGeneralConstraintProto* msg);
  static const ::operations_research::MPArrayWithConstantConstraint& min_constraint(const MPGeneralConstraintProto* msg);
  static const ::operations_research::MPArrayWithConstantConstraint& max_constraint(const MPGeneralConstraintProto* msg);
};

const ::operations_research::MPIndicatorConstraint&
MPGeneralConstraintProto::_Internal::indicator_constraint(const MPGeneralConstraintProto* msg) {
  return *msg->general_constraint_.indicator_constraint_;
}
const ::operations_research::MPSosConstraint&
MPGeneralConstraintProto::_Internal::sos_constraint(const MPGeneralConstraintProto* msg) {
  return *msg->general_constraint_.sos_constraint_;
}
const ::operations_research::MPQuadraticConstraint&
MPGeneralConstraintProto::_Internal::quadratic_constraint(const MPGeneralConstraintProto* msg) {
  return *msg->general_constraint_.quadratic_constraint_;
}
const ::operations_research::MPAbsConstraint&
MPGeneralConstraintProto::_Internal::abs_constraint(const MPGeneralConstraintProto* msg) {
  return *msg->general_constraint_.abs_constraint_;
}
const ::operations_research::MPArrayConstraint&
MPGeneralConstraintProto::_Internal::and_constraint(const MPGeneralConstraintProto* msg) {
  return *msg->general_constraint_.and_constraint_;
}
const ::operations_research::MPArrayConstraint&
MPGeneralConstraintProto::_Internal::or_constraint(const MPGeneralConstraintProto* msg) {
  return *msg->general_constraint_.or_constraint_;
}
const ::operations_research::MPArrayWithConstantConstraint&
MPGeneralConstraintProto::_Internal::min_constraint(const MPGeneralConstraintProto* msg) {
  return *msg->general_constraint_.min_constraint_;
}
const ::operations_research::MPArrayWithConstantConstraint&
MPGeneralConstraintProto::_Internal::max_constraint(const MPGeneralConstraintProto* msg) {
  return *msg->general_constraint_.max_constraint_;
}
void MPGeneralConstraintProto::set_allocated_indicator_constraint(::operations_research::MPIndicatorConstraint* indicator_constraint) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_general_constraint();
  if (indicator_constraint) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::operations_research::MPIndicatorConstraint>::GetOwningArena(indicator_constraint);
    if (message_arena != submessage_arena) {
      indicator_constraint = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, indicator_constraint, submessage_arena);
    }
    set_has_indicator_constraint();
    general_constraint_.indicator_constraint_ = indicator_constraint;
  }
  // @@protoc_insertion_point(field_set_allocated:operations_research.MPGeneralConstraintProto.indicator_constraint)
}
void MPGeneralConstraintProto::set_allocated_sos_constraint(::operations_research::MPSosConstraint* sos_constraint) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_general_constraint();
  if (sos_constraint) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::operations_research::MPSosConstraint>::GetOwningArena(sos_constraint);
    if (message_arena != submessage_arena) {
      sos_constraint = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, sos_constraint, submessage_arena);
    }
    set_has_sos_constraint();
    general_constraint_.sos_constraint_ = sos_constraint;
  }
  // @@protoc_insertion_point(field_set_allocated:operations_research.MPGeneralConstraintProto.sos_constraint)
}
void MPGeneralConstraintProto::set_allocated_quadratic_constraint(::operations_research::MPQuadraticConstraint* quadratic_constraint) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_general_constraint();
  if (quadratic_constraint) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::operations_research::MPQuadraticConstraint>::GetOwningArena(quadratic_constraint);
    if (message_arena != submessage_arena) {
      quadratic_constraint = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, quadratic_constraint, submessage_arena);
    }
    set_has_quadratic_constraint();
    general_constraint_.quadratic_constraint_ = quadratic_constraint;
  }
  // @@protoc_insertion_point(field_set_allocated:operations_research.MPGeneralConstraintProto.quadratic_constraint)
}
void MPGeneralConstraintProto::set_allocated_abs_constraint(::operations_research::MPAbsConstraint* abs_constraint) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_general_constraint();
  if (abs_constraint) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::operations_research::MPAbsConstraint>::GetOwningArena(abs_constraint);
    if (message_arena != submessage_arena) {
      abs_constraint = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, abs_constraint, submessage_arena);
    }
    set_has_abs_constraint();
    general_constraint_.abs_constraint_ = abs_constraint;
  }
  // @@protoc_insertion_point(field_set_allocated:operations_research.MPGeneralConstraintProto.abs_constraint)
}
void MPGeneralConstraintProto::set_allocated_and_constraint(::operations_research::MPArrayConstraint* and_constraint) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_general_constraint();
  if (and_constraint) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::operations_research::MPArrayConstraint>::GetOwningArena(and_constraint);
    if (message_arena != submessage_arena) {
      and_constraint = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, and_constraint, submessage_arena);
    }
    set_has_and_constraint();
    general_constraint_.and_constraint_ = and_constraint;
  }
  // @@protoc_insertion_point(field_set_allocated:operations_research.MPGeneralConstraintProto.and_constraint)
}
void MPGeneralConstraintProto::set_allocated_or_constraint(::operations_research::MPArrayConstraint* or_constraint) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_general_constraint();
  if (or_constraint) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::operations_research::MPArrayConstraint>::GetOwningArena(or_constraint);
    if (message_arena != submessage_arena) {
      or_constraint = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, or_constraint, submessage_arena);
    }
    set_has_or_constraint();
    general_constraint_.or_constraint_ = or_constraint;
  }
  // @@protoc_insertion_point(field_set_allocated:operations_research.MPGeneralConstraintProto.or_constraint)
}
void MPGeneralConstraintProto::set_allocated_min_constraint(::operations_research::MPArrayWithConstantConstraint* min_constraint) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_general_constraint();
  if (min_constraint) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::operations_research::MPArrayWithConstantConstraint>::GetOwningArena(min_constraint);
    if (message_arena != submessage_arena) {
      min_constraint = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, min_constraint, submessage_arena);
    }
    set_has_min_constraint();
    general_constraint_.min_constraint_ = min_constraint;
  }
  // @@protoc_insertion_point(field_set_allocated:operations_research.MPGeneralConstraintProto.min_constraint)
}
void MPGeneralConstraintProto::set_allocated_max_constraint(::operations_research::MPArrayWithConstantConstraint* max_constraint) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  clear_general_constraint();
  if (max_constraint) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
      ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::operations_research::MPArrayWithConstantConstraint>::GetOwningArena(max_constraint);
    if (message_arena != submessage_arena) {
      max_constraint = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, max_constraint, submessage_arena);
    }
    set_has_max_constraint();
    general_constraint_.max_constraint_ = max_constraint;
  }
  // @@protoc_insertion_point(field_set_allocated:operations_research.MPGeneralConstraintProto.max_constraint)
}
MPGeneralConstraintProto::MPGeneralConstraintProto(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
  SharedCtor();
  if (!is_message_owned) {
    RegisterArenaDtor(arena);
  }
  // @@protoc_insertion_point(arena_constructor:operations_research.MPGeneralConstraintProto)
}
MPGeneralConstraintProto::MPGeneralConstraintProto(const MPGeneralConstraintProto& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from._internal_has_name()) {
    name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_name(), 
      GetArenaForAllocation());
  }
  clear_has_general_constraint();
  switch (from.general_constraint_case()) {
    case kIndicatorConstraint: {
      _internal_mutable_indicator_constraint()->::operations_research::MPIndicatorConstraint::MergeFrom(from._internal_indicator_constraint());
      break;
    }
    case kSosConstraint: {
      _internal_mutable_sos_constraint()->::operations_research::MPSosConstraint::MergeFrom(from._internal_sos_constraint());
      break;
    }
    case kQuadraticConstraint: {
      _internal_mutable_quadratic_constraint()->::operations_research::MPQuadraticConstraint::MergeFrom(from._internal_quadratic_constraint());
      break;
    }
    case kAbsConstraint: {
      _internal_mutable_abs_constraint()->::operations_research::MPAbsConstraint::MergeFrom(from._internal_abs_constraint());
      break;
    }
    case kAndConstraint: {
      _internal_mutable_and_constraint()->::operations_research::MPArrayConstraint::MergeFrom(from._internal_and_constraint());
      break;
    }
    case kOrConstraint: {
      _internal_mutable_or_constraint()->::operations_research::MPArrayConstraint::MergeFrom(from._internal_or_constraint());
      break;
    }
    case kMinConstraint: {
      _internal_mutable_min_constraint()->::operations_research::MPArrayWithConstantConstraint::MergeFrom(from._internal_min_constraint());
      break;
    }
    case kMaxConstraint: {
      _internal_mutable_max_constraint()->::operations_research::MPArrayWithConstantConstraint::MergeFrom(from._internal_max_constraint());
      break;
    }
    case GENERAL_CONSTRAINT_NOT_SET: {
      break;
    }
  }
  // @@protoc_insertion_point(copy_constructor:operations_research.MPGeneralConstraintProto)
}

inline void MPGeneralConstraintProto::SharedCtor() {
name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
clear_has_general_constraint();
}

MPGeneralConstraintProto::~MPGeneralConstraintProto() {
  // @@protoc_insertion_point(destructor:operations_research.MPGeneralConstraintProto)
  if (GetArenaForAllocation() != nullptr) return;
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

inline void MPGeneralConstraintProto::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (has_general_constraint()) {
    clear_general_constraint();
  }
}

void MPGeneralConstraintProto::ArenaDtor(void* object) {
  MPGeneralConstraintProto* _this = reinterpret_cast< MPGeneralConstraintProto* >(object);
  (void)_this;
}
void MPGeneralConstraintProto::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void MPGeneralConstraintProto::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void MPGeneralConstraintProto::clear_general_constraint() {
// @@protoc_insertion_point(one_of_clear_start:operations_research.MPGeneralConstraintProto)
  switch (general_constraint_case()) {
    case kIndicatorConstraint: {
      if (GetArenaForAllocation() == nullptr) {
        delete general_constraint_.indicator_constraint_;
      }
      break;
    }
    case kSosConstraint: {
      if (GetArenaForAllocation() == nullptr) {
        delete general_constraint_.sos_constraint_;
      }
      break;
    }
    case kQuadraticConstraint: {
      if (GetArenaForAllocation() == nullptr) {
        delete general_constraint_.quadratic_constraint_;
      }
      break;
    }
    case kAbsConstraint: {
      if (GetArenaForAllocation() == nullptr) {
        delete general_constraint_.abs_constraint_;
      }
      break;
    }
    case kAndConstraint: {
      if (GetArenaForAllocation() == nullptr) {
        delete general_constraint_.and_constraint_;
      }
      break;
    }
    case kOrConstraint: {
      if (GetArenaForAllocation() == nullptr) {
        delete general_constraint_.or_constraint_;
      }
      break;
    }
    case kMinConstraint: {
      if (GetArenaForAllocation() == nullptr) {
        delete general_constraint_.min_constraint_;
      }
      break;
    }
    case kMaxConstraint: {
      if (GetArenaForAllocation() == nullptr) {
        delete general_constraint_.max_constraint_;
      }
      break;
    }
    case GENERAL_CONSTRAINT_NOT_SET: {
      break;
    }
  }
  _oneof_case_[0] = GENERAL_CONSTRAINT_NOT_SET;
}


void MPGeneralConstraintProto::Clear() {
// @@protoc_insertion_point(message_clear_start:operations_research.MPGeneralConstraintProto)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    name_.ClearNonDefaultToEmpty();
  }
  clear_general_constraint();
  _has_bits_.Clear();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* MPGeneralConstraintProto::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // optional string name = 1 [default = ""];
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
          auto str = _internal_mutable_name();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          #ifndef NDEBUG
          ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "operations_research.MPGeneralConstraintProto.name");
          #endif  // !NDEBUG
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // .operations_research.MPIndicatorConstraint indicator_constraint = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
          ptr = ctx->ParseMessage(_internal_mutable_indicator_constraint(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // .operations_research.MPSosConstraint sos_constraint = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) {
          ptr = ctx->ParseMessage(_internal_mutable_sos_constraint(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // .operations_research.MPQuadraticConstraint quadratic_constraint = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) {
          ptr = ctx->ParseMessage(_internal_mutable_quadratic_constraint(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // .operations_research.MPAbsConstraint abs_constraint = 5;
      case 5:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 42)) {
          ptr = ctx->ParseMessage(_internal_mutable_abs_constraint(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // .operations_research.MPArrayConstraint and_constraint = 6;
      case 6:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 50)) {
          ptr = ctx->ParseMessage(_internal_mutable_and_constraint(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // .operations_research.MPArrayConstraint or_constraint = 7;
      case 7:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 58)) {
          ptr = ctx->ParseMessage(_internal_mutable_or_constraint(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // .operations_research.MPArrayWithConstantConstraint min_constraint = 8;
      case 8:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 66)) {
          ptr = ctx->ParseMessage(_internal_mutable_min_constraint(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // .operations_research.MPArrayWithConstantConstraint max_constraint = 9;
      case 9:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 74)) {
          ptr = ctx->ParseMessage(_internal_mutable_max_constraint(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag == 0) || ((tag & 7) == 4)) {
          CHK_(ptr);
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag,
            _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
            ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* MPGeneralConstraintProto::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:operations_research.MPGeneralConstraintProto)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional string name = 1 [default = ""];
  if (cached_has_bits & 0x00000001u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
      this->_internal_name().data(), static_cast<int>(this->_internal_name().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
      "operations_research.MPGeneralConstraintProto.name");
    target = stream->WriteStringMaybeAliased(
        1, this->_internal_name(), target);
  }

  switch (general_constraint_case()) {
    case kIndicatorConstraint: {
      target = stream->EnsureSpace(target);
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(
          2, _Internal::indicator_constraint(this), target, stream);
      break;
    }
    case kSosConstraint: {
      target = stream->EnsureSpace(target);
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(
          3, _Internal::sos_constraint(this), target, stream);
      break;
    }
    case kQuadraticConstraint: {
      target = stream->EnsureSpace(target);
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(
          4, _Internal::quadratic_constraint(this), target, stream);
      break;
    }
    case kAbsConstraint: {
      target = stream->EnsureSpace(target);
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(
          5, _Internal::abs_constraint(this), target, stream);
      break;
    }
    case kAndConstraint: {
      target = stream->EnsureSpace(target);
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(
          6, _Internal::and_constraint(this), target, stream);
      break;
    }
    case kOrConstraint: {
      target = stream->EnsureSpace(target);
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(
          7, _Internal::or_constraint(this), target, stream);
      break;
    }
    case kMinConstraint: {
      target = stream->EnsureSpace(target);
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(
          8, _Internal::min_constraint(this), target, stream);
      break;
    }
    case kMaxConstraint: {
      target = stream->EnsureSpace(target);
      target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
        InternalWriteMessage(
          9, _Internal::max_constraint(this), target, stream);
      break;
    }
    default: ;
  }
  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:operations_research.MPGeneralConstraintProto)
  return target;
}

size_t MPGeneralConstraintProto::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:operations_research.MPGeneralConstraintProto)
  size_t total_size = 0;

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // optional string name = 1 [default = ""];
  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
        this->_internal_name());
  }

  switch (general_constraint_case()) {
    // .operations_research.MPIndicatorConstraint indicator_constraint = 2;
    case kIndicatorConstraint: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *general_constraint_.indicator_constraint_);
      break;
    }
    // .operations_research.MPSosConstraint sos_constraint = 3;
    case kSosConstraint: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *general_constraint_.sos_constraint_);
      break;
    }
    // .operations_research.MPQuadraticConstraint quadratic_constraint = 4;
    case kQuadraticConstraint: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *general_constraint_.quadratic_constraint_);
      break;
    }
    // .operations_research.MPAbsConstraint abs_constraint = 5;
    case kAbsConstraint: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *general_constraint_.abs_constraint_);
      break;
    }
    // .operations_research.MPArrayConstraint and_constraint = 6;
    case kAndConstraint: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *general_constraint_.and_constraint_);
      break;
    }
    // .operations_research.MPArrayConstraint or_constraint = 7;
    case kOrConstraint: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *general_constraint_.or_constraint_);
      break;
    }
    // .operations_research.MPArrayWithConstantConstraint min_constraint = 8;
    case kMinConstraint: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *general_constraint_.min_constraint_);
      break;
    }
    // .operations_research.MPArrayWithConstantConstraint max_constraint = 9;
    case kMaxConstraint: {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *general_constraint_.max_constraint_);
      break;
    }
    case GENERAL_CONSTRAINT_NOT_SET: {
      break;
    }
  }
  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize(
        _internal_metadata_, total_size, &_cached_size_);
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData MPGeneralConstraintProto::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
    MPGeneralConstraintProto::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*MPGeneralConstraintProto::GetClassData() const { return &_class_data_; }

void MPGeneralConstraintProto::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to,
                      const ::PROTOBUF_NAMESPACE_ID::Message&from) {
  static_cast<MPGeneralConstraintProto *>(to)->MergeFrom(
      static_cast<const MPGeneralConstraintProto &>(from));
}


void MPGeneralConstraintProto::MergeFrom(const MPGeneralConstraintProto& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:operations_research.MPGeneralConstraintProto)
  GOOGLE_DCHECK_NE(&from, this);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  if (from._internal_has_name()) {
    _internal_set_name(from._internal_name());
  }
  switch (from.general_constraint_case()) {
    case kIndicatorConstraint: {
      _internal_mutable_indicator_constraint()->::operations_research::MPIndicatorConstraint::MergeFrom(from._internal_indicator_constraint());
      break;
    }
    case kSosConstraint: {
      _internal_mutable_sos_constraint()->::operations_research::MPSosConstraint::MergeFrom(from._internal_sos_constraint());
      break;
    }
    case kQuadraticConstraint: {
      _internal_mutable_quadratic_constraint()->::operations_research::MPQuadraticConstraint::MergeFrom(from._internal_quadratic_constraint());
      break;
    }
    case kAbsConstraint: {
      _internal_mutable_abs_constraint()->::operations_research::MPAbsConstraint::MergeFrom(from._internal_abs_constraint());
      break;
    }
    case kAndConstraint: {
      _internal_mutable_and_constraint()->::operations_research::MPArrayConstraint::MergeFrom(from._internal_and_constraint());
      break;
    }
    case kOrConstraint: {
      _internal_mutable_or_constraint()->::operations_research::MPArrayConstraint::MergeFrom(from._internal_or_constraint());
      break;
    }
    case kMinConstraint: {
      _internal_mutable_min_constraint()->::operations_research::MPArrayWithConstantConstraint::MergeFrom(from._internal_min_constraint());
      break;
    }
    case kMaxConstraint: {
      _internal_mutable_max_constraint()->::operations_research::MPArrayWithConstantConstraint::MergeFrom(from._internal_max_constraint());
      break;
    }
    case GENERAL_CONSTRAINT_NOT_SET: {
      break;
    }
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

void MPGeneralConstraintProto::CopyFrom(const MPGeneralConstraintProto& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:operations_research.MPGeneralConstraintProto)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool MPGeneralConstraintProto::IsInitialized() const {
  return true;
}

void MPGeneralConstraintProto::InternalSwap(MPGeneralConstraintProto* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
      &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      &name_, GetArenaForAllocation(),
      &other->name_, other->GetArenaForAllocation()
  );
  swap(general_constraint_, other->general_constraint_);
  swap(_oneof_case_[0], other->_oneof_case_[0]);
}

::PROTOBUF_NAMESPACE_ID::Metadata MPGeneralConstraintProto::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_ortools_2flinear_5fsolver_2flinear_5fsolver_2eproto_getter, &descriptor_table_ortools_2flinear_5fsolver_2flinear_5fsolver_2eproto_once,
      file_level_metadata_ortools_2flinear_5fsolver_2flinear_5fsolver_2eproto[2]);
}

// ===================================================================

class MPIndicatorConstraint::_Internal {
 public:
  using HasBits = decltype(std::declval<MPIndicatorConstraint>()._has_bits_);
  static void set_has_var_index(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
  static void set_has_var_value(HasBits* has_bits) {
    (*has_bits)[0] |= 4u;
  }
  static const ::operations_research::MPConstraintProto& constraint(const MPIndicatorConstraint* msg);
  static void set_has_constraint(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
};

const ::operations_research::MPConstraintProto&
MPIndicatorConstraint::_Internal::constraint(const MPIndicatorConstraint* msg) {
  return *msg->constraint_;
}
MPIndicatorConstraint::MPIndicatorConstraint(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
  SharedCtor();
  if (!is_message_owned) {
    RegisterArenaDtor(arena);
  }
  // @@protoc_insertion_point(arena_constructor:operations_research.MPIndicatorConstraint)
}
MPIndicatorConstraint::MPIndicatorConstraint(const MPIndicatorConstraint& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  if (from._internal_has_constraint()) {
    constraint_ = new ::operations_research::MPConstraintProto(*from.constraint_);
  } else {
    constraint_ = nullptr;
  }
  ::memcpy(&var_index_, &from.var_index_,
    static_cast<size_t>(reinterpret_cast<char*>(&var_value_) -
    reinterpret_cast<char*>(&var_index_)) + sizeof(var_value_));
  // @@protoc_insertion_point(copy_constructor:operations_research.MPIndicatorConstraint)
}

inline void MPIndicatorConstraint::SharedCtor() {
::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
    reinterpret_cast<char*>(&constraint_) - reinterpret_cast<char*>(this)),
    0, static_cast<size_t>(reinterpret_cast<char*>(&var_value_) -
    reinterpret_cast<char*>(&constraint_)) + sizeof(var_value_));
}

MPIndicatorConstraint::~MPIndicatorConstraint() {
  // @@protoc_insertion_point(destructor:operations_research.MPIndicatorConstraint)
  if (GetArenaForAllocation() != nullptr) return;
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

inline void MPIndicatorConstraint::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  if (this != internal_default_instance()) delete constraint_;
}

void MPIndicatorConstraint::ArenaDtor(void* object) {
  MPIndicatorConstraint* _this = reinterpret_cast< MPIndicatorConstraint* >(object);
  (void)_this;
}
void MPIndicatorConstraint::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void MPIndicatorConstraint::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void MPIndicatorConstraint::Clear() {
// @@protoc_insertion_point(message_clear_start:operations_research.MPIndicatorConstraint)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    GOOGLE_DCHECK(constraint_ != nullptr);
    constraint_->Clear();
  }
  if (cached_has_bits & 0x00000006u) {
    ::memset(&var_index_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&var_value_) -
        reinterpret_cast<char*>(&var_index_)) + sizeof(var_value_));
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* MPIndicatorConstraint::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // optional int32 var_index = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          _Internal::set_has_var_index(&has_bits);
          var_index_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional int32 var_value = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
          _Internal::set_has_var_value(&has_bits);
          var_value_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .operations_research.MPConstraintProto constraint = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) {
          ptr = ctx->ParseMessage(_internal_mutable_constraint(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag == 0) || ((tag & 7) == 4)) {
          CHK_(ptr);
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag,
            _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
            ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* MPIndicatorConstraint::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:operations_research.MPIndicatorConstraint)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional int32 var_index = 1;
  if (cached_has_bits & 0x00000002u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(1, this->_internal_var_index(), target);
  }

  // optional int32 var_value = 2;
  if (cached_has_bits & 0x00000004u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(2, this->_internal_var_value(), target);
  }

  // optional .operations_research.MPConstraintProto constraint = 3;
  if (cached_has_bits & 0x00000001u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        3, _Internal::constraint(this), target, stream);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:operations_research.MPIndicatorConstraint)
  return target;
}

size_t MPIndicatorConstraint::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:operations_research.MPIndicatorConstraint)
  size_t total_size = 0;

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000007u) {
    // optional .operations_research.MPConstraintProto constraint = 3;
    if (cached_has_bits & 0x00000001u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *constraint_);
    }

    // optional int32 var_index = 1;
    if (cached_has_bits & 0x00000002u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
          this->_internal_var_index());
    }

    // optional int32 var_value = 2;
    if (cached_has_bits & 0x00000004u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
          this->_internal_var_value());
    }

  }
  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize(
        _internal_metadata_, total_size, &_cached_size_);
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData MPIndicatorConstraint::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
    MPIndicatorConstraint::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*MPIndicatorConstraint::GetClassData() const { return &_class_data_; }

void MPIndicatorConstraint::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to,
                      const ::PROTOBUF_NAMESPACE_ID::Message&from) {
  static_cast<MPIndicatorConstraint *>(to)->MergeFrom(
      static_cast<const MPIndicatorConstraint &>(from));
}


void MPIndicatorConstraint::MergeFrom(const MPIndicatorConstraint& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:operations_research.MPIndicatorConstraint)
  GOOGLE_DCHECK_NE(&from, this);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 0x00000007u) {
    if (cached_has_bits & 0x00000001u) {
      _internal_mutable_constraint()->::operations_research::MPConstraintProto::MergeFrom(from._internal_constraint());
    }
    if (cached_has_bits & 0x00000002u) {
      var_index_ = from.var_index_;
    }
    if (cached_has_bits & 0x00000004u) {
      var_value_ = from.var_value_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

void MPIndicatorConstraint::CopyFrom(const MPIndicatorConstraint& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:operations_research.MPIndicatorConstraint)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool MPIndicatorConstraint::IsInitialized() const {
  return true;
}

void MPIndicatorConstraint::InternalSwap(MPIndicatorConstraint* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(MPIndicatorConstraint, var_value_)
      + sizeof(MPIndicatorConstraint::var_value_)
      - PROTOBUF_FIELD_OFFSET(MPIndicatorConstraint, constraint_)>(
          reinterpret_cast<char*>(&constraint_),
          reinterpret_cast<char*>(&other->constraint_));
}

::PROTOBUF_NAMESPACE_ID::Metadata MPIndicatorConstraint::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_ortools_2flinear_5fsolver_2flinear_5fsolver_2eproto_getter, &descriptor_table_ortools_2flinear_5fsolver_2flinear_5fsolver_2eproto_once,
      file_level_metadata_ortools_2flinear_5fsolver_2flinear_5fsolver_2eproto[3]);
}

// ===================================================================

class MPSosConstraint::_Internal {
 public:
  using HasBits = decltype(std::declval<MPSosConstraint>()._has_bits_);
  static void set_has_type(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
};

MPSosConstraint::MPSosConstraint(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned),
  var_index_(arena),
  weight_(arena) {
  SharedCtor();
  if (!is_message_owned) {
    RegisterArenaDtor(arena);
  }
  // @@protoc_insertion_point(arena_constructor:operations_research.MPSosConstraint)
}
MPSosConstraint::MPSosConstraint(const MPSosConstraint& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _has_bits_(from._has_bits_),
      var_index_(from.var_index_),
      weight_(from.weight_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  type_ = from.type_;
  // @@protoc_insertion_point(copy_constructor:operations_research.MPSosConstraint)
}

inline void MPSosConstraint::SharedCtor() {
type_ = 0;
}

MPSosConstraint::~MPSosConstraint() {
  // @@protoc_insertion_point(destructor:operations_research.MPSosConstraint)
  if (GetArenaForAllocation() != nullptr) return;
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

inline void MPSosConstraint::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
}

void MPSosConstraint::ArenaDtor(void* object) {
  MPSosConstraint* _this = reinterpret_cast< MPSosConstraint* >(object);
  (void)_this;
}
void MPSosConstraint::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void MPSosConstraint::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void MPSosConstraint::Clear() {
// @@protoc_insertion_point(message_clear_start:operations_research.MPSosConstraint)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  var_index_.Clear();
  weight_.Clear();
  type_ = 0;
  _has_bits_.Clear();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* MPSosConstraint::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // optional .operations_research.MPSosConstraint.Type type = 1 [default = SOS1_DEFAULT];
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
          if (PROTOBUF_PREDICT_TRUE(::operations_research::MPSosConstraint_Type_IsValid(val))) {
            _internal_set_type(static_cast<::operations_research::MPSosConstraint_Type>(val));
          } else {
            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(1, val, mutable_unknown_fields());
          }
        } else goto handle_unusual;
        continue;
      // repeated int32 var_index = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
          ptr -= 1;
          do {
            ptr += 1;
            _internal_add_var_index(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr));
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<16>(ptr));
        } else if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18) {
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedInt32Parser(_internal_mutable_var_index(), ptr, ctx);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // repeated double weight = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 25)) {
          ptr -= 1;
          do {
            ptr += 1;
            _internal_add_weight(::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<double>(ptr));
            ptr += sizeof(double);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<25>(ptr));
        } else if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26) {
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedDoubleParser(_internal_mutable_weight(), ptr, ctx);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag == 0) || ((tag & 7) == 4)) {
          CHK_(ptr);
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag,
            _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
            ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* MPSosConstraint::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:operations_research.MPSosConstraint)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional .operations_research.MPSosConstraint.Type type = 1 [default = SOS1_DEFAULT];
  if (cached_has_bits & 0x00000001u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
      1, this->_internal_type(), target);
  }

  // repeated int32 var_index = 2;
  for (int i = 0, n = this->_internal_var_index_size(); i < n; i++) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(2, this->_internal_var_index(i), target);
  }

  // repeated double weight = 3;
  for (int i = 0, n = this->_internal_weight_size(); i < n; i++) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteDoubleToArray(3, this->_internal_weight(i), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:operations_research.MPSosConstraint)
  return target;
}

size_t MPSosConstraint::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:operations_research.MPSosConstraint)
  size_t total_size = 0;

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // repeated int32 var_index = 2;
  {
    size_t data_size = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      Int32Size(this->var_index_);
    total_size += 1 *
                  ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->_internal_var_index_size());
    total_size += data_size;
  }

  // repeated double weight = 3;
  {
    unsigned int count = static_cast<unsigned int>(this->_internal_weight_size());
    size_t data_size = 8UL * count;
    total_size += 1 *
                  ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->_internal_weight_size());
    total_size += data_size;
  }

  // optional .operations_research.MPSosConstraint.Type type = 1 [default = SOS1_DEFAULT];
  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_type());
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize(
        _internal_metadata_, total_size, &_cached_size_);
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData MPSosConstraint::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
    MPSosConstraint::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*MPSosConstraint::GetClassData() const { return &_class_data_; }

void MPSosConstraint::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to,
                      const ::PROTOBUF_NAMESPACE_ID::Message&from) {
  static_cast<MPSosConstraint *>(to)->MergeFrom(
      static_cast<const MPSosConstraint &>(from));
}


void MPSosConstraint::MergeFrom(const MPSosConstraint& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:operations_research.MPSosConstraint)
  GOOGLE_DCHECK_NE(&from, this);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  var_index_.MergeFrom(from.var_index_);
  weight_.MergeFrom(from.weight_);
  if (from._internal_has_type()) {
    _internal_set_type(from._internal_type());
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

void MPSosConstraint::CopyFrom(const MPSosConstraint& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:operations_research.MPSosConstraint)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool MPSosConstraint::IsInitialized() const {
  return true;
}

void MPSosConstraint::InternalSwap(MPSosConstraint* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  var_index_.InternalSwap(&other->var_index_);
  weight_.InternalSwap(&other->weight_);
  swap(type_, other->type_);
}

::PROTOBUF_NAMESPACE_ID::Metadata MPSosConstraint::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_ortools_2flinear_5fsolver_2flinear_5fsolver_2eproto_getter, &descriptor_table_ortools_2flinear_5fsolver_2flinear_5fsolver_2eproto_once,
      file_level_metadata_ortools_2flinear_5fsolver_2flinear_5fsolver_2eproto[4]);
}

// ===================================================================

class MPQuadraticConstraint::_Internal {
 public:
  using HasBits = decltype(std::declval<MPQuadraticConstraint>()._has_bits_);
  static void set_has_lower_bound(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static void set_has_upper_bound(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
};

MPQuadraticConstraint::MPQuadraticConstraint(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned),
  var_index_(arena),
  coefficient_(arena),
  qvar1_index_(arena),
  qvar2_index_(arena),
  qcoefficient_(arena) {
  SharedCtor();
  if (!is_message_owned) {
    RegisterArenaDtor(arena);
  }
  // @@protoc_insertion_point(arena_constructor:operations_research.MPQuadraticConstraint)
}
MPQuadraticConstraint::MPQuadraticConstraint(const MPQuadraticConstraint& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _has_bits_(from._has_bits_),
      var_index_(from.var_index_),
      coefficient_(from.coefficient_),
      qvar1_index_(from.qvar1_index_),
      qvar2_index_(from.qvar2_index_),
      qcoefficient_(from.qcoefficient_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  ::memcpy(&lower_bound_, &from.lower_bound_,
    static_cast<size_t>(reinterpret_cast<char*>(&upper_bound_) -
    reinterpret_cast<char*>(&lower_bound_)) + sizeof(upper_bound_));
  // @@protoc_insertion_point(copy_constructor:operations_research.MPQuadraticConstraint)
}

inline void MPQuadraticConstraint::SharedCtor() {
lower_bound_ = -std::numeric_limits<double>::infinity();
upper_bound_ = std::numeric_limits<double>::infinity();
}

MPQuadraticConstraint::~MPQuadraticConstraint() {
  // @@protoc_insertion_point(destructor:operations_research.MPQuadraticConstraint)
  if (GetArenaForAllocation() != nullptr) return;
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

inline void MPQuadraticConstraint::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
}

void MPQuadraticConstraint::ArenaDtor(void* object) {
  MPQuadraticConstraint* _this = reinterpret_cast< MPQuadraticConstraint* >(object);
  (void)_this;
}
void MPQuadraticConstraint::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void MPQuadraticConstraint::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void MPQuadraticConstraint::Clear() {
// @@protoc_insertion_point(message_clear_start:operations_research.MPQuadraticConstraint)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  var_index_.Clear();
  coefficient_.Clear();
  qvar1_index_.Clear();
  qvar2_index_.Clear();
  qcoefficient_.Clear();
  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    lower_bound_ = -std::numeric_limits<double>::infinity();
    upper_bound_ = std::numeric_limits<double>::infinity();
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* MPQuadraticConstraint::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // repeated int32 var_index = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          ptr -= 1;
          do {
            ptr += 1;
            _internal_add_var_index(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr));
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<8>(ptr));
        } else if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10) {
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedInt32Parser(_internal_mutable_var_index(), ptr, ctx);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // repeated double coefficient = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 17)) {
          ptr -= 1;
          do {
            ptr += 1;
            _internal_add_coefficient(::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<double>(ptr));
            ptr += sizeof(double);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<17>(ptr));
        } else if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18) {
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedDoubleParser(_internal_mutable_coefficient(), ptr, ctx);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // repeated int32 qvar1_index = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) {
          ptr -= 1;
          do {
            ptr += 1;
            _internal_add_qvar1_index(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr));
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<24>(ptr));
        } else if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26) {
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedInt32Parser(_internal_mutable_qvar1_index(), ptr, ctx);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // repeated int32 qvar2_index = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 32)) {
          ptr -= 1;
          do {
            ptr += 1;
            _internal_add_qvar2_index(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr));
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<32>(ptr));
        } else if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34) {
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedInt32Parser(_internal_mutable_qvar2_index(), ptr, ctx);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // repeated double qcoefficient = 5;
      case 5:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 41)) {
          ptr -= 1;
          do {
            ptr += 1;
            _internal_add_qcoefficient(::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<double>(ptr));
            ptr += sizeof(double);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<41>(ptr));
        } else if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 42) {
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedDoubleParser(_internal_mutable_qcoefficient(), ptr, ctx);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional double lower_bound = 6 [default = -inf];
      case 6:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 49)) {
          _Internal::set_has_lower_bound(&has_bits);
          lower_bound_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<double>(ptr);
          ptr += sizeof(double);
        } else goto handle_unusual;
        continue;
      // optional double upper_bound = 7 [default = inf];
      case 7:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 57)) {
          _Internal::set_has_upper_bound(&has_bits);
          upper_bound_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<double>(ptr);
          ptr += sizeof(double);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag == 0) || ((tag & 7) == 4)) {
          CHK_(ptr);
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag,
            _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
            ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* MPQuadraticConstraint::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:operations_research.MPQuadraticConstraint)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // repeated int32 var_index = 1;
  for (int i = 0, n = this->_internal_var_index_size(); i < n; i++) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(1, this->_internal_var_index(i), target);
  }

  // repeated double coefficient = 2;
  for (int i = 0, n = this->_internal_coefficient_size(); i < n; i++) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteDoubleToArray(2, this->_internal_coefficient(i), target);
  }

  // repeated int32 qvar1_index = 3;
  for (int i = 0, n = this->_internal_qvar1_index_size(); i < n; i++) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(3, this->_internal_qvar1_index(i), target);
  }

  // repeated int32 qvar2_index = 4;
  for (int i = 0, n = this->_internal_qvar2_index_size(); i < n; i++) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(4, this->_internal_qvar2_index(i), target);
  }

  // repeated double qcoefficient = 5;
  for (int i = 0, n = this->_internal_qcoefficient_size(); i < n; i++) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteDoubleToArray(5, this->_internal_qcoefficient(i), target);
  }

  cached_has_bits = _has_bits_[0];
  // optional double lower_bound = 6 [default = -inf];
  if (cached_has_bits & 0x00000001u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteDoubleToArray(6, this->_internal_lower_bound(), target);
  }

  // optional double upper_bound = 7 [default = inf];
  if (cached_has_bits & 0x00000002u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteDoubleToArray(7, this->_internal_upper_bound(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:operations_research.MPQuadraticConstraint)
  return target;
}

size_t MPQuadraticConstraint::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:operations_research.MPQuadraticConstraint)
  size_t total_size = 0;

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // repeated int32 var_index = 1;
  {
    size_t data_size = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      Int32Size(this->var_index_);
    total_size += 1 *
                  ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->_internal_var_index_size());
    total_size += data_size;
  }

  // repeated double coefficient = 2;
  {
    unsigned int count = static_cast<unsigned int>(this->_internal_coefficient_size());
    size_t data_size = 8UL * count;
    total_size += 1 *
                  ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->_internal_coefficient_size());
    total_size += data_size;
  }

  // repeated int32 qvar1_index = 3;
  {
    size_t data_size = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      Int32Size(this->qvar1_index_);
    total_size += 1 *
                  ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->_internal_qvar1_index_size());
    total_size += data_size;
  }

  // repeated int32 qvar2_index = 4;
  {
    size_t data_size = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      Int32Size(this->qvar2_index_);
    total_size += 1 *
                  ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->_internal_qvar2_index_size());
    total_size += data_size;
  }

  // repeated double qcoefficient = 5;
  {
    unsigned int count = static_cast<unsigned int>(this->_internal_qcoefficient_size());
    size_t data_size = 8UL * count;
    total_size += 1 *
                  ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->_internal_qcoefficient_size());
    total_size += data_size;
  }

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    // optional double lower_bound = 6 [default = -inf];
    if (cached_has_bits & 0x00000001u) {
      total_size += 1 + 8;
    }

    // optional double upper_bound = 7 [default = inf];
    if (cached_has_bits & 0x00000002u) {
      total_size += 1 + 8;
    }

  }
  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize(
        _internal_metadata_, total_size, &_cached_size_);
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData MPQuadraticConstraint::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
    MPQuadraticConstraint::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*MPQuadraticConstraint::GetClassData() const { return &_class_data_; }

void MPQuadraticConstraint::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to,
                      const ::PROTOBUF_NAMESPACE_ID::Message&from) {
  static_cast<MPQuadraticConstraint *>(to)->MergeFrom(
      static_cast<const MPQuadraticConstraint &>(from));
}


void MPQuadraticConstraint::MergeFrom(const MPQuadraticConstraint& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:operations_research.MPQuadraticConstraint)
  GOOGLE_DCHECK_NE(&from, this);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  var_index_.MergeFrom(from.var_index_);
  coefficient_.MergeFrom(from.coefficient_);
  qvar1_index_.MergeFrom(from.qvar1_index_);
  qvar2_index_.MergeFrom(from.qvar2_index_);
  qcoefficient_.MergeFrom(from.qcoefficient_);
  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    if (cached_has_bits & 0x00000001u) {
      lower_bound_ = from.lower_bound_;
    }
    if (cached_has_bits & 0x00000002u) {
      upper_bound_ = from.upper_bound_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

void MPQuadraticConstraint::CopyFrom(const MPQuadraticConstraint& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:operations_research.MPQuadraticConstraint)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool MPQuadraticConstraint::IsInitialized() const {
  return true;
}

void MPQuadraticConstraint::InternalSwap(MPQuadraticConstraint* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  var_index_.InternalSwap(&other->var_index_);
  coefficient_.InternalSwap(&other->coefficient_);
  qvar1_index_.InternalSwap(&other->qvar1_index_);
  qvar2_index_.InternalSwap(&other->qvar2_index_);
  qcoefficient_.InternalSwap(&other->qcoefficient_);
  swap(lower_bound_, other->lower_bound_);
  swap(upper_bound_, other->upper_bound_);
}

::PROTOBUF_NAMESPACE_ID::Metadata MPQuadraticConstraint::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_ortools_2flinear_5fsolver_2flinear_5fsolver_2eproto_getter, &descriptor_table_ortools_2flinear_5fsolver_2flinear_5fsolver_2eproto_once,
      file_level_metadata_ortools_2flinear_5fsolver_2flinear_5fsolver_2eproto[5]);
}

// ===================================================================

class MPAbsConstraint::_Internal {
 public:
  using HasBits = decltype(std::declval<MPAbsConstraint>()._has_bits_);
  static void set_has_var_index(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static void set_has_resultant_var_index(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
};

MPAbsConstraint::MPAbsConstraint(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
  SharedCtor();
  if (!is_message_owned) {
    RegisterArenaDtor(arena);
  }
  // @@protoc_insertion_point(arena_constructor:operations_research.MPAbsConstraint)
}
MPAbsConstraint::MPAbsConstraint(const MPAbsConstraint& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  ::memcpy(&var_index_, &from.var_index_,
    static_cast<size_t>(reinterpret_cast<char*>(&resultant_var_index_) -
    reinterpret_cast<char*>(&var_index_)) + sizeof(resultant_var_index_));
  // @@protoc_insertion_point(copy_constructor:operations_research.MPAbsConstraint)
}

inline void MPAbsConstraint::SharedCtor() {
::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
    reinterpret_cast<char*>(&var_index_) - reinterpret_cast<char*>(this)),
    0, static_cast<size_t>(reinterpret_cast<char*>(&resultant_var_index_) -
    reinterpret_cast<char*>(&var_index_)) + sizeof(resultant_var_index_));
}

MPAbsConstraint::~MPAbsConstraint() {
  // @@protoc_insertion_point(destructor:operations_research.MPAbsConstraint)
  if (GetArenaForAllocation() != nullptr) return;
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

inline void MPAbsConstraint::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
}

void MPAbsConstraint::ArenaDtor(void* object) {
  MPAbsConstraint* _this = reinterpret_cast< MPAbsConstraint* >(object);
  (void)_this;
}
void MPAbsConstraint::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void MPAbsConstraint::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void MPAbsConstraint::Clear() {
// @@protoc_insertion_point(message_clear_start:operations_research.MPAbsConstraint)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    ::memset(&var_index_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&resultant_var_index_) -
        reinterpret_cast<char*>(&var_index_)) + sizeof(resultant_var_index_));
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* MPAbsConstraint::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // optional int32 var_index = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          _Internal::set_has_var_index(&has_bits);
          var_index_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional int32 resultant_var_index = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
          _Internal::set_has_resultant_var_index(&has_bits);
          resultant_var_index_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag == 0) || ((tag & 7) == 4)) {
          CHK_(ptr);
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag,
            _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
            ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* MPAbsConstraint::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:operations_research.MPAbsConstraint)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional int32 var_index = 1;
  if (cached_has_bits & 0x00000001u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(1, this->_internal_var_index(), target);
  }

  // optional int32 resultant_var_index = 2;
  if (cached_has_bits & 0x00000002u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(2, this->_internal_resultant_var_index(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:operations_research.MPAbsConstraint)
  return target;
}

size_t MPAbsConstraint::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:operations_research.MPAbsConstraint)
  size_t total_size = 0;

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    // optional int32 var_index = 1;
    if (cached_has_bits & 0x00000001u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
          this->_internal_var_index());
    }

    // optional int32 resultant_var_index = 2;
    if (cached_has_bits & 0x00000002u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
          this->_internal_resultant_var_index());
    }

  }
  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize(
        _internal_metadata_, total_size, &_cached_size_);
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData MPAbsConstraint::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
    MPAbsConstraint::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*MPAbsConstraint::GetClassData() const { return &_class_data_; }

void MPAbsConstraint::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to,
                      const ::PROTOBUF_NAMESPACE_ID::Message&from) {
  static_cast<MPAbsConstraint *>(to)->MergeFrom(
      static_cast<const MPAbsConstraint &>(from));
}


void MPAbsConstraint::MergeFrom(const MPAbsConstraint& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:operations_research.MPAbsConstraint)
  GOOGLE_DCHECK_NE(&from, this);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    if (cached_has_bits & 0x00000001u) {
      var_index_ = from.var_index_;
    }
    if (cached_has_bits & 0x00000002u) {
      resultant_var_index_ = from.resultant_var_index_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

void MPAbsConstraint::CopyFrom(const MPAbsConstraint& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:operations_research.MPAbsConstraint)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool MPAbsConstraint::IsInitialized() const {
  return true;
}

void MPAbsConstraint::InternalSwap(MPAbsConstraint* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(MPAbsConstraint, resultant_var_index_)
      + sizeof(MPAbsConstraint::resultant_var_index_)
      - PROTOBUF_FIELD_OFFSET(MPAbsConstraint, var_index_)>(
          reinterpret_cast<char*>(&var_index_),
          reinterpret_cast<char*>(&other->var_index_));
}

::PROTOBUF_NAMESPACE_ID::Metadata MPAbsConstraint::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_ortools_2flinear_5fsolver_2flinear_5fsolver_2eproto_getter, &descriptor_table_ortools_2flinear_5fsolver_2flinear_5fsolver_2eproto_once,
      file_level_metadata_ortools_2flinear_5fsolver_2flinear_5fsolver_2eproto[6]);
}

// ===================================================================

class MPArrayConstraint::_Internal {
 public:
  using HasBits = decltype(std::declval<MPArrayConstraint>()._has_bits_);
  static void set_has_resultant_var_index(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
};

MPArrayConstraint::MPArrayConstraint(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned),
  var_index_(arena) {
  SharedCtor();
  if (!is_message_owned) {
    RegisterArenaDtor(arena);
  }
  // @@protoc_insertion_point(arena_constructor:operations_research.MPArrayConstraint)
}
MPArrayConstraint::MPArrayConstraint(const MPArrayConstraint& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _has_bits_(from._has_bits_),
      var_index_(from.var_index_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  resultant_var_index_ = from.resultant_var_index_;
  // @@protoc_insertion_point(copy_constructor:operations_research.MPArrayConstraint)
}

inline void MPArrayConstraint::SharedCtor() {
resultant_var_index_ = 0;
}

MPArrayConstraint::~MPArrayConstraint() {
  // @@protoc_insertion_point(destructor:operations_research.MPArrayConstraint)
  if (GetArenaForAllocation() != nullptr) return;
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

inline void MPArrayConstraint::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
}

void MPArrayConstraint::ArenaDtor(void* object) {
  MPArrayConstraint* _this = reinterpret_cast< MPArrayConstraint* >(object);
  (void)_this;
}
void MPArrayConstraint::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void MPArrayConstraint::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void MPArrayConstraint::Clear() {
// @@protoc_insertion_point(message_clear_start:operations_research.MPArrayConstraint)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  var_index_.Clear();
  resultant_var_index_ = 0;
  _has_bits_.Clear();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* MPArrayConstraint::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // repeated int32 var_index = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          ptr -= 1;
          do {
            ptr += 1;
            _internal_add_var_index(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr));
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<8>(ptr));
        } else if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10) {
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedInt32Parser(_internal_mutable_var_index(), ptr, ctx);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional int32 resultant_var_index = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
          _Internal::set_has_resultant_var_index(&has_bits);
          resultant_var_index_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag == 0) || ((tag & 7) == 4)) {
          CHK_(ptr);
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag,
            _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
            ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* MPArrayConstraint::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:operations_research.MPArrayConstraint)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // repeated int32 var_index = 1;
  for (int i = 0, n = this->_internal_var_index_size(); i < n; i++) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(1, this->_internal_var_index(i), target);
  }

  cached_has_bits = _has_bits_[0];
  // optional int32 resultant_var_index = 2;
  if (cached_has_bits & 0x00000001u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(2, this->_internal_resultant_var_index(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:operations_research.MPArrayConstraint)
  return target;
}

size_t MPArrayConstraint::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:operations_research.MPArrayConstraint)
  size_t total_size = 0;

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // repeated int32 var_index = 1;
  {
    size_t data_size = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      Int32Size(this->var_index_);
    total_size += 1 *
                  ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->_internal_var_index_size());
    total_size += data_size;
  }

  // optional int32 resultant_var_index = 2;
  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
        this->_internal_resultant_var_index());
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize(
        _internal_metadata_, total_size, &_cached_size_);
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData MPArrayConstraint::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
    MPArrayConstraint::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*MPArrayConstraint::GetClassData() const { return &_class_data_; }

void MPArrayConstraint::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to,
                      const ::PROTOBUF_NAMESPACE_ID::Message&from) {
  static_cast<MPArrayConstraint *>(to)->MergeFrom(
      static_cast<const MPArrayConstraint &>(from));
}


void MPArrayConstraint::MergeFrom(const MPArrayConstraint& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:operations_research.MPArrayConstraint)
  GOOGLE_DCHECK_NE(&from, this);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  var_index_.MergeFrom(from.var_index_);
  if (from._internal_has_resultant_var_index()) {
    _internal_set_resultant_var_index(from._internal_resultant_var_index());
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

void MPArrayConstraint::CopyFrom(const MPArrayConstraint& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:operations_research.MPArrayConstraint)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool MPArrayConstraint::IsInitialized() const {
  return true;
}

void MPArrayConstraint::InternalSwap(MPArrayConstraint* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  var_index_.InternalSwap(&other->var_index_);
  swap(resultant_var_index_, other->resultant_var_index_);
}

::PROTOBUF_NAMESPACE_ID::Metadata MPArrayConstraint::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_ortools_2flinear_5fsolver_2flinear_5fsolver_2eproto_getter, &descriptor_table_ortools_2flinear_5fsolver_2flinear_5fsolver_2eproto_once,
      file_level_metadata_ortools_2flinear_5fsolver_2flinear_5fsolver_2eproto[7]);
}

// ===================================================================

class MPArrayWithConstantConstraint::_Internal {
 public:
  using HasBits = decltype(std::declval<MPArrayWithConstantConstraint>()._has_bits_);
  static void set_has_constant(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static void set_has_resultant_var_index(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
};

MPArrayWithConstantConstraint::MPArrayWithConstantConstraint(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned),
  var_index_(arena) {
  SharedCtor();
  if (!is_message_owned) {
    RegisterArenaDtor(arena);
  }
  // @@protoc_insertion_point(arena_constructor:operations_research.MPArrayWithConstantConstraint)
}
MPArrayWithConstantConstraint::MPArrayWithConstantConstraint(const MPArrayWithConstantConstraint& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _has_bits_(from._has_bits_),
      var_index_(from.var_index_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  ::memcpy(&constant_, &from.constant_,
    static_cast<size_t>(reinterpret_cast<char*>(&resultant_var_index_) -
    reinterpret_cast<char*>(&constant_)) + sizeof(resultant_var_index_));
  // @@protoc_insertion_point(copy_constructor:operations_research.MPArrayWithConstantConstraint)
}

inline void MPArrayWithConstantConstraint::SharedCtor() {
::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
    reinterpret_cast<char*>(&constant_) - reinterpret_cast<char*>(this)),
    0, static_cast<size_t>(reinterpret_cast<char*>(&resultant_var_index_) -
    reinterpret_cast<char*>(&constant_)) + sizeof(resultant_var_index_));
}

MPArrayWithConstantConstraint::~MPArrayWithConstantConstraint() {
  // @@protoc_insertion_point(destructor:operations_research.MPArrayWithConstantConstraint)
  if (GetArenaForAllocation() != nullptr) return;
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

inline void MPArrayWithConstantConstraint::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
}

void MPArrayWithConstantConstraint::ArenaDtor(void* object) {
  MPArrayWithConstantConstraint* _this = reinterpret_cast< MPArrayWithConstantConstraint* >(object);
  (void)_this;
}
void MPArrayWithConstantConstraint::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void MPArrayWithConstantConstraint::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void MPArrayWithConstantConstraint::Clear() {
// @@protoc_insertion_point(message_clear_start:operations_research.MPArrayWithConstantConstraint)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  var_index_.Clear();
  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    ::memset(&constant_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&resultant_var_index_) -
        reinterpret_cast<char*>(&constant_)) + sizeof(resultant_var_index_));
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* MPArrayWithConstantConstraint::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // repeated int32 var_index = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          ptr -= 1;
          do {
            ptr += 1;
            _internal_add_var_index(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr));
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<8>(ptr));
        } else if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10) {
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedInt32Parser(_internal_mutable_var_index(), ptr, ctx);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional double constant = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 17)) {
          _Internal::set_has_constant(&has_bits);
          constant_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<double>(ptr);
          ptr += sizeof(double);
        } else goto handle_unusual;
        continue;
      // optional int32 resultant_var_index = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) {
          _Internal::set_has_resultant_var_index(&has_bits);
          resultant_var_index_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag == 0) || ((tag & 7) == 4)) {
          CHK_(ptr);
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag,
            _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
            ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* MPArrayWithConstantConstraint::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:operations_research.MPArrayWithConstantConstraint)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // repeated int32 var_index = 1;
  for (int i = 0, n = this->_internal_var_index_size(); i < n; i++) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(1, this->_internal_var_index(i), target);
  }

  cached_has_bits = _has_bits_[0];
  // optional double constant = 2;
  if (cached_has_bits & 0x00000001u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteDoubleToArray(2, this->_internal_constant(), target);
  }

  // optional int32 resultant_var_index = 3;
  if (cached_has_bits & 0x00000002u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(3, this->_internal_resultant_var_index(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:operations_research.MPArrayWithConstantConstraint)
  return target;
}

size_t MPArrayWithConstantConstraint::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:operations_research.MPArrayWithConstantConstraint)
  size_t total_size = 0;

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // repeated int32 var_index = 1;
  {
    size_t data_size = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      Int32Size(this->var_index_);
    total_size += 1 *
                  ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->_internal_var_index_size());
    total_size += data_size;
  }

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    // optional double constant = 2;
    if (cached_has_bits & 0x00000001u) {
      total_size += 1 + 8;
    }

    // optional int32 resultant_var_index = 3;
    if (cached_has_bits & 0x00000002u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
          this->_internal_resultant_var_index());
    }

  }
  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize(
        _internal_metadata_, total_size, &_cached_size_);
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData MPArrayWithConstantConstraint::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
    MPArrayWithConstantConstraint::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*MPArrayWithConstantConstraint::GetClassData() const { return &_class_data_; }

void MPArrayWithConstantConstraint::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to,
                      const ::PROTOBUF_NAMESPACE_ID::Message&from) {
  static_cast<MPArrayWithConstantConstraint *>(to)->MergeFrom(
      static_cast<const MPArrayWithConstantConstraint &>(from));
}


void MPArrayWithConstantConstraint::MergeFrom(const MPArrayWithConstantConstraint& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:operations_research.MPArrayWithConstantConstraint)
  GOOGLE_DCHECK_NE(&from, this);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  var_index_.MergeFrom(from.var_index_);
  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    if (cached_has_bits & 0x00000001u) {
      constant_ = from.constant_;
    }
    if (cached_has_bits & 0x00000002u) {
      resultant_var_index_ = from.resultant_var_index_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

void MPArrayWithConstantConstraint::CopyFrom(const MPArrayWithConstantConstraint& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:operations_research.MPArrayWithConstantConstraint)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool MPArrayWithConstantConstraint::IsInitialized() const {
  return true;
}

void MPArrayWithConstantConstraint::InternalSwap(MPArrayWithConstantConstraint* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  var_index_.InternalSwap(&other->var_index_);
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(MPArrayWithConstantConstraint, resultant_var_index_)
      + sizeof(MPArrayWithConstantConstraint::resultant_var_index_)
      - PROTOBUF_FIELD_OFFSET(MPArrayWithConstantConstraint, constant_)>(
          reinterpret_cast<char*>(&constant_),
          reinterpret_cast<char*>(&other->constant_));
}

::PROTOBUF_NAMESPACE_ID::Metadata MPArrayWithConstantConstraint::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_ortools_2flinear_5fsolver_2flinear_5fsolver_2eproto_getter, &descriptor_table_ortools_2flinear_5fsolver_2flinear_5fsolver_2eproto_once,
      file_level_metadata_ortools_2flinear_5fsolver_2flinear_5fsolver_2eproto[8]);
}

// ===================================================================

class MPQuadraticObjective::_Internal {
 public:
};

MPQuadraticObjective::MPQuadraticObjective(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned),
  qvar1_index_(arena),
  qvar2_index_(arena),
  coefficient_(arena) {
  SharedCtor();
  if (!is_message_owned) {
    RegisterArenaDtor(arena);
  }
  // @@protoc_insertion_point(arena_constructor:operations_research.MPQuadraticObjective)
}
MPQuadraticObjective::MPQuadraticObjective(const MPQuadraticObjective& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      qvar1_index_(from.qvar1_index_),
      qvar2_index_(from.qvar2_index_),
      coefficient_(from.coefficient_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  // @@protoc_insertion_point(copy_constructor:operations_research.MPQuadraticObjective)
}

inline void MPQuadraticObjective::SharedCtor() {
}

MPQuadraticObjective::~MPQuadraticObjective() {
  // @@protoc_insertion_point(destructor:operations_research.MPQuadraticObjective)
  if (GetArenaForAllocation() != nullptr) return;
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

inline void MPQuadraticObjective::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
}

void MPQuadraticObjective::ArenaDtor(void* object) {
  MPQuadraticObjective* _this = reinterpret_cast< MPQuadraticObjective* >(object);
  (void)_this;
}
void MPQuadraticObjective::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void MPQuadraticObjective::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void MPQuadraticObjective::Clear() {
// @@protoc_insertion_point(message_clear_start:operations_research.MPQuadraticObjective)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  qvar1_index_.Clear();
  qvar2_index_.Clear();
  coefficient_.Clear();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* MPQuadraticObjective::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // repeated int32 qvar1_index = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          ptr -= 1;
          do {
            ptr += 1;
            _internal_add_qvar1_index(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr));
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<8>(ptr));
        } else if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10) {
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedInt32Parser(_internal_mutable_qvar1_index(), ptr, ctx);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // repeated int32 qvar2_index = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
          ptr -= 1;
          do {
            ptr += 1;
            _internal_add_qvar2_index(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr));
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<16>(ptr));
        } else if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18) {
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedInt32Parser(_internal_mutable_qvar2_index(), ptr, ctx);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // repeated double coefficient = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 25)) {
          ptr -= 1;
          do {
            ptr += 1;
            _internal_add_coefficient(::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<double>(ptr));
            ptr += sizeof(double);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<25>(ptr));
        } else if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26) {
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedDoubleParser(_internal_mutable_coefficient(), ptr, ctx);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag == 0) || ((tag & 7) == 4)) {
          CHK_(ptr);
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag,
            _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
            ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* MPQuadraticObjective::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:operations_research.MPQuadraticObjective)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // repeated int32 qvar1_index = 1;
  for (int i = 0, n = this->_internal_qvar1_index_size(); i < n; i++) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(1, this->_internal_qvar1_index(i), target);
  }

  // repeated int32 qvar2_index = 2;
  for (int i = 0, n = this->_internal_qvar2_index_size(); i < n; i++) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(2, this->_internal_qvar2_index(i), target);
  }

  // repeated double coefficient = 3;
  for (int i = 0, n = this->_internal_coefficient_size(); i < n; i++) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteDoubleToArray(3, this->_internal_coefficient(i), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:operations_research.MPQuadraticObjective)
  return target;
}

size_t MPQuadraticObjective::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:operations_research.MPQuadraticObjective)
  size_t total_size = 0;

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // repeated int32 qvar1_index = 1;
  {
    size_t data_size = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      Int32Size(this->qvar1_index_);
    total_size += 1 *
                  ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->_internal_qvar1_index_size());
    total_size += data_size;
  }

  // repeated int32 qvar2_index = 2;
  {
    size_t data_size = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      Int32Size(this->qvar2_index_);
    total_size += 1 *
                  ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->_internal_qvar2_index_size());
    total_size += data_size;
  }

  // repeated double coefficient = 3;
  {
    unsigned int count = static_cast<unsigned int>(this->_internal_coefficient_size());
    size_t data_size = 8UL * count;
    total_size += 1 *
                  ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->_internal_coefficient_size());
    total_size += data_size;
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize(
        _internal_metadata_, total_size, &_cached_size_);
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData MPQuadraticObjective::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
    MPQuadraticObjective::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*MPQuadraticObjective::GetClassData() const { return &_class_data_; }

void MPQuadraticObjective::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to,
                      const ::PROTOBUF_NAMESPACE_ID::Message&from) {
  static_cast<MPQuadraticObjective *>(to)->MergeFrom(
      static_cast<const MPQuadraticObjective &>(from));
}


void MPQuadraticObjective::MergeFrom(const MPQuadraticObjective& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:operations_research.MPQuadraticObjective)
  GOOGLE_DCHECK_NE(&from, this);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  qvar1_index_.MergeFrom(from.qvar1_index_);
  qvar2_index_.MergeFrom(from.qvar2_index_);
  coefficient_.MergeFrom(from.coefficient_);
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

void MPQuadraticObjective::CopyFrom(const MPQuadraticObjective& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:operations_research.MPQuadraticObjective)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool MPQuadraticObjective::IsInitialized() const {
  return true;
}

void MPQuadraticObjective::InternalSwap(MPQuadraticObjective* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  qvar1_index_.InternalSwap(&other->qvar1_index_);
  qvar2_index_.InternalSwap(&other->qvar2_index_);
  coefficient_.InternalSwap(&other->coefficient_);
}

::PROTOBUF_NAMESPACE_ID::Metadata MPQuadraticObjective::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_ortools_2flinear_5fsolver_2flinear_5fsolver_2eproto_getter, &descriptor_table_ortools_2flinear_5fsolver_2flinear_5fsolver_2eproto_once,
      file_level_metadata_ortools_2flinear_5fsolver_2flinear_5fsolver_2eproto[9]);
}

// ===================================================================

class PartialVariableAssignment::_Internal {
 public:
};

PartialVariableAssignment::PartialVariableAssignment(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned),
  var_index_(arena),
  var_value_(arena) {
  SharedCtor();
  if (!is_message_owned) {
    RegisterArenaDtor(arena);
  }
  // @@protoc_insertion_point(arena_constructor:operations_research.PartialVariableAssignment)
}
PartialVariableAssignment::PartialVariableAssignment(const PartialVariableAssignment& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      var_index_(from.var_index_),
      var_value_(from.var_value_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  // @@protoc_insertion_point(copy_constructor:operations_research.PartialVariableAssignment)
}

inline void PartialVariableAssignment::SharedCtor() {
}

PartialVariableAssignment::~PartialVariableAssignment() {
  // @@protoc_insertion_point(destructor:operations_research.PartialVariableAssignment)
  if (GetArenaForAllocation() != nullptr) return;
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

inline void PartialVariableAssignment::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
}

void PartialVariableAssignment::ArenaDtor(void* object) {
  PartialVariableAssignment* _this = reinterpret_cast< PartialVariableAssignment* >(object);
  (void)_this;
}
void PartialVariableAssignment::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void PartialVariableAssignment::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void PartialVariableAssignment::Clear() {
// @@protoc_insertion_point(message_clear_start:operations_research.PartialVariableAssignment)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  var_index_.Clear();
  var_value_.Clear();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* PartialVariableAssignment::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // repeated int32 var_index = 1 [packed = true];
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedInt32Parser(_internal_mutable_var_index(), ptr, ctx);
          CHK_(ptr);
        } else if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8) {
          _internal_add_var_index(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr));
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // repeated double var_value = 2 [packed = true];
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedDoubleParser(_internal_mutable_var_value(), ptr, ctx);
          CHK_(ptr);
        } else if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 17) {
          _internal_add_var_value(::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<double>(ptr));
          ptr += sizeof(double);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag == 0) || ((tag & 7) == 4)) {
          CHK_(ptr);
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag,
            _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
            ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* PartialVariableAssignment::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:operations_research.PartialVariableAssignment)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  // repeated int32 var_index = 1 [packed = true];
  {
    int byte_size = _var_index_cached_byte_size_.load(std::memory_order_relaxed);
    if (byte_size > 0) {
      target = stream->WriteInt32Packed(
          1, _internal_var_index(), byte_size, target);
    }
  }

  // repeated double var_value = 2 [packed = true];
  if (this->_internal_var_value_size() > 0) {
    target = stream->WriteFixedPacked(2, _internal_var_value(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:operations_research.PartialVariableAssignment)
  return target;
}

size_t PartialVariableAssignment::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:operations_research.PartialVariableAssignment)
  size_t total_size = 0;

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // repeated int32 var_index = 1 [packed = true];
  {
    size_t data_size = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      Int32Size(this->var_index_);
    if (data_size > 0) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
            static_cast<::PROTOBUF_NAMESPACE_ID::int32>(data_size));
    }
    int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(data_size);
    _var_index_cached_byte_size_.store(cached_size,
                                    std::memory_order_relaxed);
    total_size += data_size;
  }

  // repeated double var_value = 2 [packed = true];
  {
    unsigned int count = static_cast<unsigned int>(this->_internal_var_value_size());
    size_t data_size = 8UL * count;
    if (data_size > 0) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
            static_cast<::PROTOBUF_NAMESPACE_ID::int32>(data_size));
    }
    total_size += data_size;
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize(
        _internal_metadata_, total_size, &_cached_size_);
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData PartialVariableAssignment::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
    PartialVariableAssignment::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*PartialVariableAssignment::GetClassData() const { return &_class_data_; }

void PartialVariableAssignment::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to,
                      const ::PROTOBUF_NAMESPACE_ID::Message&from) {
  static_cast<PartialVariableAssignment *>(to)->MergeFrom(
      static_cast<const PartialVariableAssignment &>(from));
}


void PartialVariableAssignment::MergeFrom(const PartialVariableAssignment& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:operations_research.PartialVariableAssignment)
  GOOGLE_DCHECK_NE(&from, this);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  var_index_.MergeFrom(from.var_index_);
  var_value_.MergeFrom(from.var_value_);
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

void PartialVariableAssignment::CopyFrom(const PartialVariableAssignment& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:operations_research.PartialVariableAssignment)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool PartialVariableAssignment::IsInitialized() const {
  return true;
}

void PartialVariableAssignment::InternalSwap(PartialVariableAssignment* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  var_index_.InternalSwap(&other->var_index_);
  var_value_.InternalSwap(&other->var_value_);
}

::PROTOBUF_NAMESPACE_ID::Metadata PartialVariableAssignment::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_ortools_2flinear_5fsolver_2flinear_5fsolver_2eproto_getter, &descriptor_table_ortools_2flinear_5fsolver_2flinear_5fsolver_2eproto_once,
      file_level_metadata_ortools_2flinear_5fsolver_2flinear_5fsolver_2eproto[10]);
}

// ===================================================================

class MPModelProto::_Internal {
 public:
  using HasBits = decltype(std::declval<MPModelProto>()._has_bits_);
  static void set_has_maximize(HasBits* has_bits) {
    (*has_bits)[0] |= 16u;
  }
  static void set_has_objective_offset(HasBits* has_bits) {
    (*has_bits)[0] |= 8u;
  }
  static const ::operations_research::MPQuadraticObjective& quadratic_objective(const MPModelProto* msg);
  static void set_has_quadratic_objective(HasBits* has_bits) {
    (*has_bits)[0] |= 4u;
  }
  static void set_has_name(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static const ::operations_research::PartialVariableAssignment& solution_hint(const MPModelProto* msg);
  static void set_has_solution_hint(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
};

const ::operations_research::MPQuadraticObjective&
MPModelProto::_Internal::quadratic_objective(const MPModelProto* msg) {
  return *msg->quadratic_objective_;
}
const ::operations_research::PartialVariableAssignment&
MPModelProto::_Internal::solution_hint(const MPModelProto* msg) {
  return *msg->solution_hint_;
}
MPModelProto::MPModelProto(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned),
  variable_(arena),
  constraint_(arena),
  general_constraint_(arena) {
  SharedCtor();
  if (!is_message_owned) {
    RegisterArenaDtor(arena);
  }
  // @@protoc_insertion_point(arena_constructor:operations_research.MPModelProto)
}
MPModelProto::MPModelProto(const MPModelProto& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _has_bits_(from._has_bits_),
      variable_(from.variable_),
      constraint_(from.constraint_),
      general_constraint_(from.general_constraint_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from._internal_has_name()) {
    name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_name(), 
      GetArenaForAllocation());
  }
  if (from._internal_has_solution_hint()) {
    solution_hint_ = new ::operations_research::PartialVariableAssignment(*from.solution_hint_);
  } else {
    solution_hint_ = nullptr;
  }
  if (from._internal_has_quadratic_objective()) {
    quadratic_objective_ = new ::operations_research::MPQuadraticObjective(*from.quadratic_objective_);
  } else {
    quadratic_objective_ = nullptr;
  }
  ::memcpy(&objective_offset_, &from.objective_offset_,
    static_cast<size_t>(reinterpret_cast<char*>(&maximize_) -
    reinterpret_cast<char*>(&objective_offset_)) + sizeof(maximize_));
  // @@protoc_insertion_point(copy_constructor:operations_research.MPModelProto)
}

inline void MPModelProto::SharedCtor() {
name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
    reinterpret_cast<char*>(&solution_hint_) - reinterpret_cast<char*>(this)),
    0, static_cast<size_t>(reinterpret_cast<char*>(&maximize_) -
    reinterpret_cast<char*>(&solution_hint_)) + sizeof(maximize_));
}

MPModelProto::~MPModelProto() {
  // @@protoc_insertion_point(destructor:operations_research.MPModelProto)
  if (GetArenaForAllocation() != nullptr) return;
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

inline void MPModelProto::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (this != internal_default_instance()) delete solution_hint_;
  if (this != internal_default_instance()) delete quadratic_objective_;
}

void MPModelProto::ArenaDtor(void* object) {
  MPModelProto* _this = reinterpret_cast< MPModelProto* >(object);
  (void)_this;
}
void MPModelProto::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void MPModelProto::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void MPModelProto::Clear() {
// @@protoc_insertion_point(message_clear_start:operations_research.MPModelProto)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  variable_.Clear();
  constraint_.Clear();
  general_constraint_.Clear();
  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000007u) {
    if (cached_has_bits & 0x00000001u) {
      name_.ClearNonDefaultToEmpty();
    }
    if (cached_has_bits & 0x00000002u) {
      GOOGLE_DCHECK(solution_hint_ != nullptr);
      solution_hint_->Clear();
    }
    if (cached_has_bits & 0x00000004u) {
      GOOGLE_DCHECK(quadratic_objective_ != nullptr);
      quadratic_objective_->Clear();
    }
  }
  if (cached_has_bits & 0x00000018u) {
    ::memset(&objective_offset_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&maximize_) -
        reinterpret_cast<char*>(&objective_offset_)) + sizeof(maximize_));
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* MPModelProto::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // optional bool maximize = 1 [default = false];
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          _Internal::set_has_maximize(&has_bits);
          maximize_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional double objective_offset = 2 [default = 0];
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 17)) {
          _Internal::set_has_objective_offset(&has_bits);
          objective_offset_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<double>(ptr);
          ptr += sizeof(double);
        } else goto handle_unusual;
        continue;
      // repeated .operations_research.MPVariableProto variable = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) {
          ptr -= 1;
          do {
            ptr += 1;
            ptr = ctx->ParseMessage(_internal_add_variable(), ptr);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<26>(ptr));
        } else goto handle_unusual;
        continue;
      // repeated .operations_research.MPConstraintProto constraint = 4;
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) {
          ptr -= 1;
          do {
            ptr += 1;
            ptr = ctx->ParseMessage(_internal_add_constraint(), ptr);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<34>(ptr));
        } else goto handle_unusual;
        continue;
      // optional string name = 5 [default = ""];
      case 5:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 42)) {
          auto str = _internal_mutable_name();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          #ifndef NDEBUG
          ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "operations_research.MPModelProto.name");
          #endif  // !NDEBUG
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .operations_research.PartialVariableAssignment solution_hint = 6;
      case 6:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 50)) {
          ptr = ctx->ParseMessage(_internal_mutable_solution_hint(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // repeated .operations_research.MPGeneralConstraintProto general_constraint = 7;
      case 7:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 58)) {
          ptr -= 1;
          do {
            ptr += 1;
            ptr = ctx->ParseMessage(_internal_add_general_constraint(), ptr);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<58>(ptr));
        } else goto handle_unusual;
        continue;
      // optional .operations_research.MPQuadraticObjective quadratic_objective = 8;
      case 8:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 66)) {
          ptr = ctx->ParseMessage(_internal_mutable_quadratic_objective(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag == 0) || ((tag & 7) == 4)) {
          CHK_(ptr);
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag,
            _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
            ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* MPModelProto::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:operations_research.MPModelProto)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional bool maximize = 1 [default = false];
  if (cached_has_bits & 0x00000010u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(1, this->_internal_maximize(), target);
  }

  // optional double objective_offset = 2 [default = 0];
  if (cached_has_bits & 0x00000008u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteDoubleToArray(2, this->_internal_objective_offset(), target);
  }

  // repeated .operations_research.MPVariableProto variable = 3;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->_internal_variable_size()); i < n; i++) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(3, this->_internal_variable(i), target, stream);
  }

  // repeated .operations_research.MPConstraintProto constraint = 4;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->_internal_constraint_size()); i < n; i++) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(4, this->_internal_constraint(i), target, stream);
  }

  // optional string name = 5 [default = ""];
  if (cached_has_bits & 0x00000001u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
      this->_internal_name().data(), static_cast<int>(this->_internal_name().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
      "operations_research.MPModelProto.name");
    target = stream->WriteStringMaybeAliased(
        5, this->_internal_name(), target);
  }

  // optional .operations_research.PartialVariableAssignment solution_hint = 6;
  if (cached_has_bits & 0x00000002u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        6, _Internal::solution_hint(this), target, stream);
  }

  // repeated .operations_research.MPGeneralConstraintProto general_constraint = 7;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->_internal_general_constraint_size()); i < n; i++) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(7, this->_internal_general_constraint(i), target, stream);
  }

  // optional .operations_research.MPQuadraticObjective quadratic_objective = 8;
  if (cached_has_bits & 0x00000004u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        8, _Internal::quadratic_objective(this), target, stream);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:operations_research.MPModelProto)
  return target;
}

size_t MPModelProto::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:operations_research.MPModelProto)
  size_t total_size = 0;

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // repeated .operations_research.MPVariableProto variable = 3;
  total_size += 1UL * this->_internal_variable_size();
  for (const auto& msg : this->variable_) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
  }

  // repeated .operations_research.MPConstraintProto constraint = 4;
  total_size += 1UL * this->_internal_constraint_size();
  for (const auto& msg : this->constraint_) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
  }

  // repeated .operations_research.MPGeneralConstraintProto general_constraint = 7;
  total_size += 1UL * this->_internal_general_constraint_size();
  for (const auto& msg : this->general_constraint_) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
  }

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x0000001fu) {
    // optional string name = 5 [default = ""];
    if (cached_has_bits & 0x00000001u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
          this->_internal_name());
    }

    // optional .operations_research.PartialVariableAssignment solution_hint = 6;
    if (cached_has_bits & 0x00000002u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *solution_hint_);
    }

    // optional .operations_research.MPQuadraticObjective quadratic_objective = 8;
    if (cached_has_bits & 0x00000004u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *quadratic_objective_);
    }

    // optional double objective_offset = 2 [default = 0];
    if (cached_has_bits & 0x00000008u) {
      total_size += 1 + 8;
    }

    // optional bool maximize = 1 [default = false];
    if (cached_has_bits & 0x00000010u) {
      total_size += 1 + 1;
    }

  }
  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize(
        _internal_metadata_, total_size, &_cached_size_);
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData MPModelProto::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
    MPModelProto::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*MPModelProto::GetClassData() const { return &_class_data_; }

void MPModelProto::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to,
                      const ::PROTOBUF_NAMESPACE_ID::Message&from) {
  static_cast<MPModelProto *>(to)->MergeFrom(
      static_cast<const MPModelProto &>(from));
}


void MPModelProto::MergeFrom(const MPModelProto& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:operations_research.MPModelProto)
  GOOGLE_DCHECK_NE(&from, this);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  variable_.MergeFrom(from.variable_);
  constraint_.MergeFrom(from.constraint_);
  general_constraint_.MergeFrom(from.general_constraint_);
  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 0x0000001fu) {
    if (cached_has_bits & 0x00000001u) {
      _internal_set_name(from._internal_name());
    }
    if (cached_has_bits & 0x00000002u) {
      _internal_mutable_solution_hint()->::operations_research::PartialVariableAssignment::MergeFrom(from._internal_solution_hint());
    }
    if (cached_has_bits & 0x00000004u) {
      _internal_mutable_quadratic_objective()->::operations_research::MPQuadraticObjective::MergeFrom(from._internal_quadratic_objective());
    }
    if (cached_has_bits & 0x00000008u) {
      objective_offset_ = from.objective_offset_;
    }
    if (cached_has_bits & 0x00000010u) {
      maximize_ = from.maximize_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

void MPModelProto::CopyFrom(const MPModelProto& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:operations_research.MPModelProto)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool MPModelProto::IsInitialized() const {
  return true;
}

void MPModelProto::InternalSwap(MPModelProto* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  variable_.InternalSwap(&other->variable_);
  constraint_.InternalSwap(&other->constraint_);
  general_constraint_.InternalSwap(&other->general_constraint_);
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
      &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      &name_, GetArenaForAllocation(),
      &other->name_, other->GetArenaForAllocation()
  );
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(MPModelProto, maximize_)
      + sizeof(MPModelProto::maximize_)
      - PROTOBUF_FIELD_OFFSET(MPModelProto, solution_hint_)>(
          reinterpret_cast<char*>(&solution_hint_),
          reinterpret_cast<char*>(&other->solution_hint_));
}

::PROTOBUF_NAMESPACE_ID::Metadata MPModelProto::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_ortools_2flinear_5fsolver_2flinear_5fsolver_2eproto_getter, &descriptor_table_ortools_2flinear_5fsolver_2flinear_5fsolver_2eproto_once,
      file_level_metadata_ortools_2flinear_5fsolver_2flinear_5fsolver_2eproto[11]);
}

// ===================================================================

class OptionalDouble::_Internal {
 public:
  using HasBits = decltype(std::declval<OptionalDouble>()._has_bits_);
  static void set_has_value(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
};

OptionalDouble::OptionalDouble(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
  SharedCtor();
  if (!is_message_owned) {
    RegisterArenaDtor(arena);
  }
  // @@protoc_insertion_point(arena_constructor:operations_research.OptionalDouble)
}
OptionalDouble::OptionalDouble(const OptionalDouble& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  value_ = from.value_;
  // @@protoc_insertion_point(copy_constructor:operations_research.OptionalDouble)
}

inline void OptionalDouble::SharedCtor() {
value_ = 0;
}

OptionalDouble::~OptionalDouble() {
  // @@protoc_insertion_point(destructor:operations_research.OptionalDouble)
  if (GetArenaForAllocation() != nullptr) return;
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

inline void OptionalDouble::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
}

void OptionalDouble::ArenaDtor(void* object) {
  OptionalDouble* _this = reinterpret_cast< OptionalDouble* >(object);
  (void)_this;
}
void OptionalDouble::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void OptionalDouble::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void OptionalDouble::Clear() {
// @@protoc_insertion_point(message_clear_start:operations_research.OptionalDouble)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  value_ = 0;
  _has_bits_.Clear();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* OptionalDouble::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // optional double value = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 9)) {
          _Internal::set_has_value(&has_bits);
          value_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<double>(ptr);
          ptr += sizeof(double);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag == 0) || ((tag & 7) == 4)) {
          CHK_(ptr);
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag,
            _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
            ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* OptionalDouble::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:operations_research.OptionalDouble)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional double value = 1;
  if (cached_has_bits & 0x00000001u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteDoubleToArray(1, this->_internal_value(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:operations_research.OptionalDouble)
  return target;
}

size_t OptionalDouble::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:operations_research.OptionalDouble)
  size_t total_size = 0;

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // optional double value = 1;
  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    total_size += 1 + 8;
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize(
        _internal_metadata_, total_size, &_cached_size_);
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData OptionalDouble::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
    OptionalDouble::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*OptionalDouble::GetClassData() const { return &_class_data_; }

void OptionalDouble::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to,
                      const ::PROTOBUF_NAMESPACE_ID::Message&from) {
  static_cast<OptionalDouble *>(to)->MergeFrom(
      static_cast<const OptionalDouble &>(from));
}


void OptionalDouble::MergeFrom(const OptionalDouble& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:operations_research.OptionalDouble)
  GOOGLE_DCHECK_NE(&from, this);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  if (from._internal_has_value()) {
    _internal_set_value(from._internal_value());
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

void OptionalDouble::CopyFrom(const OptionalDouble& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:operations_research.OptionalDouble)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool OptionalDouble::IsInitialized() const {
  return true;
}

void OptionalDouble::InternalSwap(OptionalDouble* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  swap(value_, other->value_);
}

::PROTOBUF_NAMESPACE_ID::Metadata OptionalDouble::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_ortools_2flinear_5fsolver_2flinear_5fsolver_2eproto_getter, &descriptor_table_ortools_2flinear_5fsolver_2flinear_5fsolver_2eproto_once,
      file_level_metadata_ortools_2flinear_5fsolver_2flinear_5fsolver_2eproto[12]);
}

// ===================================================================

class MPSolverCommonParameters::_Internal {
 public:
  using HasBits = decltype(std::declval<MPSolverCommonParameters>()._has_bits_);
  static const ::operations_research::OptionalDouble& relative_mip_gap(const MPSolverCommonParameters* msg);
  static void set_has_relative_mip_gap(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static const ::operations_research::OptionalDouble& primal_tolerance(const MPSolverCommonParameters* msg);
  static void set_has_primal_tolerance(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
  static const ::operations_research::OptionalDouble& dual_tolerance(const MPSolverCommonParameters* msg);
  static void set_has_dual_tolerance(HasBits* has_bits) {
    (*has_bits)[0] |= 4u;
  }
  static void set_has_lp_algorithm(HasBits* has_bits) {
    (*has_bits)[0] |= 8u;
  }
  static void set_has_presolve(HasBits* has_bits) {
    (*has_bits)[0] |= 16u;
  }
  static void set_has_scaling(HasBits* has_bits) {
    (*has_bits)[0] |= 32u;
  }
};

const ::operations_research::OptionalDouble&
MPSolverCommonParameters::_Internal::relative_mip_gap(const MPSolverCommonParameters* msg) {
  return *msg->relative_mip_gap_;
}
const ::operations_research::OptionalDouble&
MPSolverCommonParameters::_Internal::primal_tolerance(const MPSolverCommonParameters* msg) {
  return *msg->primal_tolerance_;
}
const ::operations_research::OptionalDouble&
MPSolverCommonParameters::_Internal::dual_tolerance(const MPSolverCommonParameters* msg) {
  return *msg->dual_tolerance_;
}
MPSolverCommonParameters::MPSolverCommonParameters(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
  SharedCtor();
  if (!is_message_owned) {
    RegisterArenaDtor(arena);
  }
  // @@protoc_insertion_point(arena_constructor:operations_research.MPSolverCommonParameters)
}
MPSolverCommonParameters::MPSolverCommonParameters(const MPSolverCommonParameters& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  if (from._internal_has_relative_mip_gap()) {
    relative_mip_gap_ = new ::operations_research::OptionalDouble(*from.relative_mip_gap_);
  } else {
    relative_mip_gap_ = nullptr;
  }
  if (from._internal_has_primal_tolerance()) {
    primal_tolerance_ = new ::operations_research::OptionalDouble(*from.primal_tolerance_);
  } else {
    primal_tolerance_ = nullptr;
  }
  if (from._internal_has_dual_tolerance()) {
    dual_tolerance_ = new ::operations_research::OptionalDouble(*from.dual_tolerance_);
  } else {
    dual_tolerance_ = nullptr;
  }
  ::memcpy(&lp_algorithm_, &from.lp_algorithm_,
    static_cast<size_t>(reinterpret_cast<char*>(&scaling_) -
    reinterpret_cast<char*>(&lp_algorithm_)) + sizeof(scaling_));
  // @@protoc_insertion_point(copy_constructor:operations_research.MPSolverCommonParameters)
}

inline void MPSolverCommonParameters::SharedCtor() {
::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
    reinterpret_cast<char*>(&relative_mip_gap_) - reinterpret_cast<char*>(this)),
    0, static_cast<size_t>(reinterpret_cast<char*>(&scaling_) -
    reinterpret_cast<char*>(&relative_mip_gap_)) + sizeof(scaling_));
}

MPSolverCommonParameters::~MPSolverCommonParameters() {
  // @@protoc_insertion_point(destructor:operations_research.MPSolverCommonParameters)
  if (GetArenaForAllocation() != nullptr) return;
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

inline void MPSolverCommonParameters::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  if (this != internal_default_instance()) delete relative_mip_gap_;
  if (this != internal_default_instance()) delete primal_tolerance_;
  if (this != internal_default_instance()) delete dual_tolerance_;
}

void MPSolverCommonParameters::ArenaDtor(void* object) {
  MPSolverCommonParameters* _this = reinterpret_cast< MPSolverCommonParameters* >(object);
  (void)_this;
}
void MPSolverCommonParameters::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void MPSolverCommonParameters::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void MPSolverCommonParameters::Clear() {
// @@protoc_insertion_point(message_clear_start:operations_research.MPSolverCommonParameters)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000007u) {
    if (cached_has_bits & 0x00000001u) {
      GOOGLE_DCHECK(relative_mip_gap_ != nullptr);
      relative_mip_gap_->Clear();
    }
    if (cached_has_bits & 0x00000002u) {
      GOOGLE_DCHECK(primal_tolerance_ != nullptr);
      primal_tolerance_->Clear();
    }
    if (cached_has_bits & 0x00000004u) {
      GOOGLE_DCHECK(dual_tolerance_ != nullptr);
      dual_tolerance_->Clear();
    }
  }
  if (cached_has_bits & 0x00000038u) {
    ::memset(&lp_algorithm_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&scaling_) -
        reinterpret_cast<char*>(&lp_algorithm_)) + sizeof(scaling_));
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* MPSolverCommonParameters::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // optional .operations_research.OptionalDouble relative_mip_gap = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_relative_mip_gap(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .operations_research.OptionalDouble primal_tolerance = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
          ptr = ctx->ParseMessage(_internal_mutable_primal_tolerance(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .operations_research.OptionalDouble dual_tolerance = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) {
          ptr = ctx->ParseMessage(_internal_mutable_dual_tolerance(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .operations_research.MPSolverCommonParameters.LPAlgorithmValues lp_algorithm = 4 [default = LP_ALGO_UNSPECIFIED];
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 32)) {
          ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
          if (PROTOBUF_PREDICT_TRUE(::operations_research::MPSolverCommonParameters_LPAlgorithmValues_IsValid(val))) {
            _internal_set_lp_algorithm(static_cast<::operations_research::MPSolverCommonParameters_LPAlgorithmValues>(val));
          } else {
            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(4, val, mutable_unknown_fields());
          }
        } else goto handle_unusual;
        continue;
      // optional .operations_research.OptionalBoolean presolve = 5 [default = BOOL_UNSPECIFIED];
      case 5:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 40)) {
          ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
          if (PROTOBUF_PREDICT_TRUE(::operations_research::OptionalBoolean_IsValid(val))) {
            _internal_set_presolve(static_cast<::operations_research::OptionalBoolean>(val));
          } else {
            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(5, val, mutable_unknown_fields());
          }
        } else goto handle_unusual;
        continue;
      // optional .operations_research.OptionalBoolean scaling = 7 [default = BOOL_UNSPECIFIED];
      case 7:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 56)) {
          ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
          if (PROTOBUF_PREDICT_TRUE(::operations_research::OptionalBoolean_IsValid(val))) {
            _internal_set_scaling(static_cast<::operations_research::OptionalBoolean>(val));
          } else {
            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(7, val, mutable_unknown_fields());
          }
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag == 0) || ((tag & 7) == 4)) {
          CHK_(ptr);
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag,
            _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
            ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* MPSolverCommonParameters::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:operations_research.MPSolverCommonParameters)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional .operations_research.OptionalDouble relative_mip_gap = 1;
  if (cached_has_bits & 0x00000001u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        1, _Internal::relative_mip_gap(this), target, stream);
  }

  // optional .operations_research.OptionalDouble primal_tolerance = 2;
  if (cached_has_bits & 0x00000002u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        2, _Internal::primal_tolerance(this), target, stream);
  }

  // optional .operations_research.OptionalDouble dual_tolerance = 3;
  if (cached_has_bits & 0x00000004u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        3, _Internal::dual_tolerance(this), target, stream);
  }

  // optional .operations_research.MPSolverCommonParameters.LPAlgorithmValues lp_algorithm = 4 [default = LP_ALGO_UNSPECIFIED];
  if (cached_has_bits & 0x00000008u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
      4, this->_internal_lp_algorithm(), target);
  }

  // optional .operations_research.OptionalBoolean presolve = 5 [default = BOOL_UNSPECIFIED];
  if (cached_has_bits & 0x00000010u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
      5, this->_internal_presolve(), target);
  }

  // optional .operations_research.OptionalBoolean scaling = 7 [default = BOOL_UNSPECIFIED];
  if (cached_has_bits & 0x00000020u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
      7, this->_internal_scaling(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:operations_research.MPSolverCommonParameters)
  return target;
}

size_t MPSolverCommonParameters::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:operations_research.MPSolverCommonParameters)
  size_t total_size = 0;

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x0000003fu) {
    // optional .operations_research.OptionalDouble relative_mip_gap = 1;
    if (cached_has_bits & 0x00000001u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *relative_mip_gap_);
    }

    // optional .operations_research.OptionalDouble primal_tolerance = 2;
    if (cached_has_bits & 0x00000002u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *primal_tolerance_);
    }

    // optional .operations_research.OptionalDouble dual_tolerance = 3;
    if (cached_has_bits & 0x00000004u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *dual_tolerance_);
    }

    // optional .operations_research.MPSolverCommonParameters.LPAlgorithmValues lp_algorithm = 4 [default = LP_ALGO_UNSPECIFIED];
    if (cached_has_bits & 0x00000008u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_lp_algorithm());
    }

    // optional .operations_research.OptionalBoolean presolve = 5 [default = BOOL_UNSPECIFIED];
    if (cached_has_bits & 0x00000010u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_presolve());
    }

    // optional .operations_research.OptionalBoolean scaling = 7 [default = BOOL_UNSPECIFIED];
    if (cached_has_bits & 0x00000020u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_scaling());
    }

  }
  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize(
        _internal_metadata_, total_size, &_cached_size_);
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData MPSolverCommonParameters::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
    MPSolverCommonParameters::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*MPSolverCommonParameters::GetClassData() const { return &_class_data_; }

void MPSolverCommonParameters::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to,
                      const ::PROTOBUF_NAMESPACE_ID::Message&from) {
  static_cast<MPSolverCommonParameters *>(to)->MergeFrom(
      static_cast<const MPSolverCommonParameters &>(from));
}


void MPSolverCommonParameters::MergeFrom(const MPSolverCommonParameters& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:operations_research.MPSolverCommonParameters)
  GOOGLE_DCHECK_NE(&from, this);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 0x0000003fu) {
    if (cached_has_bits & 0x00000001u) {
      _internal_mutable_relative_mip_gap()->::operations_research::OptionalDouble::MergeFrom(from._internal_relative_mip_gap());
    }
    if (cached_has_bits & 0x00000002u) {
      _internal_mutable_primal_tolerance()->::operations_research::OptionalDouble::MergeFrom(from._internal_primal_tolerance());
    }
    if (cached_has_bits & 0x00000004u) {
      _internal_mutable_dual_tolerance()->::operations_research::OptionalDouble::MergeFrom(from._internal_dual_tolerance());
    }
    if (cached_has_bits & 0x00000008u) {
      lp_algorithm_ = from.lp_algorithm_;
    }
    if (cached_has_bits & 0x00000010u) {
      presolve_ = from.presolve_;
    }
    if (cached_has_bits & 0x00000020u) {
      scaling_ = from.scaling_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

void MPSolverCommonParameters::CopyFrom(const MPSolverCommonParameters& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:operations_research.MPSolverCommonParameters)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool MPSolverCommonParameters::IsInitialized() const {
  return true;
}

void MPSolverCommonParameters::InternalSwap(MPSolverCommonParameters* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(MPSolverCommonParameters, scaling_)
      + sizeof(MPSolverCommonParameters::scaling_)
      - PROTOBUF_FIELD_OFFSET(MPSolverCommonParameters, relative_mip_gap_)>(
          reinterpret_cast<char*>(&relative_mip_gap_),
          reinterpret_cast<char*>(&other->relative_mip_gap_));
}

::PROTOBUF_NAMESPACE_ID::Metadata MPSolverCommonParameters::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_ortools_2flinear_5fsolver_2flinear_5fsolver_2eproto_getter, &descriptor_table_ortools_2flinear_5fsolver_2flinear_5fsolver_2eproto_once,
      file_level_metadata_ortools_2flinear_5fsolver_2flinear_5fsolver_2eproto[13]);
}

// ===================================================================

MPModelDeltaProto_VariableOverridesEntry_DoNotUse::MPModelDeltaProto_VariableOverridesEntry_DoNotUse() {}
MPModelDeltaProto_VariableOverridesEntry_DoNotUse::MPModelDeltaProto_VariableOverridesEntry_DoNotUse(::PROTOBUF_NAMESPACE_ID::Arena* arena)
    : SuperType(arena) {}
void MPModelDeltaProto_VariableOverridesEntry_DoNotUse::MergeFrom(const MPModelDeltaProto_VariableOverridesEntry_DoNotUse& other) {
  MergeFromInternal(other);
}
::PROTOBUF_NAMESPACE_ID::Metadata MPModelDeltaProto_VariableOverridesEntry_DoNotUse::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_ortools_2flinear_5fsolver_2flinear_5fsolver_2eproto_getter, &descriptor_table_ortools_2flinear_5fsolver_2flinear_5fsolver_2eproto_once,
      file_level_metadata_ortools_2flinear_5fsolver_2flinear_5fsolver_2eproto[14]);
}

// ===================================================================

MPModelDeltaProto_ConstraintOverridesEntry_DoNotUse::MPModelDeltaProto_ConstraintOverridesEntry_DoNotUse() {}
MPModelDeltaProto_ConstraintOverridesEntry_DoNotUse::MPModelDeltaProto_ConstraintOverridesEntry_DoNotUse(::PROTOBUF_NAMESPACE_ID::Arena* arena)
    : SuperType(arena) {}
void MPModelDeltaProto_ConstraintOverridesEntry_DoNotUse::MergeFrom(const MPModelDeltaProto_ConstraintOverridesEntry_DoNotUse& other) {
  MergeFromInternal(other);
}
::PROTOBUF_NAMESPACE_ID::Metadata MPModelDeltaProto_ConstraintOverridesEntry_DoNotUse::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_ortools_2flinear_5fsolver_2flinear_5fsolver_2eproto_getter, &descriptor_table_ortools_2flinear_5fsolver_2flinear_5fsolver_2eproto_once,
      file_level_metadata_ortools_2flinear_5fsolver_2flinear_5fsolver_2eproto[15]);
}

// ===================================================================

class MPModelDeltaProto::_Internal {
 public:
  using HasBits = decltype(std::declval<MPModelDeltaProto>()._has_bits_);
  static void set_has_baseline_model_file_path(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
};

MPModelDeltaProto::MPModelDeltaProto(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned),
  variable_overrides_(arena),
  constraint_overrides_(arena) {
  SharedCtor();
  if (!is_message_owned) {
    RegisterArenaDtor(arena);
  }
  // @@protoc_insertion_point(arena_constructor:operations_research.MPModelDeltaProto)
}
MPModelDeltaProto::MPModelDeltaProto(const MPModelDeltaProto& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  variable_overrides_.MergeFrom(from.variable_overrides_);
  constraint_overrides_.MergeFrom(from.constraint_overrides_);
  baseline_model_file_path_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from._internal_has_baseline_model_file_path()) {
    baseline_model_file_path_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_baseline_model_file_path(), 
      GetArenaForAllocation());
  }
  // @@protoc_insertion_point(copy_constructor:operations_research.MPModelDeltaProto)
}

inline void MPModelDeltaProto::SharedCtor() {
baseline_model_file_path_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}

MPModelDeltaProto::~MPModelDeltaProto() {
  // @@protoc_insertion_point(destructor:operations_research.MPModelDeltaProto)
  if (GetArenaForAllocation() != nullptr) return;
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

inline void MPModelDeltaProto::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  baseline_model_file_path_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}

void MPModelDeltaProto::ArenaDtor(void* object) {
  MPModelDeltaProto* _this = reinterpret_cast< MPModelDeltaProto* >(object);
  (void)_this;
  _this->variable_overrides_. ~MapField();
  _this->constraint_overrides_. ~MapField();
}
inline void MPModelDeltaProto::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena) {
  if (arena != nullptr) {
    arena->OwnCustomDestructor(this, &MPModelDeltaProto::ArenaDtor);
  }
}
void MPModelDeltaProto::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void MPModelDeltaProto::Clear() {
// @@protoc_insertion_point(message_clear_start:operations_research.MPModelDeltaProto)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  variable_overrides_.Clear();
  constraint_overrides_.Clear();
  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    baseline_model_file_path_.ClearNonDefaultToEmpty();
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* MPModelDeltaProto::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // optional string baseline_model_file_path = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
          auto str = _internal_mutable_baseline_model_file_path();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          #ifndef NDEBUG
          ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "operations_research.MPModelDeltaProto.baseline_model_file_path");
          #endif  // !NDEBUG
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // map<int32, .operations_research.MPVariableProto> variable_overrides = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
          ptr -= 1;
          do {
            ptr += 1;
            ptr = ctx->ParseMessage(&variable_overrides_, ptr);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr));
        } else goto handle_unusual;
        continue;
      // map<int32, .operations_research.MPConstraintProto> constraint_overrides = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) {
          ptr -= 1;
          do {
            ptr += 1;
            ptr = ctx->ParseMessage(&constraint_overrides_, ptr);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<26>(ptr));
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag == 0) || ((tag & 7) == 4)) {
          CHK_(ptr);
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag,
            _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
            ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* MPModelDeltaProto::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:operations_research.MPModelDeltaProto)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional string baseline_model_file_path = 1;
  if (cached_has_bits & 0x00000001u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
      this->_internal_baseline_model_file_path().data(), static_cast<int>(this->_internal_baseline_model_file_path().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
      "operations_research.MPModelDeltaProto.baseline_model_file_path");
    target = stream->WriteStringMaybeAliased(
        1, this->_internal_baseline_model_file_path(), target);
  }

  // map<int32, .operations_research.MPVariableProto> variable_overrides = 2;
  if (!this->_internal_variable_overrides().empty()) {
    typedef ::PROTOBUF_NAMESPACE_ID::Map< ::PROTOBUF_NAMESPACE_ID::int32, ::operations_research::MPVariableProto >::const_pointer
        ConstPtr;
    typedef ::PROTOBUF_NAMESPACE_ID::internal::SortItem< ::PROTOBUF_NAMESPACE_ID::int32, ConstPtr > SortItem;
    typedef ::PROTOBUF_NAMESPACE_ID::internal::CompareByFirstField<SortItem> Less;

    if (stream->IsSerializationDeterministic() &&
        this->_internal_variable_overrides().size() > 1) {
      ::std::unique_ptr<SortItem[]> items(
          new SortItem[this->_internal_variable_overrides().size()]);
      typedef ::PROTOBUF_NAMESPACE_ID::Map< ::PROTOBUF_NAMESPACE_ID::int32, ::operations_research::MPVariableProto >::size_type size_type;
      size_type n = 0;
      for (::PROTOBUF_NAMESPACE_ID::Map< ::PROTOBUF_NAMESPACE_ID::int32, ::operations_research::MPVariableProto >::const_iterator
          it = this->_internal_variable_overrides().begin();
          it != this->_internal_variable_overrides().end(); ++it, ++n) {
        items[static_cast<ptrdiff_t>(n)] = SortItem(&*it);
      }
      ::std::sort(&items[0], &items[static_cast<ptrdiff_t>(n)], Less());
      for (size_type i = 0; i < n; i++) {
        target = MPModelDeltaProto_VariableOverridesEntry_DoNotUse::Funcs::InternalSerialize(2, items[static_cast<ptrdiff_t>(i)].second->first, items[static_cast<ptrdiff_t>(i)].second->second, target, stream);
      }
    } else {
      for (::PROTOBUF_NAMESPACE_ID::Map< ::PROTOBUF_NAMESPACE_ID::int32, ::operations_research::MPVariableProto >::const_iterator
          it = this->_internal_variable_overrides().begin();
          it != this->_internal_variable_overrides().end(); ++it) {
        target = MPModelDeltaProto_VariableOverridesEntry_DoNotUse::Funcs::InternalSerialize(2, it->first, it->second, target, stream);
      }
    }
  }

  // map<int32, .operations_research.MPConstraintProto> constraint_overrides = 3;
  if (!this->_internal_constraint_overrides().empty()) {
    typedef ::PROTOBUF_NAMESPACE_ID::Map< ::PROTOBUF_NAMESPACE_ID::int32, ::operations_research::MPConstraintProto >::const_pointer
        ConstPtr;
    typedef ::PROTOBUF_NAMESPACE_ID::internal::SortItem< ::PROTOBUF_NAMESPACE_ID::int32, ConstPtr > SortItem;
    typedef ::PROTOBUF_NAMESPACE_ID::internal::CompareByFirstField<SortItem> Less;

    if (stream->IsSerializationDeterministic() &&
        this->_internal_constraint_overrides().size() > 1) {
      ::std::unique_ptr<SortItem[]> items(
          new SortItem[this->_internal_constraint_overrides().size()]);
      typedef ::PROTOBUF_NAMESPACE_ID::Map< ::PROTOBUF_NAMESPACE_ID::int32, ::operations_research::MPConstraintProto >::size_type size_type;
      size_type n = 0;
      for (::PROTOBUF_NAMESPACE_ID::Map< ::PROTOBUF_NAMESPACE_ID::int32, ::operations_research::MPConstraintProto >::const_iterator
          it = this->_internal_constraint_overrides().begin();
          it != this->_internal_constraint_overrides().end(); ++it, ++n) {
        items[static_cast<ptrdiff_t>(n)] = SortItem(&*it);
      }
      ::std::sort(&items[0], &items[static_cast<ptrdiff_t>(n)], Less());
      for (size_type i = 0; i < n; i++) {
        target = MPModelDeltaProto_ConstraintOverridesEntry_DoNotUse::Funcs::InternalSerialize(3, items[static_cast<ptrdiff_t>(i)].second->first, items[static_cast<ptrdiff_t>(i)].second->second, target, stream);
      }
    } else {
      for (::PROTOBUF_NAMESPACE_ID::Map< ::PROTOBUF_NAMESPACE_ID::int32, ::operations_research::MPConstraintProto >::const_iterator
          it = this->_internal_constraint_overrides().begin();
          it != this->_internal_constraint_overrides().end(); ++it) {
        target = MPModelDeltaProto_ConstraintOverridesEntry_DoNotUse::Funcs::InternalSerialize(3, it->first, it->second, target, stream);
      }
    }
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:operations_research.MPModelDeltaProto)
  return target;
}

size_t MPModelDeltaProto::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:operations_research.MPModelDeltaProto)
  size_t total_size = 0;

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // map<int32, .operations_research.MPVariableProto> variable_overrides = 2;
  total_size += 1 *
      ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->_internal_variable_overrides_size());
  for (::PROTOBUF_NAMESPACE_ID::Map< ::PROTOBUF_NAMESPACE_ID::int32, ::operations_research::MPVariableProto >::const_iterator
      it = this->_internal_variable_overrides().begin();
      it != this->_internal_variable_overrides().end(); ++it) {
    total_size += MPModelDeltaProto_VariableOverridesEntry_DoNotUse::Funcs::ByteSizeLong(it->first, it->second);
  }

  // map<int32, .operations_research.MPConstraintProto> constraint_overrides = 3;
  total_size += 1 *
      ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->_internal_constraint_overrides_size());
  for (::PROTOBUF_NAMESPACE_ID::Map< ::PROTOBUF_NAMESPACE_ID::int32, ::operations_research::MPConstraintProto >::const_iterator
      it = this->_internal_constraint_overrides().begin();
      it != this->_internal_constraint_overrides().end(); ++it) {
    total_size += MPModelDeltaProto_ConstraintOverridesEntry_DoNotUse::Funcs::ByteSizeLong(it->first, it->second);
  }

  // optional string baseline_model_file_path = 1;
  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    total_size += 1 +
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
        this->_internal_baseline_model_file_path());
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize(
        _internal_metadata_, total_size, &_cached_size_);
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData MPModelDeltaProto::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
    MPModelDeltaProto::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*MPModelDeltaProto::GetClassData() const { return &_class_data_; }

void MPModelDeltaProto::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to,
                      const ::PROTOBUF_NAMESPACE_ID::Message&from) {
  static_cast<MPModelDeltaProto *>(to)->MergeFrom(
      static_cast<const MPModelDeltaProto &>(from));
}


void MPModelDeltaProto::MergeFrom(const MPModelDeltaProto& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:operations_research.MPModelDeltaProto)
  GOOGLE_DCHECK_NE(&from, this);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  variable_overrides_.MergeFrom(from.variable_overrides_);
  constraint_overrides_.MergeFrom(from.constraint_overrides_);
  if (from._internal_has_baseline_model_file_path()) {
    _internal_set_baseline_model_file_path(from._internal_baseline_model_file_path());
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

void MPModelDeltaProto::CopyFrom(const MPModelDeltaProto& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:operations_research.MPModelDeltaProto)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool MPModelDeltaProto::IsInitialized() const {
  return true;
}

void MPModelDeltaProto::InternalSwap(MPModelDeltaProto* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  variable_overrides_.InternalSwap(&other->variable_overrides_);
  constraint_overrides_.InternalSwap(&other->constraint_overrides_);
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
      &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      &baseline_model_file_path_, GetArenaForAllocation(),
      &other->baseline_model_file_path_, other->GetArenaForAllocation()
  );
}

::PROTOBUF_NAMESPACE_ID::Metadata MPModelDeltaProto::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_ortools_2flinear_5fsolver_2flinear_5fsolver_2eproto_getter, &descriptor_table_ortools_2flinear_5fsolver_2flinear_5fsolver_2eproto_once,
      file_level_metadata_ortools_2flinear_5fsolver_2flinear_5fsolver_2eproto[16]);
}

// ===================================================================

class MPModelRequest::_Internal {
 public:
  using HasBits = decltype(std::declval<MPModelRequest>()._has_bits_);
  static const ::operations_research::MPModelProto& model(const MPModelRequest* msg);
  static void set_has_model(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
  static void set_has_solver_type(HasBits* has_bits) {
    (*has_bits)[0] |= 128u;
  }
  static void set_has_solver_time_limit_seconds(HasBits* has_bits) {
    (*has_bits)[0] |= 8u;
  }
  static void set_has_enable_internal_solver_output(HasBits* has_bits) {
    (*has_bits)[0] |= 16u;
  }
  static void set_has_solver_specific_parameters(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static void set_has_ignore_solver_specific_parameters_failure(HasBits* has_bits) {
    (*has_bits)[0] |= 32u;
  }
  static const ::operations_research::MPModelDeltaProto& model_delta(const MPModelRequest* msg);
  static void set_has_model_delta(HasBits* has_bits) {
    (*has_bits)[0] |= 4u;
  }
  static void set_has_populate_additional_solutions_up_to(HasBits* has_bits) {
    (*has_bits)[0] |= 64u;
  }
};

const ::operations_research::MPModelProto&
MPModelRequest::_Internal::model(const MPModelRequest* msg) {
  return *msg->model_;
}
const ::operations_research::MPModelDeltaProto&
MPModelRequest::_Internal::model_delta(const MPModelRequest* msg) {
  return *msg->model_delta_;
}
MPModelRequest::MPModelRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
  SharedCtor();
  if (!is_message_owned) {
    RegisterArenaDtor(arena);
  }
  // @@protoc_insertion_point(arena_constructor:operations_research.MPModelRequest)
}
MPModelRequest::MPModelRequest(const MPModelRequest& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  solver_specific_parameters_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from._internal_has_solver_specific_parameters()) {
    solver_specific_parameters_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_solver_specific_parameters(), 
      GetArenaForAllocation());
  }
  if (from._internal_has_model()) {
    model_ = new ::operations_research::MPModelProto(*from.model_);
  } else {
    model_ = nullptr;
  }
  if (from._internal_has_model_delta()) {
    model_delta_ = new ::operations_research::MPModelDeltaProto(*from.model_delta_);
  } else {
    model_delta_ = nullptr;
  }
  ::memcpy(&solver_time_limit_seconds_, &from.solver_time_limit_seconds_,
    static_cast<size_t>(reinterpret_cast<char*>(&solver_type_) -
    reinterpret_cast<char*>(&solver_time_limit_seconds_)) + sizeof(solver_type_));
  // @@protoc_insertion_point(copy_constructor:operations_research.MPModelRequest)
}

inline void MPModelRequest::SharedCtor() {
solver_specific_parameters_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
    reinterpret_cast<char*>(&model_) - reinterpret_cast<char*>(this)),
    0, static_cast<size_t>(reinterpret_cast<char*>(&populate_additional_solutions_up_to_) -
    reinterpret_cast<char*>(&model_)) + sizeof(populate_additional_solutions_up_to_));
solver_type_ = 2;
}

MPModelRequest::~MPModelRequest() {
  // @@protoc_insertion_point(destructor:operations_research.MPModelRequest)
  if (GetArenaForAllocation() != nullptr) return;
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

inline void MPModelRequest::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  solver_specific_parameters_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (this != internal_default_instance()) delete model_;
  if (this != internal_default_instance()) delete model_delta_;
}

void MPModelRequest::ArenaDtor(void* object) {
  MPModelRequest* _this = reinterpret_cast< MPModelRequest* >(object);
  (void)_this;
}
void MPModelRequest::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void MPModelRequest::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void MPModelRequest::Clear() {
// @@protoc_insertion_point(message_clear_start:operations_research.MPModelRequest)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000007u) {
    if (cached_has_bits & 0x00000001u) {
      solver_specific_parameters_.ClearNonDefaultToEmpty();
    }
    if (cached_has_bits & 0x00000002u) {
      GOOGLE_DCHECK(model_ != nullptr);
      model_->Clear();
    }
    if (cached_has_bits & 0x00000004u) {
      GOOGLE_DCHECK(model_delta_ != nullptr);
      model_delta_->Clear();
    }
  }
  if (cached_has_bits & 0x000000f8u) {
    ::memset(&solver_time_limit_seconds_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&populate_additional_solutions_up_to_) -
        reinterpret_cast<char*>(&solver_time_limit_seconds_)) + sizeof(populate_additional_solutions_up_to_));
    solver_type_ = 2;
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* MPModelRequest::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // optional .operations_research.MPModelProto model = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
          ptr = ctx->ParseMessage(_internal_mutable_model(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .operations_research.MPModelRequest.SolverType solver_type = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
          ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
          if (PROTOBUF_PREDICT_TRUE(::operations_research::MPModelRequest_SolverType_IsValid(val))) {
            _internal_set_solver_type(static_cast<::operations_research::MPModelRequest_SolverType>(val));
          } else {
            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(2, val, mutable_unknown_fields());
          }
        } else goto handle_unusual;
        continue;
      // optional double solver_time_limit_seconds = 3;
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 25)) {
          _Internal::set_has_solver_time_limit_seconds(&has_bits);
          solver_time_limit_seconds_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<double>(ptr);
          ptr += sizeof(double);
        } else goto handle_unusual;
        continue;
      // optional bool enable_internal_solver_output = 4 [default = false];
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 32)) {
          _Internal::set_has_enable_internal_solver_output(&has_bits);
          enable_internal_solver_output_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional string solver_specific_parameters = 5;
      case 5:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 42)) {
          auto str = _internal_mutable_solver_specific_parameters();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          #ifndef NDEBUG
          ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "operations_research.MPModelRequest.solver_specific_parameters");
          #endif  // !NDEBUG
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional .operations_research.MPModelDeltaProto model_delta = 8;
      case 8:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 66)) {
          ptr = ctx->ParseMessage(_internal_mutable_model_delta(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional bool ignore_solver_specific_parameters_failure = 9 [default = false];
      case 9:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 72)) {
          _Internal::set_has_ignore_solver_specific_parameters_failure(&has_bits);
          ignore_solver_specific_parameters_failure_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // optional int32 populate_additional_solutions_up_to = 11 [default = 0];
      case 11:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 88)) {
          _Internal::set_has_populate_additional_solutions_up_to(&has_bits);
          populate_additional_solutions_up_to_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag == 0) || ((tag & 7) == 4)) {
          CHK_(ptr);
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag,
            _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
            ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* MPModelRequest::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:operations_research.MPModelRequest)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional .operations_research.MPModelProto model = 1;
  if (cached_has_bits & 0x00000002u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        1, _Internal::model(this), target, stream);
  }

  // optional .operations_research.MPModelRequest.SolverType solver_type = 2;
  if (cached_has_bits & 0x00000080u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
      2, this->_internal_solver_type(), target);
  }

  // optional double solver_time_limit_seconds = 3;
  if (cached_has_bits & 0x00000008u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteDoubleToArray(3, this->_internal_solver_time_limit_seconds(), target);
  }

  // optional bool enable_internal_solver_output = 4 [default = false];
  if (cached_has_bits & 0x00000010u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(4, this->_internal_enable_internal_solver_output(), target);
  }

  // optional string solver_specific_parameters = 5;
  if (cached_has_bits & 0x00000001u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
      this->_internal_solver_specific_parameters().data(), static_cast<int>(this->_internal_solver_specific_parameters().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
      "operations_research.MPModelRequest.solver_specific_parameters");
    target = stream->WriteStringMaybeAliased(
        5, this->_internal_solver_specific_parameters(), target);
  }

  // optional .operations_research.MPModelDeltaProto model_delta = 8;
  if (cached_has_bits & 0x00000004u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        8, _Internal::model_delta(this), target, stream);
  }

  // optional bool ignore_solver_specific_parameters_failure = 9 [default = false];
  if (cached_has_bits & 0x00000020u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(9, this->_internal_ignore_solver_specific_parameters_failure(), target);
  }

  // optional int32 populate_additional_solutions_up_to = 11 [default = 0];
  if (cached_has_bits & 0x00000040u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(11, this->_internal_populate_additional_solutions_up_to(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:operations_research.MPModelRequest)
  return target;
}

size_t MPModelRequest::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:operations_research.MPModelRequest)
  size_t total_size = 0;

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x000000ffu) {
    // optional string solver_specific_parameters = 5;
    if (cached_has_bits & 0x00000001u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
          this->_internal_solver_specific_parameters());
    }

    // optional .operations_research.MPModelProto model = 1;
    if (cached_has_bits & 0x00000002u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *model_);
    }

    // optional .operations_research.MPModelDeltaProto model_delta = 8;
    if (cached_has_bits & 0x00000004u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *model_delta_);
    }

    // optional double solver_time_limit_seconds = 3;
    if (cached_has_bits & 0x00000008u) {
      total_size += 1 + 8;
    }

    // optional bool enable_internal_solver_output = 4 [default = false];
    if (cached_has_bits & 0x00000010u) {
      total_size += 1 + 1;
    }

    // optional bool ignore_solver_specific_parameters_failure = 9 [default = false];
    if (cached_has_bits & 0x00000020u) {
      total_size += 1 + 1;
    }

    // optional int32 populate_additional_solutions_up_to = 11 [default = 0];
    if (cached_has_bits & 0x00000040u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
          this->_internal_populate_additional_solutions_up_to());
    }

    // optional .operations_research.MPModelRequest.SolverType solver_type = 2;
    if (cached_has_bits & 0x00000080u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_solver_type());
    }

  }
  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize(
        _internal_metadata_, total_size, &_cached_size_);
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData MPModelRequest::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
    MPModelRequest::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*MPModelRequest::GetClassData() const { return &_class_data_; }

void MPModelRequest::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to,
                      const ::PROTOBUF_NAMESPACE_ID::Message&from) {
  static_cast<MPModelRequest *>(to)->MergeFrom(
      static_cast<const MPModelRequest &>(from));
}


void MPModelRequest::MergeFrom(const MPModelRequest& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:operations_research.MPModelRequest)
  GOOGLE_DCHECK_NE(&from, this);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 0x000000ffu) {
    if (cached_has_bits & 0x00000001u) {
      _internal_set_solver_specific_parameters(from._internal_solver_specific_parameters());
    }
    if (cached_has_bits & 0x00000002u) {
      _internal_mutable_model()->::operations_research::MPModelProto::MergeFrom(from._internal_model());
    }
    if (cached_has_bits & 0x00000004u) {
      _internal_mutable_model_delta()->::operations_research::MPModelDeltaProto::MergeFrom(from._internal_model_delta());
    }
    if (cached_has_bits & 0x00000008u) {
      solver_time_limit_seconds_ = from.solver_time_limit_seconds_;
    }
    if (cached_has_bits & 0x00000010u) {
      enable_internal_solver_output_ = from.enable_internal_solver_output_;
    }
    if (cached_has_bits & 0x00000020u) {
      ignore_solver_specific_parameters_failure_ = from.ignore_solver_specific_parameters_failure_;
    }
    if (cached_has_bits & 0x00000040u) {
      populate_additional_solutions_up_to_ = from.populate_additional_solutions_up_to_;
    }
    if (cached_has_bits & 0x00000080u) {
      solver_type_ = from.solver_type_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

void MPModelRequest::CopyFrom(const MPModelRequest& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:operations_research.MPModelRequest)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool MPModelRequest::IsInitialized() const {
  return true;
}

void MPModelRequest::InternalSwap(MPModelRequest* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
      &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      &solver_specific_parameters_, GetArenaForAllocation(),
      &other->solver_specific_parameters_, other->GetArenaForAllocation()
  );
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(MPModelRequest, populate_additional_solutions_up_to_)
      + sizeof(MPModelRequest::populate_additional_solutions_up_to_)
      - PROTOBUF_FIELD_OFFSET(MPModelRequest, model_)>(
          reinterpret_cast<char*>(&model_),
          reinterpret_cast<char*>(&other->model_));
  swap(solver_type_, other->solver_type_);
}

::PROTOBUF_NAMESPACE_ID::Metadata MPModelRequest::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_ortools_2flinear_5fsolver_2flinear_5fsolver_2eproto_getter, &descriptor_table_ortools_2flinear_5fsolver_2flinear_5fsolver_2eproto_once,
      file_level_metadata_ortools_2flinear_5fsolver_2flinear_5fsolver_2eproto[17]);
}

// ===================================================================

class MPSolution::_Internal {
 public:
  using HasBits = decltype(std::declval<MPSolution>()._has_bits_);
  static void set_has_objective_value(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
};

MPSolution::MPSolution(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned),
  variable_value_(arena) {
  SharedCtor();
  if (!is_message_owned) {
    RegisterArenaDtor(arena);
  }
  // @@protoc_insertion_point(arena_constructor:operations_research.MPSolution)
}
MPSolution::MPSolution(const MPSolution& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _has_bits_(from._has_bits_),
      variable_value_(from.variable_value_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  objective_value_ = from.objective_value_;
  // @@protoc_insertion_point(copy_constructor:operations_research.MPSolution)
}

inline void MPSolution::SharedCtor() {
objective_value_ = 0;
}

MPSolution::~MPSolution() {
  // @@protoc_insertion_point(destructor:operations_research.MPSolution)
  if (GetArenaForAllocation() != nullptr) return;
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

inline void MPSolution::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
}

void MPSolution::ArenaDtor(void* object) {
  MPSolution* _this = reinterpret_cast< MPSolution* >(object);
  (void)_this;
}
void MPSolution::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void MPSolution::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void MPSolution::Clear() {
// @@protoc_insertion_point(message_clear_start:operations_research.MPSolution)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  variable_value_.Clear();
  objective_value_ = 0;
  _has_bits_.Clear();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* MPSolution::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // optional double objective_value = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 9)) {
          _Internal::set_has_objective_value(&has_bits);
          objective_value_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<double>(ptr);
          ptr += sizeof(double);
        } else goto handle_unusual;
        continue;
      // repeated double variable_value = 2 [packed = true];
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedDoubleParser(_internal_mutable_variable_value(), ptr, ctx);
          CHK_(ptr);
        } else if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 17) {
          _internal_add_variable_value(::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<double>(ptr));
          ptr += sizeof(double);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag == 0) || ((tag & 7) == 4)) {
          CHK_(ptr);
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag,
            _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
            ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* MPSolution::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:operations_research.MPSolution)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional double objective_value = 1;
  if (cached_has_bits & 0x00000001u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteDoubleToArray(1, this->_internal_objective_value(), target);
  }

  // repeated double variable_value = 2 [packed = true];
  if (this->_internal_variable_value_size() > 0) {
    target = stream->WriteFixedPacked(2, _internal_variable_value(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:operations_research.MPSolution)
  return target;
}

size_t MPSolution::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:operations_research.MPSolution)
  size_t total_size = 0;

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // repeated double variable_value = 2 [packed = true];
  {
    unsigned int count = static_cast<unsigned int>(this->_internal_variable_value_size());
    size_t data_size = 8UL * count;
    if (data_size > 0) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
            static_cast<::PROTOBUF_NAMESPACE_ID::int32>(data_size));
    }
    total_size += data_size;
  }

  // optional double objective_value = 1;
  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000001u) {
    total_size += 1 + 8;
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize(
        _internal_metadata_, total_size, &_cached_size_);
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData MPSolution::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
    MPSolution::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*MPSolution::GetClassData() const { return &_class_data_; }

void MPSolution::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to,
                      const ::PROTOBUF_NAMESPACE_ID::Message&from) {
  static_cast<MPSolution *>(to)->MergeFrom(
      static_cast<const MPSolution &>(from));
}


void MPSolution::MergeFrom(const MPSolution& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:operations_research.MPSolution)
  GOOGLE_DCHECK_NE(&from, this);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  variable_value_.MergeFrom(from.variable_value_);
  if (from._internal_has_objective_value()) {
    _internal_set_objective_value(from._internal_objective_value());
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

void MPSolution::CopyFrom(const MPSolution& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:operations_research.MPSolution)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool MPSolution::IsInitialized() const {
  return true;
}

void MPSolution::InternalSwap(MPSolution* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  variable_value_.InternalSwap(&other->variable_value_);
  swap(objective_value_, other->objective_value_);
}

::PROTOBUF_NAMESPACE_ID::Metadata MPSolution::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_ortools_2flinear_5fsolver_2flinear_5fsolver_2eproto_getter, &descriptor_table_ortools_2flinear_5fsolver_2flinear_5fsolver_2eproto_once,
      file_level_metadata_ortools_2flinear_5fsolver_2flinear_5fsolver_2eproto[18]);
}

// ===================================================================

class MPSolveInfo::_Internal {
 public:
  using HasBits = decltype(std::declval<MPSolveInfo>()._has_bits_);
  static void set_has_solve_wall_time_seconds(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static void set_has_solve_user_time_seconds(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
};

MPSolveInfo::MPSolveInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
  SharedCtor();
  if (!is_message_owned) {
    RegisterArenaDtor(arena);
  }
  // @@protoc_insertion_point(arena_constructor:operations_research.MPSolveInfo)
}
MPSolveInfo::MPSolveInfo(const MPSolveInfo& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _has_bits_(from._has_bits_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  ::memcpy(&solve_wall_time_seconds_, &from.solve_wall_time_seconds_,
    static_cast<size_t>(reinterpret_cast<char*>(&solve_user_time_seconds_) -
    reinterpret_cast<char*>(&solve_wall_time_seconds_)) + sizeof(solve_user_time_seconds_));
  // @@protoc_insertion_point(copy_constructor:operations_research.MPSolveInfo)
}

inline void MPSolveInfo::SharedCtor() {
::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
    reinterpret_cast<char*>(&solve_wall_time_seconds_) - reinterpret_cast<char*>(this)),
    0, static_cast<size_t>(reinterpret_cast<char*>(&solve_user_time_seconds_) -
    reinterpret_cast<char*>(&solve_wall_time_seconds_)) + sizeof(solve_user_time_seconds_));
}

MPSolveInfo::~MPSolveInfo() {
  // @@protoc_insertion_point(destructor:operations_research.MPSolveInfo)
  if (GetArenaForAllocation() != nullptr) return;
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

inline void MPSolveInfo::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
}

void MPSolveInfo::ArenaDtor(void* object) {
  MPSolveInfo* _this = reinterpret_cast< MPSolveInfo* >(object);
  (void)_this;
}
void MPSolveInfo::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void MPSolveInfo::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void MPSolveInfo::Clear() {
// @@protoc_insertion_point(message_clear_start:operations_research.MPSolveInfo)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    ::memset(&solve_wall_time_seconds_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&solve_user_time_seconds_) -
        reinterpret_cast<char*>(&solve_wall_time_seconds_)) + sizeof(solve_user_time_seconds_));
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* MPSolveInfo::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // optional double solve_wall_time_seconds = 1;
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 9)) {
          _Internal::set_has_solve_wall_time_seconds(&has_bits);
          solve_wall_time_seconds_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<double>(ptr);
          ptr += sizeof(double);
        } else goto handle_unusual;
        continue;
      // optional double solve_user_time_seconds = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 17)) {
          _Internal::set_has_solve_user_time_seconds(&has_bits);
          solve_user_time_seconds_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<double>(ptr);
          ptr += sizeof(double);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag == 0) || ((tag & 7) == 4)) {
          CHK_(ptr);
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag,
            _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
            ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* MPSolveInfo::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:operations_research.MPSolveInfo)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional double solve_wall_time_seconds = 1;
  if (cached_has_bits & 0x00000001u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteDoubleToArray(1, this->_internal_solve_wall_time_seconds(), target);
  }

  // optional double solve_user_time_seconds = 2;
  if (cached_has_bits & 0x00000002u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteDoubleToArray(2, this->_internal_solve_user_time_seconds(), target);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:operations_research.MPSolveInfo)
  return target;
}

size_t MPSolveInfo::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:operations_research.MPSolveInfo)
  size_t total_size = 0;

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    // optional double solve_wall_time_seconds = 1;
    if (cached_has_bits & 0x00000001u) {
      total_size += 1 + 8;
    }

    // optional double solve_user_time_seconds = 2;
    if (cached_has_bits & 0x00000002u) {
      total_size += 1 + 8;
    }

  }
  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize(
        _internal_metadata_, total_size, &_cached_size_);
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData MPSolveInfo::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
    MPSolveInfo::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*MPSolveInfo::GetClassData() const { return &_class_data_; }

void MPSolveInfo::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to,
                      const ::PROTOBUF_NAMESPACE_ID::Message&from) {
  static_cast<MPSolveInfo *>(to)->MergeFrom(
      static_cast<const MPSolveInfo &>(from));
}


void MPSolveInfo::MergeFrom(const MPSolveInfo& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:operations_research.MPSolveInfo)
  GOOGLE_DCHECK_NE(&from, this);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    if (cached_has_bits & 0x00000001u) {
      solve_wall_time_seconds_ = from.solve_wall_time_seconds_;
    }
    if (cached_has_bits & 0x00000002u) {
      solve_user_time_seconds_ = from.solve_user_time_seconds_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

void MPSolveInfo::CopyFrom(const MPSolveInfo& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:operations_research.MPSolveInfo)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool MPSolveInfo::IsInitialized() const {
  return true;
}

void MPSolveInfo::InternalSwap(MPSolveInfo* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(MPSolveInfo, solve_user_time_seconds_)
      + sizeof(MPSolveInfo::solve_user_time_seconds_)
      - PROTOBUF_FIELD_OFFSET(MPSolveInfo, solve_wall_time_seconds_)>(
          reinterpret_cast<char*>(&solve_wall_time_seconds_),
          reinterpret_cast<char*>(&other->solve_wall_time_seconds_));
}

::PROTOBUF_NAMESPACE_ID::Metadata MPSolveInfo::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_ortools_2flinear_5fsolver_2flinear_5fsolver_2eproto_getter, &descriptor_table_ortools_2flinear_5fsolver_2flinear_5fsolver_2eproto_once,
      file_level_metadata_ortools_2flinear_5fsolver_2flinear_5fsolver_2eproto[19]);
}

// ===================================================================

class MPSolutionResponse::_Internal {
 public:
  using HasBits = decltype(std::declval<MPSolutionResponse>()._has_bits_);
  static void set_has_status(HasBits* has_bits) {
    (*has_bits)[0] |= 16u;
  }
  static void set_has_status_str(HasBits* has_bits) {
    (*has_bits)[0] |= 1u;
  }
  static void set_has_objective_value(HasBits* has_bits) {
    (*has_bits)[0] |= 4u;
  }
  static void set_has_best_objective_bound(HasBits* has_bits) {
    (*has_bits)[0] |= 8u;
  }
  static const ::operations_research::MPSolveInfo& solve_info(const MPSolutionResponse* msg);
  static void set_has_solve_info(HasBits* has_bits) {
    (*has_bits)[0] |= 2u;
  }
};

const ::operations_research::MPSolveInfo&
MPSolutionResponse::_Internal::solve_info(const MPSolutionResponse* msg) {
  return *msg->solve_info_;
}
MPSolutionResponse::MPSolutionResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned)
  : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned),
  variable_value_(arena),
  dual_value_(arena),
  reduced_cost_(arena),
  additional_solutions_(arena) {
  SharedCtor();
  if (!is_message_owned) {
    RegisterArenaDtor(arena);
  }
  // @@protoc_insertion_point(arena_constructor:operations_research.MPSolutionResponse)
}
MPSolutionResponse::MPSolutionResponse(const MPSolutionResponse& from)
  : ::PROTOBUF_NAMESPACE_ID::Message(),
      _has_bits_(from._has_bits_),
      variable_value_(from.variable_value_),
      dual_value_(from.dual_value_),
      reduced_cost_(from.reduced_cost_),
      additional_solutions_(from.additional_solutions_) {
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
  status_str_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (from._internal_has_status_str()) {
    status_str_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_status_str(), 
      GetArenaForAllocation());
  }
  if (from._internal_has_solve_info()) {
    solve_info_ = new ::operations_research::MPSolveInfo(*from.solve_info_);
  } else {
    solve_info_ = nullptr;
  }
  ::memcpy(&objective_value_, &from.objective_value_,
    static_cast<size_t>(reinterpret_cast<char*>(&status_) -
    reinterpret_cast<char*>(&objective_value_)) + sizeof(status_));
  // @@protoc_insertion_point(copy_constructor:operations_research.MPSolutionResponse)
}

inline void MPSolutionResponse::SharedCtor() {
status_str_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
    reinterpret_cast<char*>(&solve_info_) - reinterpret_cast<char*>(this)),
    0, static_cast<size_t>(reinterpret_cast<char*>(&best_objective_bound_) -
    reinterpret_cast<char*>(&solve_info_)) + sizeof(best_objective_bound_));
status_ = 99;
}

MPSolutionResponse::~MPSolutionResponse() {
  // @@protoc_insertion_point(destructor:operations_research.MPSolutionResponse)
  if (GetArenaForAllocation() != nullptr) return;
  SharedDtor();
  _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

inline void MPSolutionResponse::SharedDtor() {
  GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
  status_str_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  if (this != internal_default_instance()) delete solve_info_;
}

void MPSolutionResponse::ArenaDtor(void* object) {
  MPSolutionResponse* _this = reinterpret_cast< MPSolutionResponse* >(object);
  (void)_this;
}
void MPSolutionResponse::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
}
void MPSolutionResponse::SetCachedSize(int size) const {
  _cached_size_.Set(size);
}

void MPSolutionResponse::Clear() {
// @@protoc_insertion_point(message_clear_start:operations_research.MPSolutionResponse)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  variable_value_.Clear();
  dual_value_.Clear();
  reduced_cost_.Clear();
  additional_solutions_.Clear();
  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x00000003u) {
    if (cached_has_bits & 0x00000001u) {
      status_str_.ClearNonDefaultToEmpty();
    }
    if (cached_has_bits & 0x00000002u) {
      GOOGLE_DCHECK(solve_info_ != nullptr);
      solve_info_->Clear();
    }
  }
  if (cached_has_bits & 0x0000001cu) {
    ::memset(&objective_value_, 0, static_cast<size_t>(
        reinterpret_cast<char*>(&best_objective_bound_) -
        reinterpret_cast<char*>(&objective_value_)) + sizeof(best_objective_bound_));
    status_ = 99;
  }
  _has_bits_.Clear();
  _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
}

const char* MPSolutionResponse::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  _Internal::HasBits has_bits{};
  while (!ctx->Done(&ptr)) {
    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
    switch (tag >> 3) {
      // optional .operations_research.MPSolverResponseStatus status = 1 [default = MPSOLVER_UNKNOWN_STATUS];
      case 1:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
          ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
          CHK_(ptr);
          if (PROTOBUF_PREDICT_TRUE(::operations_research::MPSolverResponseStatus_IsValid(val))) {
            _internal_set_status(static_cast<::operations_research::MPSolverResponseStatus>(val));
          } else {
            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(1, val, mutable_unknown_fields());
          }
        } else goto handle_unusual;
        continue;
      // optional double objective_value = 2;
      case 2:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 17)) {
          _Internal::set_has_objective_value(&has_bits);
          objective_value_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<double>(ptr);
          ptr += sizeof(double);
        } else goto handle_unusual;
        continue;
      // repeated double variable_value = 3 [packed = true];
      case 3:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) {
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedDoubleParser(_internal_mutable_variable_value(), ptr, ctx);
          CHK_(ptr);
        } else if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 25) {
          _internal_add_variable_value(::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<double>(ptr));
          ptr += sizeof(double);
        } else goto handle_unusual;
        continue;
      // repeated double dual_value = 4 [packed = true];
      case 4:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) {
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedDoubleParser(_internal_mutable_dual_value(), ptr, ctx);
          CHK_(ptr);
        } else if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 33) {
          _internal_add_dual_value(::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<double>(ptr));
          ptr += sizeof(double);
        } else goto handle_unusual;
        continue;
      // optional double best_objective_bound = 5;
      case 5:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 41)) {
          _Internal::set_has_best_objective_bound(&has_bits);
          best_objective_bound_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<double>(ptr);
          ptr += sizeof(double);
        } else goto handle_unusual;
        continue;
      // repeated double reduced_cost = 6 [packed = true];
      case 6:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 50)) {
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedDoubleParser(_internal_mutable_reduced_cost(), ptr, ctx);
          CHK_(ptr);
        } else if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 49) {
          _internal_add_reduced_cost(::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<double>(ptr));
          ptr += sizeof(double);
        } else goto handle_unusual;
        continue;
      // optional string status_str = 7;
      case 7:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 58)) {
          auto str = _internal_mutable_status_str();
          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
          #ifndef NDEBUG
          ::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "operations_research.MPSolutionResponse.status_str");
          #endif  // !NDEBUG
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      // repeated .operations_research.MPSolution additional_solutions = 8;
      case 8:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 66)) {
          ptr -= 1;
          do {
            ptr += 1;
            ptr = ctx->ParseMessage(_internal_add_additional_solutions(), ptr);
            CHK_(ptr);
            if (!ctx->DataAvailable(ptr)) break;
          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<66>(ptr));
        } else goto handle_unusual;
        continue;
      // optional .operations_research.MPSolveInfo solve_info = 10;
      case 10:
        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 82)) {
          ptr = ctx->ParseMessage(_internal_mutable_solve_info(), ptr);
          CHK_(ptr);
        } else goto handle_unusual;
        continue;
      default: {
      handle_unusual:
        if ((tag == 0) || ((tag & 7) == 4)) {
          CHK_(ptr);
          ctx->SetLastTag(tag);
          goto success;
        }
        ptr = UnknownFieldParse(tag,
            _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
            ptr, ctx);
        CHK_(ptr != nullptr);
        continue;
      }
    }  // switch
  }  // while
success:
  _has_bits_.Or(has_bits);
  return ptr;
failure:
  ptr = nullptr;
  goto success;
#undef CHK_
}

::PROTOBUF_NAMESPACE_ID::uint8* MPSolutionResponse::_InternalSerialize(
    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  // @@protoc_insertion_point(serialize_to_array_start:operations_research.MPSolutionResponse)
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];
  // optional .operations_research.MPSolverResponseStatus status = 1 [default = MPSOLVER_UNKNOWN_STATUS];
  if (cached_has_bits & 0x00000010u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
      1, this->_internal_status(), target);
  }

  // optional double objective_value = 2;
  if (cached_has_bits & 0x00000004u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteDoubleToArray(2, this->_internal_objective_value(), target);
  }

  // repeated double variable_value = 3 [packed = true];
  if (this->_internal_variable_value_size() > 0) {
    target = stream->WriteFixedPacked(3, _internal_variable_value(), target);
  }

  // repeated double dual_value = 4 [packed = true];
  if (this->_internal_dual_value_size() > 0) {
    target = stream->WriteFixedPacked(4, _internal_dual_value(), target);
  }

  // optional double best_objective_bound = 5;
  if (cached_has_bits & 0x00000008u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteDoubleToArray(5, this->_internal_best_objective_bound(), target);
  }

  // repeated double reduced_cost = 6 [packed = true];
  if (this->_internal_reduced_cost_size() > 0) {
    target = stream->WriteFixedPacked(6, _internal_reduced_cost(), target);
  }

  // optional string status_str = 7;
  if (cached_has_bits & 0x00000001u) {
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::VerifyUTF8StringNamedField(
      this->_internal_status_str().data(), static_cast<int>(this->_internal_status_str().length()),
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::SERIALIZE,
      "operations_research.MPSolutionResponse.status_str");
    target = stream->WriteStringMaybeAliased(
        7, this->_internal_status_str(), target);
  }

  // repeated .operations_research.MPSolution additional_solutions = 8;
  for (unsigned int i = 0,
      n = static_cast<unsigned int>(this->_internal_additional_solutions_size()); i < n; i++) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(8, this->_internal_additional_solutions(i), target, stream);
  }

  // optional .operations_research.MPSolveInfo solve_info = 10;
  if (cached_has_bits & 0x00000002u) {
    target = stream->EnsureSpace(target);
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
      InternalWriteMessage(
        10, _Internal::solve_info(this), target, stream);
  }

  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
        _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:operations_research.MPSolutionResponse)
  return target;
}

size_t MPSolutionResponse::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:operations_research.MPSolutionResponse)
  size_t total_size = 0;

  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;

  // repeated double variable_value = 3 [packed = true];
  {
    unsigned int count = static_cast<unsigned int>(this->_internal_variable_value_size());
    size_t data_size = 8UL * count;
    if (data_size > 0) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
            static_cast<::PROTOBUF_NAMESPACE_ID::int32>(data_size));
    }
    total_size += data_size;
  }

  // repeated double dual_value = 4 [packed = true];
  {
    unsigned int count = static_cast<unsigned int>(this->_internal_dual_value_size());
    size_t data_size = 8UL * count;
    if (data_size > 0) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
            static_cast<::PROTOBUF_NAMESPACE_ID::int32>(data_size));
    }
    total_size += data_size;
  }

  // repeated double reduced_cost = 6 [packed = true];
  {
    unsigned int count = static_cast<unsigned int>(this->_internal_reduced_cost_size());
    size_t data_size = 8UL * count;
    if (data_size > 0) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
            static_cast<::PROTOBUF_NAMESPACE_ID::int32>(data_size));
    }
    total_size += data_size;
  }

  // repeated .operations_research.MPSolution additional_solutions = 8;
  total_size += 1UL * this->_internal_additional_solutions_size();
  for (const auto& msg : this->additional_solutions_) {
    total_size +=
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
  }

  cached_has_bits = _has_bits_[0];
  if (cached_has_bits & 0x0000001fu) {
    // optional string status_str = 7;
    if (cached_has_bits & 0x00000001u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
          this->_internal_status_str());
    }

    // optional .operations_research.MPSolveInfo solve_info = 10;
    if (cached_has_bits & 0x00000002u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
          *solve_info_);
    }

    // optional double objective_value = 2;
    if (cached_has_bits & 0x00000004u) {
      total_size += 1 + 8;
    }

    // optional double best_objective_bound = 5;
    if (cached_has_bits & 0x00000008u) {
      total_size += 1 + 8;
    }

    // optional .operations_research.MPSolverResponseStatus status = 1 [default = MPSOLVER_UNKNOWN_STATUS];
    if (cached_has_bits & 0x00000010u) {
      total_size += 1 +
        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_status());
    }

  }
  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
    return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize(
        _internal_metadata_, total_size, &_cached_size_);
  }
  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  SetCachedSize(cached_size);
  return total_size;
}

const ::PROTOBUF_NAMESPACE_ID::Message::ClassData MPSolutionResponse::_class_data_ = {
    ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
    MPSolutionResponse::MergeImpl
};
const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*MPSolutionResponse::GetClassData() const { return &_class_data_; }

void MPSolutionResponse::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to,
                      const ::PROTOBUF_NAMESPACE_ID::Message&from) {
  static_cast<MPSolutionResponse *>(to)->MergeFrom(
      static_cast<const MPSolutionResponse &>(from));
}


void MPSolutionResponse::MergeFrom(const MPSolutionResponse& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:operations_research.MPSolutionResponse)
  GOOGLE_DCHECK_NE(&from, this);
  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  (void) cached_has_bits;

  variable_value_.MergeFrom(from.variable_value_);
  dual_value_.MergeFrom(from.dual_value_);
  reduced_cost_.MergeFrom(from.reduced_cost_);
  additional_solutions_.MergeFrom(from.additional_solutions_);
  cached_has_bits = from._has_bits_[0];
  if (cached_has_bits & 0x0000001fu) {
    if (cached_has_bits & 0x00000001u) {
      _internal_set_status_str(from._internal_status_str());
    }
    if (cached_has_bits & 0x00000002u) {
      _internal_mutable_solve_info()->::operations_research::MPSolveInfo::MergeFrom(from._internal_solve_info());
    }
    if (cached_has_bits & 0x00000004u) {
      objective_value_ = from.objective_value_;
    }
    if (cached_has_bits & 0x00000008u) {
      best_objective_bound_ = from.best_objective_bound_;
    }
    if (cached_has_bits & 0x00000010u) {
      status_ = from.status_;
    }
    _has_bits_[0] |= cached_has_bits;
  }
  _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
}

void MPSolutionResponse::CopyFrom(const MPSolutionResponse& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:operations_research.MPSolutionResponse)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

bool MPSolutionResponse::IsInitialized() const {
  return true;
}

void MPSolutionResponse::InternalSwap(MPSolutionResponse* other) {
  using std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_has_bits_[0], other->_has_bits_[0]);
  variable_value_.InternalSwap(&other->variable_value_);
  dual_value_.InternalSwap(&other->dual_value_);
  reduced_cost_.InternalSwap(&other->reduced_cost_);
  additional_solutions_.InternalSwap(&other->additional_solutions_);
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
      &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      &status_str_, GetArenaForAllocation(),
      &other->status_str_, other->GetArenaForAllocation()
  );
  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
      PROTOBUF_FIELD_OFFSET(MPSolutionResponse, best_objective_bound_)
      + sizeof(MPSolutionResponse::best_objective_bound_)
      - PROTOBUF_FIELD_OFFSET(MPSolutionResponse, solve_info_)>(
          reinterpret_cast<char*>(&solve_info_),
          reinterpret_cast<char*>(&other->solve_info_));
  swap(status_, other->status_);
}

::PROTOBUF_NAMESPACE_ID::Metadata MPSolutionResponse::GetMetadata() const {
  return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
      &descriptor_table_ortools_2flinear_5fsolver_2flinear_5fsolver_2eproto_getter, &descriptor_table_ortools_2flinear_5fsolver_2flinear_5fsolver_2eproto_once,
      file_level_metadata_ortools_2flinear_5fsolver_2flinear_5fsolver_2eproto[20]);
}

// @@protoc_insertion_point(namespace_scope)
}  // namespace operations_research
PROTOBUF_NAMESPACE_OPEN
template<> PROTOBUF_NOINLINE ::operations_research::MPVariableProto* Arena::CreateMaybeMessage< ::operations_research::MPVariableProto >(Arena* arena) {
  return Arena::CreateMessageInternal< ::operations_research::MPVariableProto >(arena);
}
template<> PROTOBUF_NOINLINE ::operations_research::MPConstraintProto* Arena::CreateMaybeMessage< ::operations_research::MPConstraintProto >(Arena* arena) {
  return Arena::CreateMessageInternal< ::operations_research::MPConstraintProto >(arena);
}
template<> PROTOBUF_NOINLINE ::operations_research::MPGeneralConstraintProto* Arena::CreateMaybeMessage< ::operations_research::MPGeneralConstraintProto >(Arena* arena) {
  return Arena::CreateMessageInternal< ::operations_research::MPGeneralConstraintProto >(arena);
}
template<> PROTOBUF_NOINLINE ::operations_research::MPIndicatorConstraint* Arena::CreateMaybeMessage< ::operations_research::MPIndicatorConstraint >(Arena* arena) {
  return Arena::CreateMessageInternal< ::operations_research::MPIndicatorConstraint >(arena);
}
template<> PROTOBUF_NOINLINE ::operations_research::MPSosConstraint* Arena::CreateMaybeMessage< ::operations_research::MPSosConstraint >(Arena* arena) {
  return Arena::CreateMessageInternal< ::operations_research::MPSosConstraint >(arena);
}
template<> PROTOBUF_NOINLINE ::operations_research::MPQuadraticConstraint* Arena::CreateMaybeMessage< ::operations_research::MPQuadraticConstraint >(Arena* arena) {
  return Arena::CreateMessageInternal< ::operations_research::MPQuadraticConstraint >(arena);
}
template<> PROTOBUF_NOINLINE ::operations_research::MPAbsConstraint* Arena::CreateMaybeMessage< ::operations_research::MPAbsConstraint >(Arena* arena) {
  return Arena::CreateMessageInternal< ::operations_research::MPAbsConstraint >(arena);
}
template<> PROTOBUF_NOINLINE ::operations_research::MPArrayConstraint* Arena::CreateMaybeMessage< ::operations_research::MPArrayConstraint >(Arena* arena) {
  return Arena::CreateMessageInternal< ::operations_research::MPArrayConstraint >(arena);
}
template<> PROTOBUF_NOINLINE ::operations_research::MPArrayWithConstantConstraint* Arena::CreateMaybeMessage< ::operations_research::MPArrayWithConstantConstraint >(Arena* arena) {
  return Arena::CreateMessageInternal< ::operations_research::MPArrayWithConstantConstraint >(arena);
}
template<> PROTOBUF_NOINLINE ::operations_research::MPQuadraticObjective* Arena::CreateMaybeMessage< ::operations_research::MPQuadraticObjective >(Arena* arena) {
  return Arena::CreateMessageInternal< ::operations_research::MPQuadraticObjective >(arena);
}
template<> PROTOBUF_NOINLINE ::operations_research::PartialVariableAssignment* Arena::CreateMaybeMessage< ::operations_research::PartialVariableAssignment >(Arena* arena) {
  return Arena::CreateMessageInternal< ::operations_research::PartialVariableAssignment >(arena);
}
template<> PROTOBUF_NOINLINE ::operations_research::MPModelProto* Arena::CreateMaybeMessage< ::operations_research::MPModelProto >(Arena* arena) {
  return Arena::CreateMessageInternal< ::operations_research::MPModelProto >(arena);
}
template<> PROTOBUF_NOINLINE ::operations_research::OptionalDouble* Arena::CreateMaybeMessage< ::operations_research::OptionalDouble >(Arena* arena) {
  return Arena::CreateMessageInternal< ::operations_research::OptionalDouble >(arena);
}
template<> PROTOBUF_NOINLINE ::operations_research::MPSolverCommonParameters* Arena::CreateMaybeMessage< ::operations_research::MPSolverCommonParameters >(Arena* arena) {
  return Arena::CreateMessageInternal< ::operations_research::MPSolverCommonParameters >(arena);
}
template<> PROTOBUF_NOINLINE ::operations_research::MPModelDeltaProto_VariableOverridesEntry_DoNotUse* Arena::CreateMaybeMessage< ::operations_research::MPModelDeltaProto_VariableOverridesEntry_DoNotUse >(Arena* arena) {
  return Arena::CreateMessageInternal< ::operations_research::MPModelDeltaProto_VariableOverridesEntry_DoNotUse >(arena);
}
template<> PROTOBUF_NOINLINE ::operations_research::MPModelDeltaProto_ConstraintOverridesEntry_DoNotUse* Arena::CreateMaybeMessage< ::operations_research::MPModelDeltaProto_ConstraintOverridesEntry_DoNotUse >(Arena* arena) {
  return Arena::CreateMessageInternal< ::operations_research::MPModelDeltaProto_ConstraintOverridesEntry_DoNotUse >(arena);
}
template<> PROTOBUF_NOINLINE ::operations_research::MPModelDeltaProto* Arena::CreateMaybeMessage< ::operations_research::MPModelDeltaProto >(Arena* arena) {
  return Arena::CreateMessageInternal< ::operations_research::MPModelDeltaProto >(arena);
}
template<> PROTOBUF_NOINLINE ::operations_research::MPModelRequest* Arena::CreateMaybeMessage< ::operations_research::MPModelRequest >(Arena* arena) {
  return Arena::CreateMessageInternal< ::operations_research::MPModelRequest >(arena);
}
template<> PROTOBUF_NOINLINE ::operations_research::MPSolution* Arena::CreateMaybeMessage< ::operations_research::MPSolution >(Arena* arena) {
  return Arena::CreateMessageInternal< ::operations_research::MPSolution >(arena);
}
template<> PROTOBUF_NOINLINE ::operations_research::MPSolveInfo* Arena::CreateMaybeMessage< ::operations_research::MPSolveInfo >(Arena* arena) {
  return Arena::CreateMessageInternal< ::operations_research::MPSolveInfo >(arena);
}
template<> PROTOBUF_NOINLINE ::operations_research::MPSolutionResponse* Arena::CreateMaybeMessage< ::operations_research::MPSolutionResponse >(Arena* arena) {
  return Arena::CreateMessageInternal< ::operations_research::MPSolutionResponse >(arena);
}
PROTOBUF_NAMESPACE_CLOSE

// @@protoc_insertion_point(global_scope)
#include <google/protobuf/port_undef.inc>