solve_log.pb.cc

Go to the documentation of this file.

// Generated by the protocol buffer compiler.  DO NOT EDIT!
// NO CHECKED-IN PROTOBUF GENCODE
// source: ortools/pdlp/solve_log.proto
// Protobuf C++ Version: 6.33.1
 
#include "ortools/pdlp/solve_log.pb.h"
 
#include <algorithm>
#include <type_traits>
#include "google/protobuf/io/coded_stream.h"
#include "google/protobuf/generated_message_tctable_impl.h"
#include "google/protobuf/extension_set.h"
#include "google/protobuf/generated_message_util.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)
 
// Must be included last.
#include "google/protobuf/port_def.inc"
PROTOBUF_PRAGMA_INIT_SEG
namespace _pb = ::google::protobuf;
namespace _pbi = ::google::protobuf::internal;
namespace _fl = ::google::protobuf::internal::field_layout;
namespace operations_research {
namespace pdlp {
 
inline constexpr QuadraticProgramStats::Impl_::Impl_(
    ::_pbi::ConstantInitialized) noexcept
      : _cached_size_{0},
        num_variables_{::int64_t{0}},
        num_constraints_{::int64_t{0}},
        constraint_matrix_col_min_l_inf_norm_{0},
        constraint_matrix_row_min_l_inf_norm_{0},
        constraint_matrix_num_nonzeros_{::int64_t{0}},
        constraint_matrix_abs_max_{0},
        constraint_matrix_abs_min_{0},
        constraint_matrix_abs_avg_{0},
        combined_bounds_max_{0},
        combined_bounds_min_{0},
        combined_bounds_avg_{0},
        variable_bound_gaps_num_finite_{::int64_t{0}},
        variable_bound_gaps_max_{0},
        variable_bound_gaps_min_{0},
        variable_bound_gaps_avg_{0},
        objective_vector_abs_max_{0},
        objective_vector_abs_min_{0},
        objective_vector_abs_avg_{0},
        objective_matrix_num_nonzeros_{::int64_t{0}},
        objective_matrix_abs_max_{0},
        objective_matrix_abs_min_{0},
        objective_matrix_abs_avg_{0},
        objective_vector_l2_norm_{0},
        combined_bounds_l2_norm_{0},
        constraint_matrix_l2_norm_{0},
        variable_bound_gaps_l2_norm_{0},
        objective_matrix_l2_norm_{0},
        combined_variable_bounds_max_{0},
        combined_variable_bounds_min_{0},
        combined_variable_bounds_avg_{0},
        combined_variable_bounds_l2_norm_{0} {}
 
template <typename>
PROTOBUF_CONSTEXPR QuadraticProgramStats::QuadraticProgramStats(::_pbi::ConstantInitialized)
#if defined(PROTOBUF_CUSTOM_VTABLE)
    : ::google::protobuf::Message(QuadraticProgramStats_class_data_.base()),
#else   // PROTOBUF_CUSTOM_VTABLE
    : ::google::protobuf::Message(),
#endif  // PROTOBUF_CUSTOM_VTABLE
      _impl_(::_pbi::ConstantInitialized()) {
}
struct QuadraticProgramStatsDefaultTypeInternal {
  PROTOBUF_CONSTEXPR QuadraticProgramStatsDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~QuadraticProgramStatsDefaultTypeInternal() {}
  union {
    QuadraticProgramStats _instance;
  };
};
 
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT OR_PROTO_DLL
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 QuadraticProgramStatsDefaultTypeInternal _QuadraticProgramStats_default_instance_;
 
inline constexpr PointMetadata::Impl_::Impl_(
    ::_pbi::ConstantInitialized) noexcept
      : _cached_size_{0},
        random_primal_projections_{},
        random_dual_projections_{},
        active_primal_variable_count_{::int64_t{0}},
        active_dual_variable_count_{::int64_t{0}},
        active_primal_variable_change_{::int64_t{0}},
        active_dual_variable_change_{::int64_t{0}},
        point_type_{static_cast< ::operations_research::pdlp::PointType >(0)} {}
 
template <typename>
PROTOBUF_CONSTEXPR PointMetadata::PointMetadata(::_pbi::ConstantInitialized)
#if defined(PROTOBUF_CUSTOM_VTABLE)
    : ::google::protobuf::Message(PointMetadata_class_data_.base()),
#else   // PROTOBUF_CUSTOM_VTABLE
    : ::google::protobuf::Message(),
#endif  // PROTOBUF_CUSTOM_VTABLE
      _impl_(::_pbi::ConstantInitialized()) {
}
struct PointMetadataDefaultTypeInternal {
  PROTOBUF_CONSTEXPR PointMetadataDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~PointMetadataDefaultTypeInternal() {}
  union {
    PointMetadata _instance;
  };
};
 
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT OR_PROTO_DLL
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PointMetadataDefaultTypeInternal _PointMetadata_default_instance_;
 
inline constexpr InfeasibilityInformation::Impl_::Impl_(
    ::_pbi::ConstantInitialized) noexcept
      : _cached_size_{0},
        max_primal_ray_infeasibility_{0},
        primal_ray_linear_objective_{0},
        primal_ray_quadratic_norm_{0},
        max_dual_ray_infeasibility_{0},
        dual_ray_objective_{0},
        candidate_type_{static_cast< ::operations_research::pdlp::PointType >(0)} {}
 
template <typename>
PROTOBUF_CONSTEXPR InfeasibilityInformation::InfeasibilityInformation(::_pbi::ConstantInitialized)
#if defined(PROTOBUF_CUSTOM_VTABLE)
    : ::google::protobuf::Message(InfeasibilityInformation_class_data_.base()),
#else   // PROTOBUF_CUSTOM_VTABLE
    : ::google::protobuf::Message(),
#endif  // PROTOBUF_CUSTOM_VTABLE
      _impl_(::_pbi::ConstantInitialized()) {
}
struct InfeasibilityInformationDefaultTypeInternal {
  PROTOBUF_CONSTEXPR InfeasibilityInformationDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~InfeasibilityInformationDefaultTypeInternal() {}
  union {
    InfeasibilityInformation _instance;
  };
};
 
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT OR_PROTO_DLL
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 InfeasibilityInformationDefaultTypeInternal _InfeasibilityInformation_default_instance_;
 
inline constexpr ConvergenceInformation::Impl_::Impl_(
    ::_pbi::ConstantInitialized) noexcept
      : _cached_size_{0},
        primal_objective_{0},
        dual_objective_{0},
        corrected_dual_objective_{0},
        l_inf_primal_residual_{0},
        l2_primal_residual_{0},
        l_inf_dual_residual_{0},
        l2_dual_residual_{0},
        l_inf_primal_variable_{0},
        l2_primal_variable_{0},
        l_inf_dual_variable_{0},
        l2_dual_variable_{0},
        l_inf_componentwise_primal_residual_{0},
        l_inf_componentwise_dual_residual_{0},
        candidate_type_{static_cast< ::operations_research::pdlp::PointType >(0)} {}
 
template <typename>
PROTOBUF_CONSTEXPR ConvergenceInformation::ConvergenceInformation(::_pbi::ConstantInitialized)
#if defined(PROTOBUF_CUSTOM_VTABLE)
    : ::google::protobuf::Message(ConvergenceInformation_class_data_.base()),
#else   // PROTOBUF_CUSTOM_VTABLE
    : ::google::protobuf::Message(),
#endif  // PROTOBUF_CUSTOM_VTABLE
      _impl_(::_pbi::ConstantInitialized()) {
}
struct ConvergenceInformationDefaultTypeInternal {
  PROTOBUF_CONSTEXPR ConvergenceInformationDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~ConvergenceInformationDefaultTypeInternal() {}
  union {
    ConvergenceInformation _instance;
  };
};
 
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT OR_PROTO_DLL
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ConvergenceInformationDefaultTypeInternal _ConvergenceInformation_default_instance_;
 
inline constexpr IterationStats::Impl_::Impl_(
    ::_pbi::ConstantInitialized) noexcept
      : _cached_size_{0},
        convergence_information_{},
        infeasibility_information_{},
        point_metadata_{},
        iteration_number_{0},
        cumulative_rejected_steps_{0},
        cumulative_kkt_matrix_passes_{0},
        cumulative_time_sec_{0},
        step_size_{0},
        primal_weight_{0},
        restart_used_{static_cast< ::operations_research::pdlp::RestartChoice >(0)} {}
 
template <typename>
PROTOBUF_CONSTEXPR IterationStats::IterationStats(::_pbi::ConstantInitialized)
#if defined(PROTOBUF_CUSTOM_VTABLE)
    : ::google::protobuf::Message(IterationStats_class_data_.base()),
#else   // PROTOBUF_CUSTOM_VTABLE
    : ::google::protobuf::Message(),
#endif  // PROTOBUF_CUSTOM_VTABLE
      _impl_(::_pbi::ConstantInitialized()) {
}
struct IterationStatsDefaultTypeInternal {
  PROTOBUF_CONSTEXPR IterationStatsDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~IterationStatsDefaultTypeInternal() {}
  union {
    IterationStats _instance;
  };
};
 
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT OR_PROTO_DLL
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 IterationStatsDefaultTypeInternal _IterationStats_default_instance_;
 
inline constexpr FeasibilityPolishingDetails::Impl_::Impl_(
    ::_pbi::ConstantInitialized) noexcept
      : _cached_size_{0},
        iteration_stats_{},
        params_{nullptr},
        solution_stats_{nullptr},
        polishing_phase_type_{static_cast< ::operations_research::pdlp::PolishingPhaseType >(0)},
        main_iteration_count_{0},
        termination_reason_{static_cast< ::operations_research::pdlp::TerminationReason >(0)},
        iteration_count_{0},
        solve_time_sec_{0},
        solution_type_{static_cast< ::operations_research::pdlp::PointType >(0)} {}
 
template <typename>
PROTOBUF_CONSTEXPR FeasibilityPolishingDetails::FeasibilityPolishingDetails(::_pbi::ConstantInitialized)
#if defined(PROTOBUF_CUSTOM_VTABLE)
    : ::google::protobuf::Message(FeasibilityPolishingDetails_class_data_.base()),
#else   // PROTOBUF_CUSTOM_VTABLE
    : ::google::protobuf::Message(),
#endif  // PROTOBUF_CUSTOM_VTABLE
      _impl_(::_pbi::ConstantInitialized()) {
}
struct FeasibilityPolishingDetailsDefaultTypeInternal {
  PROTOBUF_CONSTEXPR FeasibilityPolishingDetailsDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~FeasibilityPolishingDetailsDefaultTypeInternal() {}
  union {
    FeasibilityPolishingDetails _instance;
  };
};
 
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT OR_PROTO_DLL
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 FeasibilityPolishingDetailsDefaultTypeInternal _FeasibilityPolishingDetails_default_instance_;
 
inline constexpr SolveLog::Impl_::Impl_(
    ::_pbi::ConstantInitialized) noexcept
      : _cached_size_{0},
        iteration_stats_{},
        feasibility_polishing_details_{},
        instance_name_(
            &::google::protobuf::internal::fixed_address_empty_string,
            ::_pbi::ConstantInitialized()),
        termination_string_(
            &::google::protobuf::internal::fixed_address_empty_string,
            ::_pbi::ConstantInitialized()),
        solution_stats_{nullptr},
        original_problem_stats_{nullptr},
        preprocessed_problem_stats_{nullptr},
        params_{nullptr},
        termination_reason_{static_cast< ::operations_research::pdlp::TerminationReason >(0)},
        iteration_count_{0},
        solve_time_sec_{0},
        preprocessing_time_sec_{0},
        solution_type_{static_cast< ::operations_research::pdlp::PointType >(0)} {}
 
template <typename>
PROTOBUF_CONSTEXPR SolveLog::SolveLog(::_pbi::ConstantInitialized)
#if defined(PROTOBUF_CUSTOM_VTABLE)
    : ::google::protobuf::Message(SolveLog_class_data_.base()),
#else   // PROTOBUF_CUSTOM_VTABLE
    : ::google::protobuf::Message(),
#endif  // PROTOBUF_CUSTOM_VTABLE
      _impl_(::_pbi::ConstantInitialized()) {
}
struct SolveLogDefaultTypeInternal {
  PROTOBUF_CONSTEXPR SolveLogDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {}
  ~SolveLogDefaultTypeInternal() {}
  union {
    SolveLog _instance;
  };
};
 
PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT OR_PROTO_DLL
    PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SolveLogDefaultTypeInternal _SolveLog_default_instance_;
}  // namespace pdlp
}  // namespace operations_research
static const ::_pb::EnumDescriptor* PROTOBUF_NONNULL
    file_level_enum_descriptors_ortools_2fpdlp_2fsolve_5flog_2eproto[4];
static constexpr const ::_pb::ServiceDescriptor* PROTOBUF_NONNULL* PROTOBUF_NULLABLE
    file_level_service_descriptors_ortools_2fpdlp_2fsolve_5flog_2eproto = nullptr;
const ::uint32_t
    TableStruct_ortools_2fpdlp_2fsolve_5flog_2eproto::offsets[] ABSL_ATTRIBUTE_SECTION_VARIABLE(
        protodesc_cold) = {
        0x081, // bitmap
        PROTOBUF_FIELD_OFFSET(::operations_research::pdlp::QuadraticProgramStats, _impl_._has_bits_),
        34, // hasbit index offset
        PROTOBUF_FIELD_OFFSET(::operations_research::pdlp::QuadraticProgramStats, _impl_.num_variables_),
        PROTOBUF_FIELD_OFFSET(::operations_research::pdlp::QuadraticProgramStats, _impl_.num_constraints_),
        PROTOBUF_FIELD_OFFSET(::operations_research::pdlp::QuadraticProgramStats, _impl_.constraint_matrix_col_min_l_inf_norm_),
        PROTOBUF_FIELD_OFFSET(::operations_research::pdlp::QuadraticProgramStats, _impl_.constraint_matrix_row_min_l_inf_norm_),
        PROTOBUF_FIELD_OFFSET(::operations_research::pdlp::QuadraticProgramStats, _impl_.constraint_matrix_num_nonzeros_),
        PROTOBUF_FIELD_OFFSET(::operations_research::pdlp::QuadraticProgramStats, _impl_.constraint_matrix_abs_max_),
        PROTOBUF_FIELD_OFFSET(::operations_research::pdlp::QuadraticProgramStats, _impl_.constraint_matrix_abs_min_),
        PROTOBUF_FIELD_OFFSET(::operations_research::pdlp::QuadraticProgramStats, _impl_.constraint_matrix_abs_avg_),
        PROTOBUF_FIELD_OFFSET(::operations_research::pdlp::QuadraticProgramStats, _impl_.constraint_matrix_l2_norm_),
        PROTOBUF_FIELD_OFFSET(::operations_research::pdlp::QuadraticProgramStats, _impl_.combined_bounds_max_),
        PROTOBUF_FIELD_OFFSET(::operations_research::pdlp::QuadraticProgramStats, _impl_.combined_bounds_min_),
        PROTOBUF_FIELD_OFFSET(::operations_research::pdlp::QuadraticProgramStats, _impl_.combined_bounds_avg_),
        PROTOBUF_FIELD_OFFSET(::operations_research::pdlp::QuadraticProgramStats, _impl_.combined_bounds_l2_norm_),
        PROTOBUF_FIELD_OFFSET(::operations_research::pdlp::QuadraticProgramStats, _impl_.combined_variable_bounds_max_),
        PROTOBUF_FIELD_OFFSET(::operations_research::pdlp::QuadraticProgramStats, _impl_.combined_variable_bounds_min_),
        PROTOBUF_FIELD_OFFSET(::operations_research::pdlp::QuadraticProgramStats, _impl_.combined_variable_bounds_avg_),
        PROTOBUF_FIELD_OFFSET(::operations_research::pdlp::QuadraticProgramStats, _impl_.combined_variable_bounds_l2_norm_),
        PROTOBUF_FIELD_OFFSET(::operations_research::pdlp::QuadraticProgramStats, _impl_.variable_bound_gaps_num_finite_),
        PROTOBUF_FIELD_OFFSET(::operations_research::pdlp::QuadraticProgramStats, _impl_.variable_bound_gaps_max_),
        PROTOBUF_FIELD_OFFSET(::operations_research::pdlp::QuadraticProgramStats, _impl_.variable_bound_gaps_min_),
        PROTOBUF_FIELD_OFFSET(::operations_research::pdlp::QuadraticProgramStats, _impl_.variable_bound_gaps_avg_),
        PROTOBUF_FIELD_OFFSET(::operations_research::pdlp::QuadraticProgramStats, _impl_.variable_bound_gaps_l2_norm_),
        PROTOBUF_FIELD_OFFSET(::operations_research::pdlp::QuadraticProgramStats, _impl_.objective_vector_abs_max_),
        PROTOBUF_FIELD_OFFSET(::operations_research::pdlp::QuadraticProgramStats, _impl_.objective_vector_abs_min_),
        PROTOBUF_FIELD_OFFSET(::operations_research::pdlp::QuadraticProgramStats, _impl_.objective_vector_abs_avg_),
        PROTOBUF_FIELD_OFFSET(::operations_research::pdlp::QuadraticProgramStats, _impl_.objective_vector_l2_norm_),
        PROTOBUF_FIELD_OFFSET(::operations_research::pdlp::QuadraticProgramStats, _impl_.objective_matrix_num_nonzeros_),
        PROTOBUF_FIELD_OFFSET(::operations_research::pdlp::QuadraticProgramStats, _impl_.objective_matrix_abs_max_),
        PROTOBUF_FIELD_OFFSET(::operations_research::pdlp::QuadraticProgramStats, _impl_.objective_matrix_abs_min_),
        PROTOBUF_FIELD_OFFSET(::operations_research::pdlp::QuadraticProgramStats, _impl_.objective_matrix_abs_avg_),
        PROTOBUF_FIELD_OFFSET(::operations_research::pdlp::QuadraticProgramStats, _impl_.objective_matrix_l2_norm_),
        0,
        1,
        2,
        3,
        4,
        5,
        6,
        7,
        24,
        8,
        9,
        10,
        23,
        27,
        28,
        29,
        30,
        11,
        12,
        13,
        14,
        25,
        15,
        16,
        17,
        22,
        18,
        19,
        20,
        21,
        26,
        0x081, // bitmap
        PROTOBUF_FIELD_OFFSET(::operations_research::pdlp::ConvergenceInformation, _impl_._has_bits_),
        17, // hasbit index offset
        PROTOBUF_FIELD_OFFSET(::operations_research::pdlp::ConvergenceInformation, _impl_.candidate_type_),
        PROTOBUF_FIELD_OFFSET(::operations_research::pdlp::ConvergenceInformation, _impl_.primal_objective_),
        PROTOBUF_FIELD_OFFSET(::operations_research::pdlp::ConvergenceInformation, _impl_.dual_objective_),
        PROTOBUF_FIELD_OFFSET(::operations_research::pdlp::ConvergenceInformation, _impl_.corrected_dual_objective_),
        PROTOBUF_FIELD_OFFSET(::operations_research::pdlp::ConvergenceInformation, _impl_.l_inf_primal_residual_),
        PROTOBUF_FIELD_OFFSET(::operations_research::pdlp::ConvergenceInformation, _impl_.l2_primal_residual_),
        PROTOBUF_FIELD_OFFSET(::operations_research::pdlp::ConvergenceInformation, _impl_.l_inf_componentwise_primal_residual_),
        PROTOBUF_FIELD_OFFSET(::operations_research::pdlp::ConvergenceInformation, _impl_.l_inf_dual_residual_),
        PROTOBUF_FIELD_OFFSET(::operations_research::pdlp::ConvergenceInformation, _impl_.l2_dual_residual_),
        PROTOBUF_FIELD_OFFSET(::operations_research::pdlp::ConvergenceInformation, _impl_.l_inf_componentwise_dual_residual_),
        PROTOBUF_FIELD_OFFSET(::operations_research::pdlp::ConvergenceInformation, _impl_.l_inf_primal_variable_),
        PROTOBUF_FIELD_OFFSET(::operations_research::pdlp::ConvergenceInformation, _impl_.l2_primal_variable_),
        PROTOBUF_FIELD_OFFSET(::operations_research::pdlp::ConvergenceInformation, _impl_.l_inf_dual_variable_),
        PROTOBUF_FIELD_OFFSET(::operations_research::pdlp::ConvergenceInformation, _impl_.l2_dual_variable_),
        13,
        0,
        1,
        2,
        3,
        4,
        11,
        5,
        6,
        12,
        7,
        8,
        9,
        10,
        0x081, // bitmap
        PROTOBUF_FIELD_OFFSET(::operations_research::pdlp::InfeasibilityInformation, _impl_._has_bits_),
        9, // hasbit index offset
        PROTOBUF_FIELD_OFFSET(::operations_research::pdlp::InfeasibilityInformation, _impl_.max_primal_ray_infeasibility_),
        PROTOBUF_FIELD_OFFSET(::operations_research::pdlp::InfeasibilityInformation, _impl_.primal_ray_linear_objective_),
        PROTOBUF_FIELD_OFFSET(::operations_research::pdlp::InfeasibilityInformation, _impl_.primal_ray_quadratic_norm_),
        PROTOBUF_FIELD_OFFSET(::operations_research::pdlp::InfeasibilityInformation, _impl_.max_dual_ray_infeasibility_),
        PROTOBUF_FIELD_OFFSET(::operations_research::pdlp::InfeasibilityInformation, _impl_.dual_ray_objective_),
        PROTOBUF_FIELD_OFFSET(::operations_research::pdlp::InfeasibilityInformation, _impl_.candidate_type_),
        0,
        1,
        2,
        3,
        4,
        5,
        0x081, // bitmap
        PROTOBUF_FIELD_OFFSET(::operations_research::pdlp::PointMetadata, _impl_._has_bits_),
        10, // hasbit index offset
        PROTOBUF_FIELD_OFFSET(::operations_research::pdlp::PointMetadata, _impl_.point_type_),
        PROTOBUF_FIELD_OFFSET(::operations_research::pdlp::PointMetadata, _impl_.random_primal_projections_),
        PROTOBUF_FIELD_OFFSET(::operations_research::pdlp::PointMetadata, _impl_.random_dual_projections_),
        PROTOBUF_FIELD_OFFSET(::operations_research::pdlp::PointMetadata, _impl_.active_primal_variable_count_),
        PROTOBUF_FIELD_OFFSET(::operations_research::pdlp::PointMetadata, _impl_.active_dual_variable_count_),
        PROTOBUF_FIELD_OFFSET(::operations_research::pdlp::PointMetadata, _impl_.active_primal_variable_change_),
        PROTOBUF_FIELD_OFFSET(::operations_research::pdlp::PointMetadata, _impl_.active_dual_variable_change_),
        6,
        0,
        1,
        2,
        3,
        4,
        5,
        0x081, // bitmap
        PROTOBUF_FIELD_OFFSET(::operations_research::pdlp::IterationStats, _impl_._has_bits_),
        13, // hasbit index offset
        PROTOBUF_FIELD_OFFSET(::operations_research::pdlp::IterationStats, _impl_.iteration_number_),
        PROTOBUF_FIELD_OFFSET(::operations_research::pdlp::IterationStats, _impl_.convergence_information_),
        PROTOBUF_FIELD_OFFSET(::operations_research::pdlp::IterationStats, _impl_.infeasibility_information_),
        PROTOBUF_FIELD_OFFSET(::operations_research::pdlp::IterationStats, _impl_.point_metadata_),
        PROTOBUF_FIELD_OFFSET(::operations_research::pdlp::IterationStats, _impl_.cumulative_kkt_matrix_passes_),
        PROTOBUF_FIELD_OFFSET(::operations_research::pdlp::IterationStats, _impl_.cumulative_rejected_steps_),
        PROTOBUF_FIELD_OFFSET(::operations_research::pdlp::IterationStats, _impl_.cumulative_time_sec_),
        PROTOBUF_FIELD_OFFSET(::operations_research::pdlp::IterationStats, _impl_.restart_used_),
        PROTOBUF_FIELD_OFFSET(::operations_research::pdlp::IterationStats, _impl_.step_size_),
        PROTOBUF_FIELD_OFFSET(::operations_research::pdlp::IterationStats, _impl_.primal_weight_),
        3,
        0,
        1,
        2,
        5,
        4,
        6,
        9,
        7,
        8,
        0x081, // bitmap
        PROTOBUF_FIELD_OFFSET(::operations_research::pdlp::FeasibilityPolishingDetails, _impl_._has_bits_),
        12, // hasbit index offset
        PROTOBUF_FIELD_OFFSET(::operations_research::pdlp::FeasibilityPolishingDetails, _impl_.polishing_phase_type_),
        PROTOBUF_FIELD_OFFSET(::operations_research::pdlp::FeasibilityPolishingDetails, _impl_.main_iteration_count_),
        PROTOBUF_FIELD_OFFSET(::operations_research::pdlp::FeasibilityPolishingDetails, _impl_.params_),
        PROTOBUF_FIELD_OFFSET(::operations_research::pdlp::FeasibilityPolishingDetails, _impl_.termination_reason_),
        PROTOBUF_FIELD_OFFSET(::operations_research::pdlp::FeasibilityPolishingDetails, _impl_.iteration_count_),
        PROTOBUF_FIELD_OFFSET(::operations_research::pdlp::FeasibilityPolishingDetails, _impl_.solve_time_sec_),
        PROTOBUF_FIELD_OFFSET(::operations_research::pdlp::FeasibilityPolishingDetails, _impl_.solution_stats_),
        PROTOBUF_FIELD_OFFSET(::operations_research::pdlp::FeasibilityPolishingDetails, _impl_.solution_type_),
        PROTOBUF_FIELD_OFFSET(::operations_research::pdlp::FeasibilityPolishingDetails, _impl_.iteration_stats_),
        3,
        4,
        1,
        5,
        6,
        7,
        2,
        8,
        0,
        0x081, // bitmap
        PROTOBUF_FIELD_OFFSET(::operations_research::pdlp::SolveLog, _impl_._has_bits_),
        16, // hasbit index offset
        PROTOBUF_FIELD_OFFSET(::operations_research::pdlp::SolveLog, _impl_.instance_name_),
        PROTOBUF_FIELD_OFFSET(::operations_research::pdlp::SolveLog, _impl_.params_),
        PROTOBUF_FIELD_OFFSET(::operations_research::pdlp::SolveLog, _impl_.termination_reason_),
        PROTOBUF_FIELD_OFFSET(::operations_research::pdlp::SolveLog, _impl_.termination_string_),
        PROTOBUF_FIELD_OFFSET(::operations_research::pdlp::SolveLog, _impl_.iteration_count_),
        PROTOBUF_FIELD_OFFSET(::operations_research::pdlp::SolveLog, _impl_.preprocessing_time_sec_),
        PROTOBUF_FIELD_OFFSET(::operations_research::pdlp::SolveLog, _impl_.solve_time_sec_),
        PROTOBUF_FIELD_OFFSET(::operations_research::pdlp::SolveLog, _impl_.solution_stats_),
        PROTOBUF_FIELD_OFFSET(::operations_research::pdlp::SolveLog, _impl_.solution_type_),
        PROTOBUF_FIELD_OFFSET(::operations_research::pdlp::SolveLog, _impl_.iteration_stats_),
        PROTOBUF_FIELD_OFFSET(::operations_research::pdlp::SolveLog, _impl_.original_problem_stats_),
        PROTOBUF_FIELD_OFFSET(::operations_research::pdlp::SolveLog, _impl_.preprocessed_problem_stats_),
        PROTOBUF_FIELD_OFFSET(::operations_research::pdlp::SolveLog, _impl_.feasibility_polishing_details_),
        2,
        7,
        8,
        3,
        9,
        11,
        10,
        4,
        12,
        0,
        5,
        6,
        1,
};
 
static const ::_pbi::MigrationSchema
    schemas[] ABSL_ATTRIBUTE_SECTION_VARIABLE(protodesc_cold) = {
        {0, sizeof(::operations_research::pdlp::QuadraticProgramStats)},
        {65, sizeof(::operations_research::pdlp::ConvergenceInformation)},
        {96, sizeof(::operations_research::pdlp::InfeasibilityInformation)},
        {111, sizeof(::operations_research::pdlp::PointMetadata)},
        {128, sizeof(::operations_research::pdlp::IterationStats)},
        {151, sizeof(::operations_research::pdlp::FeasibilityPolishingDetails)},
        {172, sizeof(::operations_research::pdlp::SolveLog)},
};
static const ::_pb::Message* PROTOBUF_NONNULL const file_default_instances[] = {
    &::operations_research::pdlp::_QuadraticProgramStats_default_instance_._instance,
    &::operations_research::pdlp::_ConvergenceInformation_default_instance_._instance,
    &::operations_research::pdlp::_InfeasibilityInformation_default_instance_._instance,
    &::operations_research::pdlp::_PointMetadata_default_instance_._instance,
    &::operations_research::pdlp::_IterationStats_default_instance_._instance,
    &::operations_research::pdlp::_FeasibilityPolishingDetails_default_instance_._instance,
    &::operations_research::pdlp::_SolveLog_default_instance_._instance,
};
const char descriptor_table_protodef_ortools_2fpdlp_2fsolve_5flog_2eproto[] ABSL_ATTRIBUTE_SECTION_VARIABLE(
    protodesc_cold) = {
    "\n\034ortools/pdlp/solve_log.proto\022\030operatio"
    "ns_research.pdlp\032\032ortools/pdlp/solvers.p"
    "roto\"\322\010\n\025QuadraticProgramStats\022\025\n\rnum_va"
    "riables\030\001 \001(\003\022\027\n\017num_constraints\030\002 \001(\003\022,"
    "\n$constraint_matrix_col_min_l_inf_norm\030\003"
    " \001(\001\022,\n$constraint_matrix_row_min_l_inf_"
    "norm\030\004 \001(\001\022&\n\036constraint_matrix_num_nonz"
    "eros\030\005 \001(\003\022!\n\031constraint_matrix_abs_max\030"
    "\006 \001(\001\022!\n\031constraint_matrix_abs_min\030\007 \001(\001"
    "\022!\n\031constraint_matrix_abs_avg\030\010 \001(\001\022!\n\031c"
    "onstraint_matrix_l2_norm\030\031 \001(\001\022\033\n\023combin"
    "ed_bounds_max\030\t \001(\001\022\033\n\023combined_bounds_m"
    "in\030\n \001(\001\022\033\n\023combined_bounds_avg\030\013 \001(\001\022\037\n"
    "\027combined_bounds_l2_norm\030\030 \001(\001\022$\n\034combin"
    "ed_variable_bounds_max\030\034 \001(\001\022$\n\034combined"
    "_variable_bounds_min\030\035 \001(\001\022$\n\034combined_v"
    "ariable_bounds_avg\030\036 \001(\001\022(\n combined_var"
    "iable_bounds_l2_norm\030\037 \001(\001\022&\n\036variable_b"
    "ound_gaps_num_finite\030\014 \001(\003\022\037\n\027variable_b"
    "ound_gaps_max\030\r \001(\001\022\037\n\027variable_bound_ga"
    "ps_min\030\016 \001(\001\022\037\n\027variable_bound_gaps_avg\030"
    "\017 \001(\001\022#\n\033variable_bound_gaps_l2_norm\030\032 \001"
    "(\001\022 \n\030objective_vector_abs_max\030\020 \001(\001\022 \n\030"
    "objective_vector_abs_min\030\021 \001(\001\022 \n\030object"
    "ive_vector_abs_avg\030\022 \001(\001\022 \n\030objective_ve"
    "ctor_l2_norm\030\027 \001(\001\022%\n\035objective_matrix_n"
    "um_nonzeros\030\023 \001(\003\022 \n\030objective_matrix_ab"
    "s_max\030\024 \001(\001\022 \n\030objective_matrix_abs_min\030"
    "\025 \001(\001\022 \n\030objective_matrix_abs_avg\030\026 \001(\001\022"
    " \n\030objective_matrix_l2_norm\030\033 \001(\001\"\247\004\n\026Co"
    "nvergenceInformation\022;\n\016candidate_type\030\001"
    " \001(\0162#.operations_research.pdlp.PointTyp"
    "e\022\030\n\020primal_objective\030\002 \001(\001\022\026\n\016dual_obje"
    "ctive\030\003 \001(\001\022 \n\030corrected_dual_objective\030"
    "\004 \001(\001\022\035\n\025l_inf_primal_residual\030\005 \001(\001\022\032\n\022"
    "l2_primal_residual\030\006 \001(\001\022+\n#l_inf_compon"
    "entwise_primal_residual\030\030 \001(\001\022\033\n\023l_inf_d"
    "ual_residual\030\007 \001(\001\022\030\n\020l2_dual_residual\030\010"
    " \001(\001\022)\n!l_inf_componentwise_dual_residua"
    "l\030\031 \001(\001\022\035\n\025l_inf_primal_variable\030\016 \001(\001\022\032"
    "\n\022l2_primal_variable\030\017 \001(\001\022\033\n\023l_inf_dual"
    "_variable\030\020 \001(\001\022\030\n\020l2_dual_variable\030\021 \001("
    "\001J\004\010\t\020\nJ\004\010\n\020\013J\004\010\013\020\014J\004\010\014\020\rJ\004\010\r\020\016J\004\010\022\020\023J\004\010"
    "\023\020\024J\004\010\024\020\025J\004\010\025\020\026J\004\010\026\020\027J\004\010\027\020\030\"\221\002\n\030Infeasib"
    "ilityInformation\022$\n\034max_primal_ray_infea"
    "sibility\030\001 \001(\001\022#\n\033primal_ray_linear_obje"
    "ctive\030\002 \001(\001\022!\n\031primal_ray_quadratic_norm"
    "\030\003 \001(\001\022\"\n\032max_dual_ray_infeasibility\030\004 \001"
    "(\001\022\032\n\022dual_ray_objective\030\005 \001(\001\022;\n\016candid"
    "ate_type\030\006 \001(\0162#.operations_research.pdl"
    "p.PointTypeJ\004\010\007\020\010J\004\010\010\020\t\"\252\002\n\rPointMetadat"
    "a\0227\n\npoint_type\030\001 \001(\0162#.operations_resea"
    "rch.pdlp.PointType\022%\n\031random_primal_proj"
    "ections\030\002 \003(\001B\002\020\001\022#\n\027random_dual_project"
    "ions\030\003 \003(\001B\002\020\001\022$\n\034active_primal_variable"
    "_count\030\004 \001(\003\022\"\n\032active_dual_variable_cou"
    "nt\030\005 \001(\003\022%\n\035active_primal_variable_chang"
    "e\030\006 \001(\003\022#\n\033active_dual_variable_change\030\007"
    " \001(\003\"\352\003\n\016IterationStats\022\030\n\020iteration_num"
    "ber\030\001 \001(\005\022Q\n\027convergence_information\030\002 \003"
    "(\01320.operations_research.pdlp.Convergenc"
    "eInformation\022U\n\031infeasibility_informatio"
    "n\030\003 \003(\01322.operations_research.pdlp.Infea"
    "sibilityInformation\022\?\n\016point_metadata\030\013 "
    "\003(\0132\'.operations_research.pdlp.PointMeta"
    "data\022$\n\034cumulative_kkt_matrix_passes\030\004 \001"
    "(\001\022!\n\031cumulative_rejected_steps\030\005 \001(\005\022\033\n"
    "\023cumulative_time_sec\030\006 \001(\001\022=\n\014restart_us"
    "ed\030\007 \001(\0162\'.operations_research.pdlp.Rest"
    "artChoice\022\021\n\tstep_size\030\010 \001(\001\022\025\n\rprimal_w"
    "eight\030\t \001(\001J\004\010\n\020\013\"\214\004\n\033FeasibilityPolishi"
    "ngDetails\022J\n\024polishing_phase_type\030\001 \001(\0162"
    ",.operations_research.pdlp.PolishingPhas"
    "eType\022\034\n\024main_iteration_count\030\002 \001(\005\022H\n\006p"
    "arams\030\003 \001(\01328.operations_research.pdlp.P"
    "rimalDualHybridGradientParams\022G\n\022termina"
    "tion_reason\030\004 \001(\0162+.operations_research."
    "pdlp.TerminationReason\022\027\n\017iteration_coun"
    "t\030\005 \001(\005\022\026\n\016solve_time_sec\030\006 \001(\001\022@\n\016solut"
    "ion_stats\030\007 \001(\0132(.operations_research.pd"
    "lp.IterationStats\022:\n\rsolution_type\030\010 \001(\016"
    "2#.operations_research.pdlp.PointType\022A\n"
    "\017iteration_stats\030\t \003(\0132(.operations_rese"
    "arch.pdlp.IterationStats\"\362\005\n\010SolveLog\022\025\n"
    "\rinstance_name\030\001 \001(\t\022H\n\006params\030\016 \001(\01328.o"
    "perations_research.pdlp.PrimalDualHybrid"
    "GradientParams\022G\n\022termination_reason\030\003 \001"
    "(\0162+.operations_research.pdlp.Terminatio"
    "nReason\022\032\n\022termination_string\030\004 \001(\t\022\027\n\017i"
    "teration_count\030\005 \001(\005\022\036\n\026preprocessing_ti"
    "me_sec\030\r \001(\001\022\026\n\016solve_time_sec\030\006 \001(\001\022@\n\016"
    "solution_stats\030\010 \001(\0132(.operations_resear"
    "ch.pdlp.IterationStats\022:\n\rsolution_type\030"
    "\n \001(\0162#.operations_research.pdlp.PointTy"
    "pe\022A\n\017iteration_stats\030\007 \003(\0132(.operations"
    "_research.pdlp.IterationStats\022O\n\026origina"
    "l_problem_stats\030\013 \001(\0132/.operations_resea"
    "rch.pdlp.QuadraticProgramStats\022S\n\032prepro"
    "cessed_problem_stats\030\014 \001(\0132/.operations_"
    "research.pdlp.QuadraticProgramStats\022\\\n\035f"
    "easibility_polishing_details\030\017 \003(\01325.ope"
    "rations_research.pdlp.FeasibilityPolishi"
    "ngDetailsJ\004\010\002\020\003J\004\010\t\020\n*\240\001\n\rRestartChoice\022"
    "\036\n\032RESTART_CHOICE_UNSPECIFIED\020\000\022\035\n\031RESTA"
    "RT_CHOICE_NO_RESTART\020\001\022)\n%RESTART_CHOICE"
    "_WEIGHTED_AVERAGE_RESET\020\002\022%\n!RESTART_CHO"
    "ICE_RESTART_TO_AVERAGE\020\003*\361\001\n\tPointType\022\032"
    "\n\026POINT_TYPE_UNSPECIFIED\020\000\022\036\n\032POINT_TYPE"
    "_CURRENT_ITERATE\020\001\022!\n\035POINT_TYPE_ITERATE"
    "_DIFFERENCE\020\002\022\036\n\032POINT_TYPE_AVERAGE_ITER"
    "ATE\020\003\022\023\n\017POINT_TYPE_NONE\020\004\022!\n\035POINT_TYPE"
    "_PRESOLVER_SOLUTION\020\005\022-\n)POINT_TYPE_FEAS"
    "IBILITY_POLISHING_SOLUTION\020\006*\311\004\n\021Termina"
    "tionReason\022\"\n\036TERMINATION_REASON_UNSPECI"
    "FIED\020\000\022\036\n\032TERMINATION_REASON_OPTIMAL\020\001\022("
    "\n$TERMINATION_REASON_PRIMAL_INFEASIBLE\020\002"
    "\022&\n\"TERMINATION_REASON_DUAL_INFEASIBLE\020\003"
    "\022!\n\035TERMINATION_REASON_TIME_LIMIT\020\004\022&\n\"T"
    "ERMINATION_REASON_ITERATION_LIMIT\020\005\022,\n(T"
    "ERMINATION_REASON_KKT_MATRIX_PASS_LIMIT\020"
    "\010\022*\n&TERMINATION_REASON_INTERRUPTED_BY_U"
    "SER\020\014\022&\n\"TERMINATION_REASON_NUMERICAL_ER"
    "ROR\020\006\022&\n\"TERMINATION_REASON_INVALID_PROB"
    "LEM\020\t\022/\n+TERMINATION_REASON_INVALID_INIT"
    "IAL_SOLUTION\020\r\022(\n$TERMINATION_REASON_INV"
    "ALID_PARAMETER\020\n\022\034\n\030TERMINATION_REASON_O"
    "THER\020\007\0220\n,TERMINATION_REASON_PRIMAL_OR_D"
    "UAL_INFEASIBLE\020\013*\222\001\n\022PolishingPhaseType\022"
    "$\n POLISHING_PHASE_TYPE_UNSPECIFIED\020\000\022+\n"
    "\'POLISHING_PHASE_TYPE_PRIMAL_FEASIBILITY"
    "\020\001\022)\n%POLISHING_PHASE_TYPE_DUAL_FEASIBIL"
    "ITY\020\002B1\n\027com.google.ortools.pdlpP\001\252\002\023Goo"
    "gle.OrTools.PDLP"
};
static const ::_pbi::DescriptorTable* PROTOBUF_NONNULL const
    descriptor_table_ortools_2fpdlp_2fsolve_5flog_2eproto_deps[1] = {
        &::descriptor_table_ortools_2fpdlp_2fsolvers_2eproto,
};
static ::absl::once_flag descriptor_table_ortools_2fpdlp_2fsolve_5flog_2eproto_once;
PROTOBUF_CONSTINIT const ::_pbi::DescriptorTable descriptor_table_ortools_2fpdlp_2fsolve_5flog_2eproto = {
    false,
    false,
    5296,
    descriptor_table_protodef_ortools_2fpdlp_2fsolve_5flog_2eproto,
    "ortools/pdlp/solve_log.proto",
    &descriptor_table_ortools_2fpdlp_2fsolve_5flog_2eproto_once,
    descriptor_table_ortools_2fpdlp_2fsolve_5flog_2eproto_deps,
    1,
    7,
    schemas,
    file_default_instances,
    TableStruct_ortools_2fpdlp_2fsolve_5flog_2eproto::offsets,
    file_level_enum_descriptors_ortools_2fpdlp_2fsolve_5flog_2eproto,
    file_level_service_descriptors_ortools_2fpdlp_2fsolve_5flog_2eproto,
};
namespace operations_research {
namespace pdlp {
const ::google::protobuf::EnumDescriptor* PROTOBUF_NONNULL RestartChoice_descriptor() {
  ::google::protobuf::internal::AssignDescriptors(&descriptor_table_ortools_2fpdlp_2fsolve_5flog_2eproto);
  return file_level_enum_descriptors_ortools_2fpdlp_2fsolve_5flog_2eproto[0];
}
PROTOBUF_CONSTINIT const uint32_t RestartChoice_internal_data_[] = {
    262144u, 0u, };
const ::google::protobuf::EnumDescriptor* PROTOBUF_NONNULL PointType_descriptor() {
  ::google::protobuf::internal::AssignDescriptors(&descriptor_table_ortools_2fpdlp_2fsolve_5flog_2eproto);
  return file_level_enum_descriptors_ortools_2fpdlp_2fsolve_5flog_2eproto[1];
}
PROTOBUF_CONSTINIT const uint32_t PointType_internal_data_[] = {
    458752u, 0u, };
const ::google::protobuf::EnumDescriptor* PROTOBUF_NONNULL TerminationReason_descriptor() {
  ::google::protobuf::internal::AssignDescriptors(&descriptor_table_ortools_2fpdlp_2fsolve_5flog_2eproto);
  return file_level_enum_descriptors_ortools_2fpdlp_2fsolve_5flog_2eproto[2];
}
PROTOBUF_CONSTINIT const uint32_t TerminationReason_internal_data_[] = {
    917504u, 0u, };
const ::google::protobuf::EnumDescriptor* PROTOBUF_NONNULL PolishingPhaseType_descriptor() {
  ::google::protobuf::internal::AssignDescriptors(&descriptor_table_ortools_2fpdlp_2fsolve_5flog_2eproto);
  return file_level_enum_descriptors_ortools_2fpdlp_2fsolve_5flog_2eproto[3];
}
PROTOBUF_CONSTINIT const uint32_t PolishingPhaseType_internal_data_[] = {
    196608u, 0u, };
// ===================================================================
 
class QuadraticProgramStats::_Internal {
 public:
  using HasBits =
      decltype(::std::declval<QuadraticProgramStats>()._impl_._has_bits_);
  static constexpr ::int32_t kHasBitsOffset =
      8 * PROTOBUF_FIELD_OFFSET(QuadraticProgramStats, _impl_._has_bits_);
};
 
QuadraticProgramStats::QuadraticProgramStats(::google::protobuf::Arena* PROTOBUF_NULLABLE arena)
#if defined(PROTOBUF_CUSTOM_VTABLE)
    : ::google::protobuf::Message(arena, QuadraticProgramStats_class_data_.base()) {
#else   // PROTOBUF_CUSTOM_VTABLE
    : ::google::protobuf::Message(arena) {
#endif  // PROTOBUF_CUSTOM_VTABLE
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:operations_research.pdlp.QuadraticProgramStats)
}
QuadraticProgramStats::QuadraticProgramStats(
    ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const QuadraticProgramStats& from)
#if defined(PROTOBUF_CUSTOM_VTABLE)
    : ::google::protobuf::Message(arena, QuadraticProgramStats_class_data_.base()),
#else   // PROTOBUF_CUSTOM_VTABLE
    : ::google::protobuf::Message(arena),
#endif  // PROTOBUF_CUSTOM_VTABLE
      _impl_(from._impl_) {
  _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(
      from._internal_metadata_);
}
PROTOBUF_NDEBUG_INLINE QuadraticProgramStats::Impl_::Impl_(
    [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility,
    [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena)
      : _cached_size_{0} {}
 
inline void QuadraticProgramStats::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) {
  new (&_impl_) Impl_(internal_visibility(), arena);
  ::memset(reinterpret_cast<char*>(&_impl_) +
               offsetof(Impl_, num_variables_),
           0,
           offsetof(Impl_, combined_variable_bounds_l2_norm_) -
               offsetof(Impl_, num_variables_) +
               sizeof(Impl_::combined_variable_bounds_l2_norm_));
}
QuadraticProgramStats::~QuadraticProgramStats() {
  // @@protoc_insertion_point(destructor:operations_research.pdlp.QuadraticProgramStats)
  SharedDtor(*this);
}
inline void QuadraticProgramStats::SharedDtor(MessageLite& self) {
  QuadraticProgramStats& this_ = static_cast<QuadraticProgramStats&>(self);
  if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) {
    this_.CheckHasBitConsistency();
  }
  this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>();
  ABSL_DCHECK(this_.GetArena() == nullptr);
  this_._impl_.~Impl_();
}
 
inline void* PROTOBUF_NONNULL QuadraticProgramStats::PlacementNew_(
    const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem,
    ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) {
  return ::new (mem) QuadraticProgramStats(arena);
}
constexpr auto QuadraticProgramStats::InternalNewImpl_() {
  return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(QuadraticProgramStats),
                                            alignof(QuadraticProgramStats));
}
constexpr auto QuadraticProgramStats::InternalGenerateClassData_() {
  return ::google::protobuf::internal::ClassDataFull{
      ::google::protobuf::internal::ClassData{
          &_QuadraticProgramStats_default_instance_._instance,
          &_table_.header,
          nullptr,  // OnDemandRegisterArenaDtor
          nullptr,  // IsInitialized
          &QuadraticProgramStats::MergeImpl,
          ::google::protobuf::Message::GetNewImpl<QuadraticProgramStats>(),
#if defined(PROTOBUF_CUSTOM_VTABLE)
          &QuadraticProgramStats::SharedDtor,
          ::google::protobuf::Message::GetClearImpl<QuadraticProgramStats>(), &QuadraticProgramStats::ByteSizeLong,
              &QuadraticProgramStats::_InternalSerialize,
#endif  // PROTOBUF_CUSTOM_VTABLE
          PROTOBUF_FIELD_OFFSET(QuadraticProgramStats, _impl_._cached_size_),
          false,
      },
      &QuadraticProgramStats::kDescriptorMethods,
      &descriptor_table_ortools_2fpdlp_2fsolve_5flog_2eproto,
      nullptr,  // tracker
  };
}
 
PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const
    ::google::protobuf::internal::ClassDataFull QuadraticProgramStats_class_data_ =
        QuadraticProgramStats::InternalGenerateClassData_();
 
PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL
QuadraticProgramStats::GetClassData() const {
  ::google::protobuf::internal::PrefetchToLocalCache(&QuadraticProgramStats_class_data_);
  ::google::protobuf::internal::PrefetchToLocalCache(QuadraticProgramStats_class_data_.tc_table);
  return QuadraticProgramStats_class_data_.base();
}
PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1
const ::_pbi::TcParseTable<5, 31, 0, 0, 2>
QuadraticProgramStats::_table_ = {
  {
    PROTOBUF_FIELD_OFFSET(QuadraticProgramStats, _impl_._has_bits_),
    0, // no _extensions_
    31, 248,  // max_field_number, fast_idx_mask
    offsetof(decltype(_table_), field_lookup_table),
    2147483648,  // skipmap
    offsetof(decltype(_table_), field_entries),
    31,  // num_field_entries
    0,  // num_aux_entries
    offsetof(decltype(_table_), field_names),  // no aux_entries
    QuadraticProgramStats_class_data_.base(),
    nullptr,  // post_loop_handler
    ::_pbi::TcParser::GenericFallback,  // fallback
    #ifdef PROTOBUF_PREFETCH_PARSE_TABLE
    ::_pbi::TcParser::GetTable<::operations_research::pdlp::QuadraticProgramStats>(),  // to_prefetch
    #endif  // PROTOBUF_PREFETCH_PARSE_TABLE
  }, {{
    {::_pbi::TcParser::MiniParse, {}},
    // optional int64 num_variables = 1;
    {::_pbi::TcParser::SingularVarintNoZag1<::uint64_t, offsetof(QuadraticProgramStats, _impl_.num_variables_), 0>(),
     {8, 0, 0,
      PROTOBUF_FIELD_OFFSET(QuadraticProgramStats, _impl_.num_variables_)}},
    // optional int64 num_constraints = 2;
    {::_pbi::TcParser::SingularVarintNoZag1<::uint64_t, offsetof(QuadraticProgramStats, _impl_.num_constraints_), 1>(),
     {16, 1, 0,
      PROTOBUF_FIELD_OFFSET(QuadraticProgramStats, _impl_.num_constraints_)}},
    // optional double constraint_matrix_col_min_l_inf_norm = 3;
    {::_pbi::TcParser::FastF64S1,
     {25, 2, 0,
      PROTOBUF_FIELD_OFFSET(QuadraticProgramStats, _impl_.constraint_matrix_col_min_l_inf_norm_)}},
    // optional double constraint_matrix_row_min_l_inf_norm = 4;
    {::_pbi::TcParser::FastF64S1,
     {33, 3, 0,
      PROTOBUF_FIELD_OFFSET(QuadraticProgramStats, _impl_.constraint_matrix_row_min_l_inf_norm_)}},
    // optional int64 constraint_matrix_num_nonzeros = 5;
    {::_pbi::TcParser::SingularVarintNoZag1<::uint64_t, offsetof(QuadraticProgramStats, _impl_.constraint_matrix_num_nonzeros_), 4>(),
     {40, 4, 0,
      PROTOBUF_FIELD_OFFSET(QuadraticProgramStats, _impl_.constraint_matrix_num_nonzeros_)}},
    // optional double constraint_matrix_abs_max = 6;
    {::_pbi::TcParser::FastF64S1,
     {49, 5, 0,
      PROTOBUF_FIELD_OFFSET(QuadraticProgramStats, _impl_.constraint_matrix_abs_max_)}},
    // optional double constraint_matrix_abs_min = 7;
    {::_pbi::TcParser::FastF64S1,
     {57, 6, 0,
      PROTOBUF_FIELD_OFFSET(QuadraticProgramStats, _impl_.constraint_matrix_abs_min_)}},
    // optional double constraint_matrix_abs_avg = 8;
    {::_pbi::TcParser::FastF64S1,
     {65, 7, 0,
      PROTOBUF_FIELD_OFFSET(QuadraticProgramStats, _impl_.constraint_matrix_abs_avg_)}},
    // optional double combined_bounds_max = 9;
    {::_pbi::TcParser::FastF64S1,
     {73, 8, 0,
      PROTOBUF_FIELD_OFFSET(QuadraticProgramStats, _impl_.combined_bounds_max_)}},
    // optional double combined_bounds_min = 10;
    {::_pbi::TcParser::FastF64S1,
     {81, 9, 0,
      PROTOBUF_FIELD_OFFSET(QuadraticProgramStats, _impl_.combined_bounds_min_)}},
    // optional double combined_bounds_avg = 11;
    {::_pbi::TcParser::FastF64S1,
     {89, 10, 0,
      PROTOBUF_FIELD_OFFSET(QuadraticProgramStats, _impl_.combined_bounds_avg_)}},
    // optional int64 variable_bound_gaps_num_finite = 12;
    {::_pbi::TcParser::SingularVarintNoZag1<::uint64_t, offsetof(QuadraticProgramStats, _impl_.variable_bound_gaps_num_finite_), 11>(),
     {96, 11, 0,
      PROTOBUF_FIELD_OFFSET(QuadraticProgramStats, _impl_.variable_bound_gaps_num_finite_)}},
    // optional double variable_bound_gaps_max = 13;
    {::_pbi::TcParser::FastF64S1,
     {105, 12, 0,
      PROTOBUF_FIELD_OFFSET(QuadraticProgramStats, _impl_.variable_bound_gaps_max_)}},
    // optional double variable_bound_gaps_min = 14;
    {::_pbi::TcParser::FastF64S1,
     {113, 13, 0,
      PROTOBUF_FIELD_OFFSET(QuadraticProgramStats, _impl_.variable_bound_gaps_min_)}},
    // optional double variable_bound_gaps_avg = 15;
    {::_pbi::TcParser::FastF64S1,
     {121, 14, 0,
      PROTOBUF_FIELD_OFFSET(QuadraticProgramStats, _impl_.variable_bound_gaps_avg_)}},
    // optional double objective_vector_abs_max = 16;
    {::_pbi::TcParser::FastF64S2,
     {385, 15, 0,
      PROTOBUF_FIELD_OFFSET(QuadraticProgramStats, _impl_.objective_vector_abs_max_)}},
    // optional double objective_vector_abs_min = 17;
    {::_pbi::TcParser::FastF64S2,
     {393, 16, 0,
      PROTOBUF_FIELD_OFFSET(QuadraticProgramStats, _impl_.objective_vector_abs_min_)}},
    // optional double objective_vector_abs_avg = 18;
    {::_pbi::TcParser::FastF64S2,
     {401, 17, 0,
      PROTOBUF_FIELD_OFFSET(QuadraticProgramStats, _impl_.objective_vector_abs_avg_)}},
    // optional int64 objective_matrix_num_nonzeros = 19;
    {::_pbi::TcParser::FastV64S2,
     {408, 18, 0,
      PROTOBUF_FIELD_OFFSET(QuadraticProgramStats, _impl_.objective_matrix_num_nonzeros_)}},
    // optional double objective_matrix_abs_max = 20;
    {::_pbi::TcParser::FastF64S2,
     {417, 19, 0,
      PROTOBUF_FIELD_OFFSET(QuadraticProgramStats, _impl_.objective_matrix_abs_max_)}},
    // optional double objective_matrix_abs_min = 21;
    {::_pbi::TcParser::FastF64S2,
     {425, 20, 0,
      PROTOBUF_FIELD_OFFSET(QuadraticProgramStats, _impl_.objective_matrix_abs_min_)}},
    // optional double objective_matrix_abs_avg = 22;
    {::_pbi::TcParser::FastF64S2,
     {433, 21, 0,
      PROTOBUF_FIELD_OFFSET(QuadraticProgramStats, _impl_.objective_matrix_abs_avg_)}},
    // optional double objective_vector_l2_norm = 23;
    {::_pbi::TcParser::FastF64S2,
     {441, 22, 0,
      PROTOBUF_FIELD_OFFSET(QuadraticProgramStats, _impl_.objective_vector_l2_norm_)}},
    // optional double combined_bounds_l2_norm = 24;
    {::_pbi::TcParser::FastF64S2,
     {449, 23, 0,
      PROTOBUF_FIELD_OFFSET(QuadraticProgramStats, _impl_.combined_bounds_l2_norm_)}},
    // optional double constraint_matrix_l2_norm = 25;
    {::_pbi::TcParser::FastF64S2,
     {457, 24, 0,
      PROTOBUF_FIELD_OFFSET(QuadraticProgramStats, _impl_.constraint_matrix_l2_norm_)}},
    // optional double variable_bound_gaps_l2_norm = 26;
    {::_pbi::TcParser::FastF64S2,
     {465, 25, 0,
      PROTOBUF_FIELD_OFFSET(QuadraticProgramStats, _impl_.variable_bound_gaps_l2_norm_)}},
    // optional double objective_matrix_l2_norm = 27;
    {::_pbi::TcParser::FastF64S2,
     {473, 26, 0,
      PROTOBUF_FIELD_OFFSET(QuadraticProgramStats, _impl_.objective_matrix_l2_norm_)}},
    // optional double combined_variable_bounds_max = 28;
    {::_pbi::TcParser::FastF64S2,
     {481, 27, 0,
      PROTOBUF_FIELD_OFFSET(QuadraticProgramStats, _impl_.combined_variable_bounds_max_)}},
    // optional double combined_variable_bounds_min = 29;
    {::_pbi::TcParser::FastF64S2,
     {489, 28, 0,
      PROTOBUF_FIELD_OFFSET(QuadraticProgramStats, _impl_.combined_variable_bounds_min_)}},
    // optional double combined_variable_bounds_avg = 30;
    {::_pbi::TcParser::FastF64S2,
     {497, 29, 0,
      PROTOBUF_FIELD_OFFSET(QuadraticProgramStats, _impl_.combined_variable_bounds_avg_)}},
    // optional double combined_variable_bounds_l2_norm = 31;
    {::_pbi::TcParser::FastF64S2,
     {505, 30, 0,
      PROTOBUF_FIELD_OFFSET(QuadraticProgramStats, _impl_.combined_variable_bounds_l2_norm_)}},
  }}, {{
    65535, 65535
  }}, {{
    // optional int64 num_variables = 1;
    {PROTOBUF_FIELD_OFFSET(QuadraticProgramStats, _impl_.num_variables_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kInt64)},
    // optional int64 num_constraints = 2;
    {PROTOBUF_FIELD_OFFSET(QuadraticProgramStats, _impl_.num_constraints_), _Internal::kHasBitsOffset + 1, 0, (0 | ::_fl::kFcOptional | ::_fl::kInt64)},
    // optional double constraint_matrix_col_min_l_inf_norm = 3;
    {PROTOBUF_FIELD_OFFSET(QuadraticProgramStats, _impl_.constraint_matrix_col_min_l_inf_norm_), _Internal::kHasBitsOffset + 2, 0, (0 | ::_fl::kFcOptional | ::_fl::kDouble)},
    // optional double constraint_matrix_row_min_l_inf_norm = 4;
    {PROTOBUF_FIELD_OFFSET(QuadraticProgramStats, _impl_.constraint_matrix_row_min_l_inf_norm_), _Internal::kHasBitsOffset + 3, 0, (0 | ::_fl::kFcOptional | ::_fl::kDouble)},
    // optional int64 constraint_matrix_num_nonzeros = 5;
    {PROTOBUF_FIELD_OFFSET(QuadraticProgramStats, _impl_.constraint_matrix_num_nonzeros_), _Internal::kHasBitsOffset + 4, 0, (0 | ::_fl::kFcOptional | ::_fl::kInt64)},
    // optional double constraint_matrix_abs_max = 6;
    {PROTOBUF_FIELD_OFFSET(QuadraticProgramStats, _impl_.constraint_matrix_abs_max_), _Internal::kHasBitsOffset + 5, 0, (0 | ::_fl::kFcOptional | ::_fl::kDouble)},
    // optional double constraint_matrix_abs_min = 7;
    {PROTOBUF_FIELD_OFFSET(QuadraticProgramStats, _impl_.constraint_matrix_abs_min_), _Internal::kHasBitsOffset + 6, 0, (0 | ::_fl::kFcOptional | ::_fl::kDouble)},
    // optional double constraint_matrix_abs_avg = 8;
    {PROTOBUF_FIELD_OFFSET(QuadraticProgramStats, _impl_.constraint_matrix_abs_avg_), _Internal::kHasBitsOffset + 7, 0, (0 | ::_fl::kFcOptional | ::_fl::kDouble)},
    // optional double combined_bounds_max = 9;
    {PROTOBUF_FIELD_OFFSET(QuadraticProgramStats, _impl_.combined_bounds_max_), _Internal::kHasBitsOffset + 8, 0, (0 | ::_fl::kFcOptional | ::_fl::kDouble)},
    // optional double combined_bounds_min = 10;
    {PROTOBUF_FIELD_OFFSET(QuadraticProgramStats, _impl_.combined_bounds_min_), _Internal::kHasBitsOffset + 9, 0, (0 | ::_fl::kFcOptional | ::_fl::kDouble)},
    // optional double combined_bounds_avg = 11;
    {PROTOBUF_FIELD_OFFSET(QuadraticProgramStats, _impl_.combined_bounds_avg_), _Internal::kHasBitsOffset + 10, 0, (0 | ::_fl::kFcOptional | ::_fl::kDouble)},
    // optional int64 variable_bound_gaps_num_finite = 12;
    {PROTOBUF_FIELD_OFFSET(QuadraticProgramStats, _impl_.variable_bound_gaps_num_finite_), _Internal::kHasBitsOffset + 11, 0, (0 | ::_fl::kFcOptional | ::_fl::kInt64)},
    // optional double variable_bound_gaps_max = 13;
    {PROTOBUF_FIELD_OFFSET(QuadraticProgramStats, _impl_.variable_bound_gaps_max_), _Internal::kHasBitsOffset + 12, 0, (0 | ::_fl::kFcOptional | ::_fl::kDouble)},
    // optional double variable_bound_gaps_min = 14;
    {PROTOBUF_FIELD_OFFSET(QuadraticProgramStats, _impl_.variable_bound_gaps_min_), _Internal::kHasBitsOffset + 13, 0, (0 | ::_fl::kFcOptional | ::_fl::kDouble)},
    // optional double variable_bound_gaps_avg = 15;
    {PROTOBUF_FIELD_OFFSET(QuadraticProgramStats, _impl_.variable_bound_gaps_avg_), _Internal::kHasBitsOffset + 14, 0, (0 | ::_fl::kFcOptional | ::_fl::kDouble)},
    // optional double objective_vector_abs_max = 16;
    {PROTOBUF_FIELD_OFFSET(QuadraticProgramStats, _impl_.objective_vector_abs_max_), _Internal::kHasBitsOffset + 15, 0, (0 | ::_fl::kFcOptional | ::_fl::kDouble)},
    // optional double objective_vector_abs_min = 17;
    {PROTOBUF_FIELD_OFFSET(QuadraticProgramStats, _impl_.objective_vector_abs_min_), _Internal::kHasBitsOffset + 16, 0, (0 | ::_fl::kFcOptional | ::_fl::kDouble)},
    // optional double objective_vector_abs_avg = 18;
    {PROTOBUF_FIELD_OFFSET(QuadraticProgramStats, _impl_.objective_vector_abs_avg_), _Internal::kHasBitsOffset + 17, 0, (0 | ::_fl::kFcOptional | ::_fl::kDouble)},
    // optional int64 objective_matrix_num_nonzeros = 19;
    {PROTOBUF_FIELD_OFFSET(QuadraticProgramStats, _impl_.objective_matrix_num_nonzeros_), _Internal::kHasBitsOffset + 18, 0, (0 | ::_fl::kFcOptional | ::_fl::kInt64)},
    // optional double objective_matrix_abs_max = 20;
    {PROTOBUF_FIELD_OFFSET(QuadraticProgramStats, _impl_.objective_matrix_abs_max_), _Internal::kHasBitsOffset + 19, 0, (0 | ::_fl::kFcOptional | ::_fl::kDouble)},
    // optional double objective_matrix_abs_min = 21;
    {PROTOBUF_FIELD_OFFSET(QuadraticProgramStats, _impl_.objective_matrix_abs_min_), _Internal::kHasBitsOffset + 20, 0, (0 | ::_fl::kFcOptional | ::_fl::kDouble)},
    // optional double objective_matrix_abs_avg = 22;
    {PROTOBUF_FIELD_OFFSET(QuadraticProgramStats, _impl_.objective_matrix_abs_avg_), _Internal::kHasBitsOffset + 21, 0, (0 | ::_fl::kFcOptional | ::_fl::kDouble)},
    // optional double objective_vector_l2_norm = 23;
    {PROTOBUF_FIELD_OFFSET(QuadraticProgramStats, _impl_.objective_vector_l2_norm_), _Internal::kHasBitsOffset + 22, 0, (0 | ::_fl::kFcOptional | ::_fl::kDouble)},
    // optional double combined_bounds_l2_norm = 24;
    {PROTOBUF_FIELD_OFFSET(QuadraticProgramStats, _impl_.combined_bounds_l2_norm_), _Internal::kHasBitsOffset + 23, 0, (0 | ::_fl::kFcOptional | ::_fl::kDouble)},
    // optional double constraint_matrix_l2_norm = 25;
    {PROTOBUF_FIELD_OFFSET(QuadraticProgramStats, _impl_.constraint_matrix_l2_norm_), _Internal::kHasBitsOffset + 24, 0, (0 | ::_fl::kFcOptional | ::_fl::kDouble)},
    // optional double variable_bound_gaps_l2_norm = 26;
    {PROTOBUF_FIELD_OFFSET(QuadraticProgramStats, _impl_.variable_bound_gaps_l2_norm_), _Internal::kHasBitsOffset + 25, 0, (0 | ::_fl::kFcOptional | ::_fl::kDouble)},
    // optional double objective_matrix_l2_norm = 27;
    {PROTOBUF_FIELD_OFFSET(QuadraticProgramStats, _impl_.objective_matrix_l2_norm_), _Internal::kHasBitsOffset + 26, 0, (0 | ::_fl::kFcOptional | ::_fl::kDouble)},
    // optional double combined_variable_bounds_max = 28;
    {PROTOBUF_FIELD_OFFSET(QuadraticProgramStats, _impl_.combined_variable_bounds_max_), _Internal::kHasBitsOffset + 27, 0, (0 | ::_fl::kFcOptional | ::_fl::kDouble)},
    // optional double combined_variable_bounds_min = 29;
    {PROTOBUF_FIELD_OFFSET(QuadraticProgramStats, _impl_.combined_variable_bounds_min_), _Internal::kHasBitsOffset + 28, 0, (0 | ::_fl::kFcOptional | ::_fl::kDouble)},
    // optional double combined_variable_bounds_avg = 30;
    {PROTOBUF_FIELD_OFFSET(QuadraticProgramStats, _impl_.combined_variable_bounds_avg_), _Internal::kHasBitsOffset + 29, 0, (0 | ::_fl::kFcOptional | ::_fl::kDouble)},
    // optional double combined_variable_bounds_l2_norm = 31;
    {PROTOBUF_FIELD_OFFSET(QuadraticProgramStats, _impl_.combined_variable_bounds_l2_norm_), _Internal::kHasBitsOffset + 30, 0, (0 | ::_fl::kFcOptional | ::_fl::kDouble)},
  }},
  // no aux_entries
  {{
  }},
};
PROTOBUF_NOINLINE void QuadraticProgramStats::Clear() {
// @@protoc_insertion_point(message_clear_start:operations_research.pdlp.QuadraticProgramStats)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;
 
  cached_has_bits = _impl_._has_bits_[0];
  if (BatchCheckHasBit(cached_has_bits, 0x000000ffU)) {
    ::memset(&_impl_.num_variables_, 0, static_cast<::size_t>(
        reinterpret_cast<char*>(&_impl_.constraint_matrix_abs_avg_) -
        reinterpret_cast<char*>(&_impl_.num_variables_)) + sizeof(_impl_.constraint_matrix_abs_avg_));
  }
  if (BatchCheckHasBit(cached_has_bits, 0x0000ff00U)) {
    ::memset(&_impl_.combined_bounds_max_, 0, static_cast<::size_t>(
        reinterpret_cast<char*>(&_impl_.objective_vector_abs_max_) -
        reinterpret_cast<char*>(&_impl_.combined_bounds_max_)) + sizeof(_impl_.objective_vector_abs_max_));
  }
  if (BatchCheckHasBit(cached_has_bits, 0x00ff0000U)) {
    ::memset(&_impl_.objective_vector_abs_min_, 0, static_cast<::size_t>(
        reinterpret_cast<char*>(&_impl_.combined_bounds_l2_norm_) -
        reinterpret_cast<char*>(&_impl_.objective_vector_abs_min_)) + sizeof(_impl_.combined_bounds_l2_norm_));
  }
  if (BatchCheckHasBit(cached_has_bits, 0x7f000000U)) {
    ::memset(&_impl_.constraint_matrix_l2_norm_, 0, static_cast<::size_t>(
        reinterpret_cast<char*>(&_impl_.combined_variable_bounds_l2_norm_) -
        reinterpret_cast<char*>(&_impl_.constraint_matrix_l2_norm_)) + sizeof(_impl_.combined_variable_bounds_l2_norm_));
  }
  _impl_._has_bits_.Clear();
  _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>();
}
 
#if defined(PROTOBUF_CUSTOM_VTABLE)
::uint8_t* PROTOBUF_NONNULL QuadraticProgramStats::_InternalSerialize(
    const ::google::protobuf::MessageLite& base, ::uint8_t* PROTOBUF_NONNULL target,
    ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) {
  const QuadraticProgramStats& this_ = static_cast<const QuadraticProgramStats&>(base);
#else   // PROTOBUF_CUSTOM_VTABLE
::uint8_t* PROTOBUF_NONNULL QuadraticProgramStats::_InternalSerialize(
    ::uint8_t* PROTOBUF_NONNULL target,
    ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const {
  const QuadraticProgramStats& this_ = *this;
#endif  // PROTOBUF_CUSTOM_VTABLE
  if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) {
    this_.CheckHasBitConsistency();
  }
  // @@protoc_insertion_point(serialize_to_array_start:operations_research.pdlp.QuadraticProgramStats)
  ::uint32_t cached_has_bits = 0;
  (void)cached_has_bits;
 
  cached_has_bits = this_._impl_._has_bits_[0];
  // optional int64 num_variables = 1;
  if (CheckHasBit(cached_has_bits, 0x00000001U)) {
    target =
        ::google::protobuf::internal::WireFormatLite::WriteInt64ToArrayWithField<1>(
            stream, this_._internal_num_variables(), target);
  }
 
  // optional int64 num_constraints = 2;
  if (CheckHasBit(cached_has_bits, 0x00000002U)) {
    target =
        ::google::protobuf::internal::WireFormatLite::WriteInt64ToArrayWithField<2>(
            stream, this_._internal_num_constraints(), target);
  }
 
  // optional double constraint_matrix_col_min_l_inf_norm = 3;
  if (CheckHasBit(cached_has_bits, 0x00000004U)) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteDoubleToArray(
        3, this_._internal_constraint_matrix_col_min_l_inf_norm(), target);
  }
 
  // optional double constraint_matrix_row_min_l_inf_norm = 4;
  if (CheckHasBit(cached_has_bits, 0x00000008U)) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteDoubleToArray(
        4, this_._internal_constraint_matrix_row_min_l_inf_norm(), target);
  }
 
  // optional int64 constraint_matrix_num_nonzeros = 5;
  if (CheckHasBit(cached_has_bits, 0x00000010U)) {
    target =
        ::google::protobuf::internal::WireFormatLite::WriteInt64ToArrayWithField<5>(
            stream, this_._internal_constraint_matrix_num_nonzeros(), target);
  }
 
  // optional double constraint_matrix_abs_max = 6;
  if (CheckHasBit(cached_has_bits, 0x00000020U)) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteDoubleToArray(
        6, this_._internal_constraint_matrix_abs_max(), target);
  }
 
  // optional double constraint_matrix_abs_min = 7;
  if (CheckHasBit(cached_has_bits, 0x00000040U)) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteDoubleToArray(
        7, this_._internal_constraint_matrix_abs_min(), target);
  }
 
  // optional double constraint_matrix_abs_avg = 8;
  if (CheckHasBit(cached_has_bits, 0x00000080U)) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteDoubleToArray(
        8, this_._internal_constraint_matrix_abs_avg(), target);
  }
 
  // optional double combined_bounds_max = 9;
  if (CheckHasBit(cached_has_bits, 0x00000100U)) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteDoubleToArray(
        9, this_._internal_combined_bounds_max(), target);
  }
 
  // optional double combined_bounds_min = 10;
  if (CheckHasBit(cached_has_bits, 0x00000200U)) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteDoubleToArray(
        10, this_._internal_combined_bounds_min(), target);
  }
 
  // optional double combined_bounds_avg = 11;
  if (CheckHasBit(cached_has_bits, 0x00000400U)) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteDoubleToArray(
        11, this_._internal_combined_bounds_avg(), target);
  }
 
  // optional int64 variable_bound_gaps_num_finite = 12;
  if (CheckHasBit(cached_has_bits, 0x00000800U)) {
    target =
        ::google::protobuf::internal::WireFormatLite::WriteInt64ToArrayWithField<12>(
            stream, this_._internal_variable_bound_gaps_num_finite(), target);
  }
 
  // optional double variable_bound_gaps_max = 13;
  if (CheckHasBit(cached_has_bits, 0x00001000U)) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteDoubleToArray(
        13, this_._internal_variable_bound_gaps_max(), target);
  }
 
  // optional double variable_bound_gaps_min = 14;
  if (CheckHasBit(cached_has_bits, 0x00002000U)) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteDoubleToArray(
        14, this_._internal_variable_bound_gaps_min(), target);
  }
 
  // optional double variable_bound_gaps_avg = 15;
  if (CheckHasBit(cached_has_bits, 0x00004000U)) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteDoubleToArray(
        15, this_._internal_variable_bound_gaps_avg(), target);
  }
 
  // optional double objective_vector_abs_max = 16;
  if (CheckHasBit(cached_has_bits, 0x00008000U)) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteDoubleToArray(
        16, this_._internal_objective_vector_abs_max(), target);
  }
 
  // optional double objective_vector_abs_min = 17;
  if (CheckHasBit(cached_has_bits, 0x00010000U)) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteDoubleToArray(
        17, this_._internal_objective_vector_abs_min(), target);
  }
 
  // optional double objective_vector_abs_avg = 18;
  if (CheckHasBit(cached_has_bits, 0x00020000U)) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteDoubleToArray(
        18, this_._internal_objective_vector_abs_avg(), target);
  }
 
  // optional int64 objective_matrix_num_nonzeros = 19;
  if (CheckHasBit(cached_has_bits, 0x00040000U)) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteInt64ToArray(
        19, this_._internal_objective_matrix_num_nonzeros(), target);
  }
 
  // optional double objective_matrix_abs_max = 20;
  if (CheckHasBit(cached_has_bits, 0x00080000U)) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteDoubleToArray(
        20, this_._internal_objective_matrix_abs_max(), target);
  }
 
  // optional double objective_matrix_abs_min = 21;
  if (CheckHasBit(cached_has_bits, 0x00100000U)) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteDoubleToArray(
        21, this_._internal_objective_matrix_abs_min(), target);
  }
 
  // optional double objective_matrix_abs_avg = 22;
  if (CheckHasBit(cached_has_bits, 0x00200000U)) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteDoubleToArray(
        22, this_._internal_objective_matrix_abs_avg(), target);
  }
 
  // optional double objective_vector_l2_norm = 23;
  if (CheckHasBit(cached_has_bits, 0x00400000U)) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteDoubleToArray(
        23, this_._internal_objective_vector_l2_norm(), target);
  }
 
  // optional double combined_bounds_l2_norm = 24;
  if (CheckHasBit(cached_has_bits, 0x00800000U)) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteDoubleToArray(
        24, this_._internal_combined_bounds_l2_norm(), target);
  }
 
  // optional double constraint_matrix_l2_norm = 25;
  if (CheckHasBit(cached_has_bits, 0x01000000U)) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteDoubleToArray(
        25, this_._internal_constraint_matrix_l2_norm(), target);
  }
 
  // optional double variable_bound_gaps_l2_norm = 26;
  if (CheckHasBit(cached_has_bits, 0x02000000U)) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteDoubleToArray(
        26, this_._internal_variable_bound_gaps_l2_norm(), target);
  }
 
  // optional double objective_matrix_l2_norm = 27;
  if (CheckHasBit(cached_has_bits, 0x04000000U)) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteDoubleToArray(
        27, this_._internal_objective_matrix_l2_norm(), target);
  }
 
  // optional double combined_variable_bounds_max = 28;
  if (CheckHasBit(cached_has_bits, 0x08000000U)) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteDoubleToArray(
        28, this_._internal_combined_variable_bounds_max(), target);
  }
 
  // optional double combined_variable_bounds_min = 29;
  if (CheckHasBit(cached_has_bits, 0x10000000U)) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteDoubleToArray(
        29, this_._internal_combined_variable_bounds_min(), target);
  }
 
  // optional double combined_variable_bounds_avg = 30;
  if (CheckHasBit(cached_has_bits, 0x20000000U)) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteDoubleToArray(
        30, this_._internal_combined_variable_bounds_avg(), target);
  }
 
  // optional double combined_variable_bounds_l2_norm = 31;
  if (CheckHasBit(cached_has_bits, 0x40000000U)) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteDoubleToArray(
        31, this_._internal_combined_variable_bounds_l2_norm(), target);
  }
 
  if (ABSL_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) {
    target =
        ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray(
            this_._internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:operations_research.pdlp.QuadraticProgramStats)
  return target;
}
 
#if defined(PROTOBUF_CUSTOM_VTABLE)
::size_t QuadraticProgramStats::ByteSizeLong(const MessageLite& base) {
  const QuadraticProgramStats& this_ = static_cast<const QuadraticProgramStats&>(base);
#else   // PROTOBUF_CUSTOM_VTABLE
::size_t QuadraticProgramStats::ByteSizeLong() const {
  const QuadraticProgramStats& this_ = *this;
#endif  // PROTOBUF_CUSTOM_VTABLE
  // @@protoc_insertion_point(message_byte_size_start:operations_research.pdlp.QuadraticProgramStats)
  ::size_t total_size = 0;
 
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void)cached_has_bits;
 
  ::_pbi::Prefetch5LinesFrom7Lines(&this_);
  cached_has_bits = this_._impl_._has_bits_[0];
  total_size += ::absl::popcount(0x7ffb8000U & cached_has_bits) * 10;
  total_size += ::absl::popcount(0x000077ecU & cached_has_bits) * 9;
  if (BatchCheckHasBit(cached_has_bits, 0x00000013U)) {
    // optional int64 num_variables = 1;
    if (CheckHasBit(cached_has_bits, 0x00000001U)) {
      total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(
          this_._internal_num_variables());
    }
    // optional int64 num_constraints = 2;
    if (CheckHasBit(cached_has_bits, 0x00000002U)) {
      total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(
          this_._internal_num_constraints());
    }
    // optional int64 constraint_matrix_num_nonzeros = 5;
    if (CheckHasBit(cached_has_bits, 0x00000010U)) {
      total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(
          this_._internal_constraint_matrix_num_nonzeros());
    }
  }
   {
    // optional int64 variable_bound_gaps_num_finite = 12;
    if (CheckHasBit(cached_has_bits, 0x00000800U)) {
      total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(
          this_._internal_variable_bound_gaps_num_finite());
    }
  }
   {
    // optional int64 objective_matrix_num_nonzeros = 19;
    if (CheckHasBit(cached_has_bits, 0x00040000U)) {
      total_size += 2 + ::_pbi::WireFormatLite::Int64Size(
                                      this_._internal_objective_matrix_num_nonzeros());
    }
  }
  return this_.MaybeComputeUnknownFieldsSize(total_size,
                                             &this_._impl_._cached_size_);
}
 
void QuadraticProgramStats::MergeImpl(::google::protobuf::MessageLite& to_msg,
                            const ::google::protobuf::MessageLite& from_msg) {
   auto* const _this =
      static_cast<QuadraticProgramStats*>(&to_msg);
  auto& from = static_cast<const QuadraticProgramStats&>(from_msg);
  if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) {
    from.CheckHasBitConsistency();
  }
  // @@protoc_insertion_point(class_specific_merge_from_start:operations_research.pdlp.QuadraticProgramStats)
  ABSL_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void)cached_has_bits;
 
  cached_has_bits = from._impl_._has_bits_[0];
  if (BatchCheckHasBit(cached_has_bits, 0x000000ffU)) {
    if (CheckHasBit(cached_has_bits, 0x00000001U)) {
      _this->_impl_.num_variables_ = from._impl_.num_variables_;
    }
    if (CheckHasBit(cached_has_bits, 0x00000002U)) {
      _this->_impl_.num_constraints_ = from._impl_.num_constraints_;
    }
    if (CheckHasBit(cached_has_bits, 0x00000004U)) {
      _this->_impl_.constraint_matrix_col_min_l_inf_norm_ = from._impl_.constraint_matrix_col_min_l_inf_norm_;
    }
    if (CheckHasBit(cached_has_bits, 0x00000008U)) {
      _this->_impl_.constraint_matrix_row_min_l_inf_norm_ = from._impl_.constraint_matrix_row_min_l_inf_norm_;
    }
    if (CheckHasBit(cached_has_bits, 0x00000010U)) {
      _this->_impl_.constraint_matrix_num_nonzeros_ = from._impl_.constraint_matrix_num_nonzeros_;
    }
    if (CheckHasBit(cached_has_bits, 0x00000020U)) {
      _this->_impl_.constraint_matrix_abs_max_ = from._impl_.constraint_matrix_abs_max_;
    }
    if (CheckHasBit(cached_has_bits, 0x00000040U)) {
      _this->_impl_.constraint_matrix_abs_min_ = from._impl_.constraint_matrix_abs_min_;
    }
    if (CheckHasBit(cached_has_bits, 0x00000080U)) {
      _this->_impl_.constraint_matrix_abs_avg_ = from._impl_.constraint_matrix_abs_avg_;
    }
  }
  if (BatchCheckHasBit(cached_has_bits, 0x0000ff00U)) {
    if (CheckHasBit(cached_has_bits, 0x00000100U)) {
      _this->_impl_.combined_bounds_max_ = from._impl_.combined_bounds_max_;
    }
    if (CheckHasBit(cached_has_bits, 0x00000200U)) {
      _this->_impl_.combined_bounds_min_ = from._impl_.combined_bounds_min_;
    }
    if (CheckHasBit(cached_has_bits, 0x00000400U)) {
      _this->_impl_.combined_bounds_avg_ = from._impl_.combined_bounds_avg_;
    }
    if (CheckHasBit(cached_has_bits, 0x00000800U)) {
      _this->_impl_.variable_bound_gaps_num_finite_ = from._impl_.variable_bound_gaps_num_finite_;
    }
    if (CheckHasBit(cached_has_bits, 0x00001000U)) {
      _this->_impl_.variable_bound_gaps_max_ = from._impl_.variable_bound_gaps_max_;
    }
    if (CheckHasBit(cached_has_bits, 0x00002000U)) {
      _this->_impl_.variable_bound_gaps_min_ = from._impl_.variable_bound_gaps_min_;
    }
    if (CheckHasBit(cached_has_bits, 0x00004000U)) {
      _this->_impl_.variable_bound_gaps_avg_ = from._impl_.variable_bound_gaps_avg_;
    }
    if (CheckHasBit(cached_has_bits, 0x00008000U)) {
      _this->_impl_.objective_vector_abs_max_ = from._impl_.objective_vector_abs_max_;
    }
  }
  if (BatchCheckHasBit(cached_has_bits, 0x00ff0000U)) {
    if (CheckHasBit(cached_has_bits, 0x00010000U)) {
      _this->_impl_.objective_vector_abs_min_ = from._impl_.objective_vector_abs_min_;
    }
    if (CheckHasBit(cached_has_bits, 0x00020000U)) {
      _this->_impl_.objective_vector_abs_avg_ = from._impl_.objective_vector_abs_avg_;
    }
    if (CheckHasBit(cached_has_bits, 0x00040000U)) {
      _this->_impl_.objective_matrix_num_nonzeros_ = from._impl_.objective_matrix_num_nonzeros_;
    }
    if (CheckHasBit(cached_has_bits, 0x00080000U)) {
      _this->_impl_.objective_matrix_abs_max_ = from._impl_.objective_matrix_abs_max_;
    }
    if (CheckHasBit(cached_has_bits, 0x00100000U)) {
      _this->_impl_.objective_matrix_abs_min_ = from._impl_.objective_matrix_abs_min_;
    }
    if (CheckHasBit(cached_has_bits, 0x00200000U)) {
      _this->_impl_.objective_matrix_abs_avg_ = from._impl_.objective_matrix_abs_avg_;
    }
    if (CheckHasBit(cached_has_bits, 0x00400000U)) {
      _this->_impl_.objective_vector_l2_norm_ = from._impl_.objective_vector_l2_norm_;
    }
    if (CheckHasBit(cached_has_bits, 0x00800000U)) {
      _this->_impl_.combined_bounds_l2_norm_ = from._impl_.combined_bounds_l2_norm_;
    }
  }
  if (BatchCheckHasBit(cached_has_bits, 0x7f000000U)) {
    if (CheckHasBit(cached_has_bits, 0x01000000U)) {
      _this->_impl_.constraint_matrix_l2_norm_ = from._impl_.constraint_matrix_l2_norm_;
    }
    if (CheckHasBit(cached_has_bits, 0x02000000U)) {
      _this->_impl_.variable_bound_gaps_l2_norm_ = from._impl_.variable_bound_gaps_l2_norm_;
    }
    if (CheckHasBit(cached_has_bits, 0x04000000U)) {
      _this->_impl_.objective_matrix_l2_norm_ = from._impl_.objective_matrix_l2_norm_;
    }
    if (CheckHasBit(cached_has_bits, 0x08000000U)) {
      _this->_impl_.combined_variable_bounds_max_ = from._impl_.combined_variable_bounds_max_;
    }
    if (CheckHasBit(cached_has_bits, 0x10000000U)) {
      _this->_impl_.combined_variable_bounds_min_ = from._impl_.combined_variable_bounds_min_;
    }
    if (CheckHasBit(cached_has_bits, 0x20000000U)) {
      _this->_impl_.combined_variable_bounds_avg_ = from._impl_.combined_variable_bounds_avg_;
    }
    if (CheckHasBit(cached_has_bits, 0x40000000U)) {
      _this->_impl_.combined_variable_bounds_l2_norm_ = from._impl_.combined_variable_bounds_l2_norm_;
    }
  }
  _this->_impl_._has_bits_[0] |= cached_has_bits;
  _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(
      from._internal_metadata_);
}
 
void QuadraticProgramStats::CopyFrom(const QuadraticProgramStats& from) {
  // @@protoc_insertion_point(class_specific_copy_from_start:operations_research.pdlp.QuadraticProgramStats)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}
 
 
void QuadraticProgramStats::InternalSwap(QuadraticProgramStats* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) {
  using ::std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
  ::google::protobuf::internal::memswap<
      PROTOBUF_FIELD_OFFSET(QuadraticProgramStats, _impl_.combined_variable_bounds_l2_norm_)
      + sizeof(QuadraticProgramStats::_impl_.combined_variable_bounds_l2_norm_)
      - PROTOBUF_FIELD_OFFSET(QuadraticProgramStats, _impl_.num_variables_)>(
          reinterpret_cast<char*>(&_impl_.num_variables_),
          reinterpret_cast<char*>(&other->_impl_.num_variables_));
}
 
::google::protobuf::Metadata QuadraticProgramStats::GetMetadata() const {
  return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full());
}
// ===================================================================
 
class ConvergenceInformation::_Internal {
 public:
  using HasBits =
      decltype(::std::declval<ConvergenceInformation>()._impl_._has_bits_);
  static constexpr ::int32_t kHasBitsOffset =
      8 * PROTOBUF_FIELD_OFFSET(ConvergenceInformation, _impl_._has_bits_);
};
 
ConvergenceInformation::ConvergenceInformation(::google::protobuf::Arena* PROTOBUF_NULLABLE arena)
#if defined(PROTOBUF_CUSTOM_VTABLE)
    : ::google::protobuf::Message(arena, ConvergenceInformation_class_data_.base()) {
#else   // PROTOBUF_CUSTOM_VTABLE
    : ::google::protobuf::Message(arena) {
#endif  // PROTOBUF_CUSTOM_VTABLE
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:operations_research.pdlp.ConvergenceInformation)
}
ConvergenceInformation::ConvergenceInformation(
    ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const ConvergenceInformation& from)
#if defined(PROTOBUF_CUSTOM_VTABLE)
    : ::google::protobuf::Message(arena, ConvergenceInformation_class_data_.base()),
#else   // PROTOBUF_CUSTOM_VTABLE
    : ::google::protobuf::Message(arena),
#endif  // PROTOBUF_CUSTOM_VTABLE
      _impl_(from._impl_) {
  _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(
      from._internal_metadata_);
}
PROTOBUF_NDEBUG_INLINE ConvergenceInformation::Impl_::Impl_(
    [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility,
    [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena)
      : _cached_size_{0} {}
 
inline void ConvergenceInformation::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) {
  new (&_impl_) Impl_(internal_visibility(), arena);
  ::memset(reinterpret_cast<char*>(&_impl_) +
               offsetof(Impl_, primal_objective_),
           0,
           offsetof(Impl_, candidate_type_) -
               offsetof(Impl_, primal_objective_) +
               sizeof(Impl_::candidate_type_));
}
ConvergenceInformation::~ConvergenceInformation() {
  // @@protoc_insertion_point(destructor:operations_research.pdlp.ConvergenceInformation)
  SharedDtor(*this);
}
inline void ConvergenceInformation::SharedDtor(MessageLite& self) {
  ConvergenceInformation& this_ = static_cast<ConvergenceInformation&>(self);
  if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) {
    this_.CheckHasBitConsistency();
  }
  this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>();
  ABSL_DCHECK(this_.GetArena() == nullptr);
  this_._impl_.~Impl_();
}
 
inline void* PROTOBUF_NONNULL ConvergenceInformation::PlacementNew_(
    const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem,
    ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) {
  return ::new (mem) ConvergenceInformation(arena);
}
constexpr auto ConvergenceInformation::InternalNewImpl_() {
  return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(ConvergenceInformation),
                                            alignof(ConvergenceInformation));
}
constexpr auto ConvergenceInformation::InternalGenerateClassData_() {
  return ::google::protobuf::internal::ClassDataFull{
      ::google::protobuf::internal::ClassData{
          &_ConvergenceInformation_default_instance_._instance,
          &_table_.header,
          nullptr,  // OnDemandRegisterArenaDtor
          nullptr,  // IsInitialized
          &ConvergenceInformation::MergeImpl,
          ::google::protobuf::Message::GetNewImpl<ConvergenceInformation>(),
#if defined(PROTOBUF_CUSTOM_VTABLE)
          &ConvergenceInformation::SharedDtor,
          ::google::protobuf::Message::GetClearImpl<ConvergenceInformation>(), &ConvergenceInformation::ByteSizeLong,
              &ConvergenceInformation::_InternalSerialize,
#endif  // PROTOBUF_CUSTOM_VTABLE
          PROTOBUF_FIELD_OFFSET(ConvergenceInformation, _impl_._cached_size_),
          false,
      },
      &ConvergenceInformation::kDescriptorMethods,
      &descriptor_table_ortools_2fpdlp_2fsolve_5flog_2eproto,
      nullptr,  // tracker
  };
}
 
PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const
    ::google::protobuf::internal::ClassDataFull ConvergenceInformation_class_data_ =
        ConvergenceInformation::InternalGenerateClassData_();
 
PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL
ConvergenceInformation::GetClassData() const {
  ::google::protobuf::internal::PrefetchToLocalCache(&ConvergenceInformation_class_data_);
  ::google::protobuf::internal::PrefetchToLocalCache(ConvergenceInformation_class_data_.tc_table);
  return ConvergenceInformation_class_data_.base();
}
PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1
const ::_pbi::TcParseTable<4, 14, 1, 0, 2>
ConvergenceInformation::_table_ = {
  {
    PROTOBUF_FIELD_OFFSET(ConvergenceInformation, _impl_._has_bits_),
    0, // no _extensions_
    25, 120,  // max_field_number, fast_idx_mask
    offsetof(decltype(_table_), field_lookup_table),
    4269678336,  // skipmap
    offsetof(decltype(_table_), field_entries),
    14,  // num_field_entries
    1,  // num_aux_entries
    offsetof(decltype(_table_), aux_entries),
    ConvergenceInformation_class_data_.base(),
    nullptr,  // post_loop_handler
    ::_pbi::TcParser::GenericFallback,  // fallback
    #ifdef PROTOBUF_PREFETCH_PARSE_TABLE
    ::_pbi::TcParser::GetTable<::operations_research::pdlp::ConvergenceInformation>(),  // to_prefetch
    #endif  // PROTOBUF_PREFETCH_PARSE_TABLE
  }, {{
    // optional double l_inf_dual_variable = 16;
    {::_pbi::TcParser::FastF64S2,
     {385, 9, 0,
      PROTOBUF_FIELD_OFFSET(ConvergenceInformation, _impl_.l_inf_dual_variable_)}},
    // optional .operations_research.pdlp.PointType candidate_type = 1;
    {::_pbi::TcParser::FastEr0S1,
     {8, 13, 6,
      PROTOBUF_FIELD_OFFSET(ConvergenceInformation, _impl_.candidate_type_)}},
    // optional double primal_objective = 2;
    {::_pbi::TcParser::FastF64S1,
     {17, 0, 0,
      PROTOBUF_FIELD_OFFSET(ConvergenceInformation, _impl_.primal_objective_)}},
    // optional double dual_objective = 3;
    {::_pbi::TcParser::FastF64S1,
     {25, 1, 0,
      PROTOBUF_FIELD_OFFSET(ConvergenceInformation, _impl_.dual_objective_)}},
    // optional double corrected_dual_objective = 4;
    {::_pbi::TcParser::FastF64S1,
     {33, 2, 0,
      PROTOBUF_FIELD_OFFSET(ConvergenceInformation, _impl_.corrected_dual_objective_)}},
    // optional double l_inf_primal_residual = 5;
    {::_pbi::TcParser::FastF64S1,
     {41, 3, 0,
      PROTOBUF_FIELD_OFFSET(ConvergenceInformation, _impl_.l_inf_primal_residual_)}},
    // optional double l2_primal_residual = 6;
    {::_pbi::TcParser::FastF64S1,
     {49, 4, 0,
      PROTOBUF_FIELD_OFFSET(ConvergenceInformation, _impl_.l2_primal_residual_)}},
    // optional double l_inf_dual_residual = 7;
    {::_pbi::TcParser::FastF64S1,
     {57, 5, 0,
      PROTOBUF_FIELD_OFFSET(ConvergenceInformation, _impl_.l_inf_dual_residual_)}},
    // optional double l2_dual_residual = 8;
    {::_pbi::TcParser::FastF64S1,
     {65, 6, 0,
      PROTOBUF_FIELD_OFFSET(ConvergenceInformation, _impl_.l2_dual_residual_)}},
    // optional double l_inf_componentwise_dual_residual = 25;
    {::_pbi::TcParser::FastF64S2,
     {457, 12, 0,
      PROTOBUF_FIELD_OFFSET(ConvergenceInformation, _impl_.l_inf_componentwise_dual_residual_)}},
    {::_pbi::TcParser::MiniParse, {}},
    {::_pbi::TcParser::MiniParse, {}},
    {::_pbi::TcParser::MiniParse, {}},
    {::_pbi::TcParser::MiniParse, {}},
    // optional double l_inf_primal_variable = 14;
    {::_pbi::TcParser::FastF64S1,
     {113, 7, 0,
      PROTOBUF_FIELD_OFFSET(ConvergenceInformation, _impl_.l_inf_primal_variable_)}},
    // optional double l2_primal_variable = 15;
    {::_pbi::TcParser::FastF64S1,
     {121, 8, 0,
      PROTOBUF_FIELD_OFFSET(ConvergenceInformation, _impl_.l2_primal_variable_)}},
  }}, {{
    65535, 65535
  }}, {{
    // optional .operations_research.pdlp.PointType candidate_type = 1;
    {PROTOBUF_FIELD_OFFSET(ConvergenceInformation, _impl_.candidate_type_), _Internal::kHasBitsOffset + 13, 0, (0 | ::_fl::kFcOptional | ::_fl::kEnumRange)},
    // optional double primal_objective = 2;
    {PROTOBUF_FIELD_OFFSET(ConvergenceInformation, _impl_.primal_objective_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kDouble)},
    // optional double dual_objective = 3;
    {PROTOBUF_FIELD_OFFSET(ConvergenceInformation, _impl_.dual_objective_), _Internal::kHasBitsOffset + 1, 0, (0 | ::_fl::kFcOptional | ::_fl::kDouble)},
    // optional double corrected_dual_objective = 4;
    {PROTOBUF_FIELD_OFFSET(ConvergenceInformation, _impl_.corrected_dual_objective_), _Internal::kHasBitsOffset + 2, 0, (0 | ::_fl::kFcOptional | ::_fl::kDouble)},
    // optional double l_inf_primal_residual = 5;
    {PROTOBUF_FIELD_OFFSET(ConvergenceInformation, _impl_.l_inf_primal_residual_), _Internal::kHasBitsOffset + 3, 0, (0 | ::_fl::kFcOptional | ::_fl::kDouble)},
    // optional double l2_primal_residual = 6;
    {PROTOBUF_FIELD_OFFSET(ConvergenceInformation, _impl_.l2_primal_residual_), _Internal::kHasBitsOffset + 4, 0, (0 | ::_fl::kFcOptional | ::_fl::kDouble)},
    // optional double l_inf_dual_residual = 7;
    {PROTOBUF_FIELD_OFFSET(ConvergenceInformation, _impl_.l_inf_dual_residual_), _Internal::kHasBitsOffset + 5, 0, (0 | ::_fl::kFcOptional | ::_fl::kDouble)},
    // optional double l2_dual_residual = 8;
    {PROTOBUF_FIELD_OFFSET(ConvergenceInformation, _impl_.l2_dual_residual_), _Internal::kHasBitsOffset + 6, 0, (0 | ::_fl::kFcOptional | ::_fl::kDouble)},
    // optional double l_inf_primal_variable = 14;
    {PROTOBUF_FIELD_OFFSET(ConvergenceInformation, _impl_.l_inf_primal_variable_), _Internal::kHasBitsOffset + 7, 0, (0 | ::_fl::kFcOptional | ::_fl::kDouble)},
    // optional double l2_primal_variable = 15;
    {PROTOBUF_FIELD_OFFSET(ConvergenceInformation, _impl_.l2_primal_variable_), _Internal::kHasBitsOffset + 8, 0, (0 | ::_fl::kFcOptional | ::_fl::kDouble)},
    // optional double l_inf_dual_variable = 16;
    {PROTOBUF_FIELD_OFFSET(ConvergenceInformation, _impl_.l_inf_dual_variable_), _Internal::kHasBitsOffset + 9, 0, (0 | ::_fl::kFcOptional | ::_fl::kDouble)},
    // optional double l2_dual_variable = 17;
    {PROTOBUF_FIELD_OFFSET(ConvergenceInformation, _impl_.l2_dual_variable_), _Internal::kHasBitsOffset + 10, 0, (0 | ::_fl::kFcOptional | ::_fl::kDouble)},
    // optional double l_inf_componentwise_primal_residual = 24;
    {PROTOBUF_FIELD_OFFSET(ConvergenceInformation, _impl_.l_inf_componentwise_primal_residual_), _Internal::kHasBitsOffset + 11, 0, (0 | ::_fl::kFcOptional | ::_fl::kDouble)},
    // optional double l_inf_componentwise_dual_residual = 25;
    {PROTOBUF_FIELD_OFFSET(ConvergenceInformation, _impl_.l_inf_componentwise_dual_residual_), _Internal::kHasBitsOffset + 12, 0, (0 | ::_fl::kFcOptional | ::_fl::kDouble)},
  }},
  {{
      {0, 6},
  }},
  {{
  }},
};
PROTOBUF_NOINLINE void ConvergenceInformation::Clear() {
// @@protoc_insertion_point(message_clear_start:operations_research.pdlp.ConvergenceInformation)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;
 
  cached_has_bits = _impl_._has_bits_[0];
  if (BatchCheckHasBit(cached_has_bits, 0x000000ffU)) {
    ::memset(&_impl_.primal_objective_, 0, static_cast<::size_t>(
        reinterpret_cast<char*>(&_impl_.l_inf_primal_variable_) -
        reinterpret_cast<char*>(&_impl_.primal_objective_)) + sizeof(_impl_.l_inf_primal_variable_));
  }
  if (BatchCheckHasBit(cached_has_bits, 0x00003f00U)) {
    ::memset(&_impl_.l2_primal_variable_, 0, static_cast<::size_t>(
        reinterpret_cast<char*>(&_impl_.candidate_type_) -
        reinterpret_cast<char*>(&_impl_.l2_primal_variable_)) + sizeof(_impl_.candidate_type_));
  }
  _impl_._has_bits_.Clear();
  _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>();
}
 
#if defined(PROTOBUF_CUSTOM_VTABLE)
::uint8_t* PROTOBUF_NONNULL ConvergenceInformation::_InternalSerialize(
    const ::google::protobuf::MessageLite& base, ::uint8_t* PROTOBUF_NONNULL target,
    ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) {
  const ConvergenceInformation& this_ = static_cast<const ConvergenceInformation&>(base);
#else   // PROTOBUF_CUSTOM_VTABLE
::uint8_t* PROTOBUF_NONNULL ConvergenceInformation::_InternalSerialize(
    ::uint8_t* PROTOBUF_NONNULL target,
    ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const {
  const ConvergenceInformation& this_ = *this;
#endif  // PROTOBUF_CUSTOM_VTABLE
  if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) {
    this_.CheckHasBitConsistency();
  }
  // @@protoc_insertion_point(serialize_to_array_start:operations_research.pdlp.ConvergenceInformation)
  ::uint32_t cached_has_bits = 0;
  (void)cached_has_bits;
 
  cached_has_bits = this_._impl_._has_bits_[0];
  // optional .operations_research.pdlp.PointType candidate_type = 1;
  if (CheckHasBit(cached_has_bits, 0x00002000U)) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteEnumToArray(
        1, this_._internal_candidate_type(), target);
  }
 
  // optional double primal_objective = 2;
  if (CheckHasBit(cached_has_bits, 0x00000001U)) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteDoubleToArray(
        2, this_._internal_primal_objective(), target);
  }
 
  // optional double dual_objective = 3;
  if (CheckHasBit(cached_has_bits, 0x00000002U)) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteDoubleToArray(
        3, this_._internal_dual_objective(), target);
  }
 
  // optional double corrected_dual_objective = 4;
  if (CheckHasBit(cached_has_bits, 0x00000004U)) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteDoubleToArray(
        4, this_._internal_corrected_dual_objective(), target);
  }
 
  // optional double l_inf_primal_residual = 5;
  if (CheckHasBit(cached_has_bits, 0x00000008U)) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteDoubleToArray(
        5, this_._internal_l_inf_primal_residual(), target);
  }
 
  // optional double l2_primal_residual = 6;
  if (CheckHasBit(cached_has_bits, 0x00000010U)) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteDoubleToArray(
        6, this_._internal_l2_primal_residual(), target);
  }
 
  // optional double l_inf_dual_residual = 7;
  if (CheckHasBit(cached_has_bits, 0x00000020U)) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteDoubleToArray(
        7, this_._internal_l_inf_dual_residual(), target);
  }
 
  // optional double l2_dual_residual = 8;
  if (CheckHasBit(cached_has_bits, 0x00000040U)) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteDoubleToArray(
        8, this_._internal_l2_dual_residual(), target);
  }
 
  // optional double l_inf_primal_variable = 14;
  if (CheckHasBit(cached_has_bits, 0x00000080U)) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteDoubleToArray(
        14, this_._internal_l_inf_primal_variable(), target);
  }
 
  // optional double l2_primal_variable = 15;
  if (CheckHasBit(cached_has_bits, 0x00000100U)) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteDoubleToArray(
        15, this_._internal_l2_primal_variable(), target);
  }
 
  // optional double l_inf_dual_variable = 16;
  if (CheckHasBit(cached_has_bits, 0x00000200U)) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteDoubleToArray(
        16, this_._internal_l_inf_dual_variable(), target);
  }
 
  // optional double l2_dual_variable = 17;
  if (CheckHasBit(cached_has_bits, 0x00000400U)) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteDoubleToArray(
        17, this_._internal_l2_dual_variable(), target);
  }
 
  // optional double l_inf_componentwise_primal_residual = 24;
  if (CheckHasBit(cached_has_bits, 0x00000800U)) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteDoubleToArray(
        24, this_._internal_l_inf_componentwise_primal_residual(), target);
  }
 
  // optional double l_inf_componentwise_dual_residual = 25;
  if (CheckHasBit(cached_has_bits, 0x00001000U)) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteDoubleToArray(
        25, this_._internal_l_inf_componentwise_dual_residual(), target);
  }
 
  if (ABSL_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) {
    target =
        ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray(
            this_._internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:operations_research.pdlp.ConvergenceInformation)
  return target;
}
 
#if defined(PROTOBUF_CUSTOM_VTABLE)
::size_t ConvergenceInformation::ByteSizeLong(const MessageLite& base) {
  const ConvergenceInformation& this_ = static_cast<const ConvergenceInformation&>(base);
#else   // PROTOBUF_CUSTOM_VTABLE
::size_t ConvergenceInformation::ByteSizeLong() const {
  const ConvergenceInformation& this_ = *this;
#endif  // PROTOBUF_CUSTOM_VTABLE
  // @@protoc_insertion_point(message_byte_size_start:operations_research.pdlp.ConvergenceInformation)
  ::size_t total_size = 0;
 
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void)cached_has_bits;
 
  ::_pbi::Prefetch5LinesFrom7Lines(&this_);
  cached_has_bits = this_._impl_._has_bits_[0];
  total_size += ::absl::popcount(0x00001e00U & cached_has_bits) * 10;
  total_size += ::absl::popcount(0x000001ffU & cached_has_bits) * 9;
   {
    // optional .operations_research.pdlp.PointType candidate_type = 1;
    if (CheckHasBit(cached_has_bits, 0x00002000U)) {
      total_size += 1 +
                    ::_pbi::WireFormatLite::EnumSize(this_._internal_candidate_type());
    }
  }
  return this_.MaybeComputeUnknownFieldsSize(total_size,
                                             &this_._impl_._cached_size_);
}
 
void ConvergenceInformation::MergeImpl(::google::protobuf::MessageLite& to_msg,
                            const ::google::protobuf::MessageLite& from_msg) {
   auto* const _this =
      static_cast<ConvergenceInformation*>(&to_msg);
  auto& from = static_cast<const ConvergenceInformation&>(from_msg);
  if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) {
    from.CheckHasBitConsistency();
  }
  // @@protoc_insertion_point(class_specific_merge_from_start:operations_research.pdlp.ConvergenceInformation)
  ABSL_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void)cached_has_bits;
 
  cached_has_bits = from._impl_._has_bits_[0];
  if (BatchCheckHasBit(cached_has_bits, 0x000000ffU)) {
    if (CheckHasBit(cached_has_bits, 0x00000001U)) {
      _this->_impl_.primal_objective_ = from._impl_.primal_objective_;
    }
    if (CheckHasBit(cached_has_bits, 0x00000002U)) {
      _this->_impl_.dual_objective_ = from._impl_.dual_objective_;
    }
    if (CheckHasBit(cached_has_bits, 0x00000004U)) {
      _this->_impl_.corrected_dual_objective_ = from._impl_.corrected_dual_objective_;
    }
    if (CheckHasBit(cached_has_bits, 0x00000008U)) {
      _this->_impl_.l_inf_primal_residual_ = from._impl_.l_inf_primal_residual_;
    }
    if (CheckHasBit(cached_has_bits, 0x00000010U)) {
      _this->_impl_.l2_primal_residual_ = from._impl_.l2_primal_residual_;
    }
    if (CheckHasBit(cached_has_bits, 0x00000020U)) {
      _this->_impl_.l_inf_dual_residual_ = from._impl_.l_inf_dual_residual_;
    }
    if (CheckHasBit(cached_has_bits, 0x00000040U)) {
      _this->_impl_.l2_dual_residual_ = from._impl_.l2_dual_residual_;
    }
    if (CheckHasBit(cached_has_bits, 0x00000080U)) {
      _this->_impl_.l_inf_primal_variable_ = from._impl_.l_inf_primal_variable_;
    }
  }
  if (BatchCheckHasBit(cached_has_bits, 0x00003f00U)) {
    if (CheckHasBit(cached_has_bits, 0x00000100U)) {
      _this->_impl_.l2_primal_variable_ = from._impl_.l2_primal_variable_;
    }
    if (CheckHasBit(cached_has_bits, 0x00000200U)) {
      _this->_impl_.l_inf_dual_variable_ = from._impl_.l_inf_dual_variable_;
    }
    if (CheckHasBit(cached_has_bits, 0x00000400U)) {
      _this->_impl_.l2_dual_variable_ = from._impl_.l2_dual_variable_;
    }
    if (CheckHasBit(cached_has_bits, 0x00000800U)) {
      _this->_impl_.l_inf_componentwise_primal_residual_ = from._impl_.l_inf_componentwise_primal_residual_;
    }
    if (CheckHasBit(cached_has_bits, 0x00001000U)) {
      _this->_impl_.l_inf_componentwise_dual_residual_ = from._impl_.l_inf_componentwise_dual_residual_;
    }
    if (CheckHasBit(cached_has_bits, 0x00002000U)) {
      _this->_impl_.candidate_type_ = from._impl_.candidate_type_;
    }
  }
  _this->_impl_._has_bits_[0] |= cached_has_bits;
  _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(
      from._internal_metadata_);
}
 
void ConvergenceInformation::CopyFrom(const ConvergenceInformation& from) {
  // @@protoc_insertion_point(class_specific_copy_from_start:operations_research.pdlp.ConvergenceInformation)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}
 
 
void ConvergenceInformation::InternalSwap(ConvergenceInformation* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) {
  using ::std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
  ::google::protobuf::internal::memswap<
      PROTOBUF_FIELD_OFFSET(ConvergenceInformation, _impl_.candidate_type_)
      + sizeof(ConvergenceInformation::_impl_.candidate_type_)
      - PROTOBUF_FIELD_OFFSET(ConvergenceInformation, _impl_.primal_objective_)>(
          reinterpret_cast<char*>(&_impl_.primal_objective_),
          reinterpret_cast<char*>(&other->_impl_.primal_objective_));
}
 
::google::protobuf::Metadata ConvergenceInformation::GetMetadata() const {
  return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full());
}
// ===================================================================
 
class InfeasibilityInformation::_Internal {
 public:
  using HasBits =
      decltype(::std::declval<InfeasibilityInformation>()._impl_._has_bits_);
  static constexpr ::int32_t kHasBitsOffset =
      8 * PROTOBUF_FIELD_OFFSET(InfeasibilityInformation, _impl_._has_bits_);
};
 
InfeasibilityInformation::InfeasibilityInformation(::google::protobuf::Arena* PROTOBUF_NULLABLE arena)
#if defined(PROTOBUF_CUSTOM_VTABLE)
    : ::google::protobuf::Message(arena, InfeasibilityInformation_class_data_.base()) {
#else   // PROTOBUF_CUSTOM_VTABLE
    : ::google::protobuf::Message(arena) {
#endif  // PROTOBUF_CUSTOM_VTABLE
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:operations_research.pdlp.InfeasibilityInformation)
}
InfeasibilityInformation::InfeasibilityInformation(
    ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const InfeasibilityInformation& from)
#if defined(PROTOBUF_CUSTOM_VTABLE)
    : ::google::protobuf::Message(arena, InfeasibilityInformation_class_data_.base()),
#else   // PROTOBUF_CUSTOM_VTABLE
    : ::google::protobuf::Message(arena),
#endif  // PROTOBUF_CUSTOM_VTABLE
      _impl_(from._impl_) {
  _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(
      from._internal_metadata_);
}
PROTOBUF_NDEBUG_INLINE InfeasibilityInformation::Impl_::Impl_(
    [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility,
    [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena)
      : _cached_size_{0} {}
 
inline void InfeasibilityInformation::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) {
  new (&_impl_) Impl_(internal_visibility(), arena);
  ::memset(reinterpret_cast<char*>(&_impl_) +
               offsetof(Impl_, max_primal_ray_infeasibility_),
           0,
           offsetof(Impl_, candidate_type_) -
               offsetof(Impl_, max_primal_ray_infeasibility_) +
               sizeof(Impl_::candidate_type_));
}
InfeasibilityInformation::~InfeasibilityInformation() {
  // @@protoc_insertion_point(destructor:operations_research.pdlp.InfeasibilityInformation)
  SharedDtor(*this);
}
inline void InfeasibilityInformation::SharedDtor(MessageLite& self) {
  InfeasibilityInformation& this_ = static_cast<InfeasibilityInformation&>(self);
  if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) {
    this_.CheckHasBitConsistency();
  }
  this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>();
  ABSL_DCHECK(this_.GetArena() == nullptr);
  this_._impl_.~Impl_();
}
 
inline void* PROTOBUF_NONNULL InfeasibilityInformation::PlacementNew_(
    const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem,
    ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) {
  return ::new (mem) InfeasibilityInformation(arena);
}
constexpr auto InfeasibilityInformation::InternalNewImpl_() {
  return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(InfeasibilityInformation),
                                            alignof(InfeasibilityInformation));
}
constexpr auto InfeasibilityInformation::InternalGenerateClassData_() {
  return ::google::protobuf::internal::ClassDataFull{
      ::google::protobuf::internal::ClassData{
          &_InfeasibilityInformation_default_instance_._instance,
          &_table_.header,
          nullptr,  // OnDemandRegisterArenaDtor
          nullptr,  // IsInitialized
          &InfeasibilityInformation::MergeImpl,
          ::google::protobuf::Message::GetNewImpl<InfeasibilityInformation>(),
#if defined(PROTOBUF_CUSTOM_VTABLE)
          &InfeasibilityInformation::SharedDtor,
          ::google::protobuf::Message::GetClearImpl<InfeasibilityInformation>(), &InfeasibilityInformation::ByteSizeLong,
              &InfeasibilityInformation::_InternalSerialize,
#endif  // PROTOBUF_CUSTOM_VTABLE
          PROTOBUF_FIELD_OFFSET(InfeasibilityInformation, _impl_._cached_size_),
          false,
      },
      &InfeasibilityInformation::kDescriptorMethods,
      &descriptor_table_ortools_2fpdlp_2fsolve_5flog_2eproto,
      nullptr,  // tracker
  };
}
 
PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const
    ::google::protobuf::internal::ClassDataFull InfeasibilityInformation_class_data_ =
        InfeasibilityInformation::InternalGenerateClassData_();
 
PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL
InfeasibilityInformation::GetClassData() const {
  ::google::protobuf::internal::PrefetchToLocalCache(&InfeasibilityInformation_class_data_);
  ::google::protobuf::internal::PrefetchToLocalCache(InfeasibilityInformation_class_data_.tc_table);
  return InfeasibilityInformation_class_data_.base();
}
PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1
const ::_pbi::TcParseTable<3, 6, 1, 0, 2>
InfeasibilityInformation::_table_ = {
  {
    PROTOBUF_FIELD_OFFSET(InfeasibilityInformation, _impl_._has_bits_),
    0, // no _extensions_
    6, 56,  // max_field_number, fast_idx_mask
    offsetof(decltype(_table_), field_lookup_table),
    4294967232,  // skipmap
    offsetof(decltype(_table_), field_entries),
    6,  // num_field_entries
    1,  // num_aux_entries
    offsetof(decltype(_table_), aux_entries),
    InfeasibilityInformation_class_data_.base(),
    nullptr,  // post_loop_handler
    ::_pbi::TcParser::GenericFallback,  // fallback
    #ifdef PROTOBUF_PREFETCH_PARSE_TABLE
    ::_pbi::TcParser::GetTable<::operations_research::pdlp::InfeasibilityInformation>(),  // to_prefetch
    #endif  // PROTOBUF_PREFETCH_PARSE_TABLE
  }, {{
    {::_pbi::TcParser::MiniParse, {}},
    // optional double max_primal_ray_infeasibility = 1;
    {::_pbi::TcParser::FastF64S1,
     {9, 0, 0,
      PROTOBUF_FIELD_OFFSET(InfeasibilityInformation, _impl_.max_primal_ray_infeasibility_)}},
    // optional double primal_ray_linear_objective = 2;
    {::_pbi::TcParser::FastF64S1,
     {17, 1, 0,
      PROTOBUF_FIELD_OFFSET(InfeasibilityInformation, _impl_.primal_ray_linear_objective_)}},
    // optional double primal_ray_quadratic_norm = 3;
    {::_pbi::TcParser::FastF64S1,
     {25, 2, 0,
      PROTOBUF_FIELD_OFFSET(InfeasibilityInformation, _impl_.primal_ray_quadratic_norm_)}},
    // optional double max_dual_ray_infeasibility = 4;
    {::_pbi::TcParser::FastF64S1,
     {33, 3, 0,
      PROTOBUF_FIELD_OFFSET(InfeasibilityInformation, _impl_.max_dual_ray_infeasibility_)}},
    // optional double dual_ray_objective = 5;
    {::_pbi::TcParser::FastF64S1,
     {41, 4, 0,
      PROTOBUF_FIELD_OFFSET(InfeasibilityInformation, _impl_.dual_ray_objective_)}},
    // optional .operations_research.pdlp.PointType candidate_type = 6;
    {::_pbi::TcParser::FastEr0S1,
     {48, 5, 6,
      PROTOBUF_FIELD_OFFSET(InfeasibilityInformation, _impl_.candidate_type_)}},
    {::_pbi::TcParser::MiniParse, {}},
  }}, {{
    65535, 65535
  }}, {{
    // optional double max_primal_ray_infeasibility = 1;
    {PROTOBUF_FIELD_OFFSET(InfeasibilityInformation, _impl_.max_primal_ray_infeasibility_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kDouble)},
    // optional double primal_ray_linear_objective = 2;
    {PROTOBUF_FIELD_OFFSET(InfeasibilityInformation, _impl_.primal_ray_linear_objective_), _Internal::kHasBitsOffset + 1, 0, (0 | ::_fl::kFcOptional | ::_fl::kDouble)},
    // optional double primal_ray_quadratic_norm = 3;
    {PROTOBUF_FIELD_OFFSET(InfeasibilityInformation, _impl_.primal_ray_quadratic_norm_), _Internal::kHasBitsOffset + 2, 0, (0 | ::_fl::kFcOptional | ::_fl::kDouble)},
    // optional double max_dual_ray_infeasibility = 4;
    {PROTOBUF_FIELD_OFFSET(InfeasibilityInformation, _impl_.max_dual_ray_infeasibility_), _Internal::kHasBitsOffset + 3, 0, (0 | ::_fl::kFcOptional | ::_fl::kDouble)},
    // optional double dual_ray_objective = 5;
    {PROTOBUF_FIELD_OFFSET(InfeasibilityInformation, _impl_.dual_ray_objective_), _Internal::kHasBitsOffset + 4, 0, (0 | ::_fl::kFcOptional | ::_fl::kDouble)},
    // optional .operations_research.pdlp.PointType candidate_type = 6;
    {PROTOBUF_FIELD_OFFSET(InfeasibilityInformation, _impl_.candidate_type_), _Internal::kHasBitsOffset + 5, 0, (0 | ::_fl::kFcOptional | ::_fl::kEnumRange)},
  }},
  {{
      {0, 6},
  }},
  {{
  }},
};
PROTOBUF_NOINLINE void InfeasibilityInformation::Clear() {
// @@protoc_insertion_point(message_clear_start:operations_research.pdlp.InfeasibilityInformation)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;
 
  cached_has_bits = _impl_._has_bits_[0];
  if (BatchCheckHasBit(cached_has_bits, 0x0000003fU)) {
    ::memset(&_impl_.max_primal_ray_infeasibility_, 0, static_cast<::size_t>(
        reinterpret_cast<char*>(&_impl_.candidate_type_) -
        reinterpret_cast<char*>(&_impl_.max_primal_ray_infeasibility_)) + sizeof(_impl_.candidate_type_));
  }
  _impl_._has_bits_.Clear();
  _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>();
}
 
#if defined(PROTOBUF_CUSTOM_VTABLE)
::uint8_t* PROTOBUF_NONNULL InfeasibilityInformation::_InternalSerialize(
    const ::google::protobuf::MessageLite& base, ::uint8_t* PROTOBUF_NONNULL target,
    ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) {
  const InfeasibilityInformation& this_ = static_cast<const InfeasibilityInformation&>(base);
#else   // PROTOBUF_CUSTOM_VTABLE
::uint8_t* PROTOBUF_NONNULL InfeasibilityInformation::_InternalSerialize(
    ::uint8_t* PROTOBUF_NONNULL target,
    ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const {
  const InfeasibilityInformation& this_ = *this;
#endif  // PROTOBUF_CUSTOM_VTABLE
  if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) {
    this_.CheckHasBitConsistency();
  }
  // @@protoc_insertion_point(serialize_to_array_start:operations_research.pdlp.InfeasibilityInformation)
  ::uint32_t cached_has_bits = 0;
  (void)cached_has_bits;
 
  cached_has_bits = this_._impl_._has_bits_[0];
  // optional double max_primal_ray_infeasibility = 1;
  if (CheckHasBit(cached_has_bits, 0x00000001U)) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteDoubleToArray(
        1, this_._internal_max_primal_ray_infeasibility(), target);
  }
 
  // optional double primal_ray_linear_objective = 2;
  if (CheckHasBit(cached_has_bits, 0x00000002U)) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteDoubleToArray(
        2, this_._internal_primal_ray_linear_objective(), target);
  }
 
  // optional double primal_ray_quadratic_norm = 3;
  if (CheckHasBit(cached_has_bits, 0x00000004U)) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteDoubleToArray(
        3, this_._internal_primal_ray_quadratic_norm(), target);
  }
 
  // optional double max_dual_ray_infeasibility = 4;
  if (CheckHasBit(cached_has_bits, 0x00000008U)) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteDoubleToArray(
        4, this_._internal_max_dual_ray_infeasibility(), target);
  }
 
  // optional double dual_ray_objective = 5;
  if (CheckHasBit(cached_has_bits, 0x00000010U)) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteDoubleToArray(
        5, this_._internal_dual_ray_objective(), target);
  }
 
  // optional .operations_research.pdlp.PointType candidate_type = 6;
  if (CheckHasBit(cached_has_bits, 0x00000020U)) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteEnumToArray(
        6, this_._internal_candidate_type(), target);
  }
 
  if (ABSL_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) {
    target =
        ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray(
            this_._internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:operations_research.pdlp.InfeasibilityInformation)
  return target;
}
 
#if defined(PROTOBUF_CUSTOM_VTABLE)
::size_t InfeasibilityInformation::ByteSizeLong(const MessageLite& base) {
  const InfeasibilityInformation& this_ = static_cast<const InfeasibilityInformation&>(base);
#else   // PROTOBUF_CUSTOM_VTABLE
::size_t InfeasibilityInformation::ByteSizeLong() const {
  const InfeasibilityInformation& this_ = *this;
#endif  // PROTOBUF_CUSTOM_VTABLE
  // @@protoc_insertion_point(message_byte_size_start:operations_research.pdlp.InfeasibilityInformation)
  ::size_t total_size = 0;
 
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void)cached_has_bits;
 
  ::_pbi::Prefetch5LinesFrom7Lines(&this_);
  cached_has_bits = this_._impl_._has_bits_[0];
  total_size += ::absl::popcount(0x0000001fU & cached_has_bits) * 9;
   {
    // optional .operations_research.pdlp.PointType candidate_type = 6;
    if (CheckHasBit(cached_has_bits, 0x00000020U)) {
      total_size += 1 +
                    ::_pbi::WireFormatLite::EnumSize(this_._internal_candidate_type());
    }
  }
  return this_.MaybeComputeUnknownFieldsSize(total_size,
                                             &this_._impl_._cached_size_);
}
 
void InfeasibilityInformation::MergeImpl(::google::protobuf::MessageLite& to_msg,
                            const ::google::protobuf::MessageLite& from_msg) {
   auto* const _this =
      static_cast<InfeasibilityInformation*>(&to_msg);
  auto& from = static_cast<const InfeasibilityInformation&>(from_msg);
  if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) {
    from.CheckHasBitConsistency();
  }
  // @@protoc_insertion_point(class_specific_merge_from_start:operations_research.pdlp.InfeasibilityInformation)
  ABSL_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void)cached_has_bits;
 
  cached_has_bits = from._impl_._has_bits_[0];
  if (BatchCheckHasBit(cached_has_bits, 0x0000003fU)) {
    if (CheckHasBit(cached_has_bits, 0x00000001U)) {
      _this->_impl_.max_primal_ray_infeasibility_ = from._impl_.max_primal_ray_infeasibility_;
    }
    if (CheckHasBit(cached_has_bits, 0x00000002U)) {
      _this->_impl_.primal_ray_linear_objective_ = from._impl_.primal_ray_linear_objective_;
    }
    if (CheckHasBit(cached_has_bits, 0x00000004U)) {
      _this->_impl_.primal_ray_quadratic_norm_ = from._impl_.primal_ray_quadratic_norm_;
    }
    if (CheckHasBit(cached_has_bits, 0x00000008U)) {
      _this->_impl_.max_dual_ray_infeasibility_ = from._impl_.max_dual_ray_infeasibility_;
    }
    if (CheckHasBit(cached_has_bits, 0x00000010U)) {
      _this->_impl_.dual_ray_objective_ = from._impl_.dual_ray_objective_;
    }
    if (CheckHasBit(cached_has_bits, 0x00000020U)) {
      _this->_impl_.candidate_type_ = from._impl_.candidate_type_;
    }
  }
  _this->_impl_._has_bits_[0] |= cached_has_bits;
  _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(
      from._internal_metadata_);
}
 
void InfeasibilityInformation::CopyFrom(const InfeasibilityInformation& from) {
  // @@protoc_insertion_point(class_specific_copy_from_start:operations_research.pdlp.InfeasibilityInformation)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}
 
 
void InfeasibilityInformation::InternalSwap(InfeasibilityInformation* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) {
  using ::std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
  ::google::protobuf::internal::memswap<
      PROTOBUF_FIELD_OFFSET(InfeasibilityInformation, _impl_.candidate_type_)
      + sizeof(InfeasibilityInformation::_impl_.candidate_type_)
      - PROTOBUF_FIELD_OFFSET(InfeasibilityInformation, _impl_.max_primal_ray_infeasibility_)>(
          reinterpret_cast<char*>(&_impl_.max_primal_ray_infeasibility_),
          reinterpret_cast<char*>(&other->_impl_.max_primal_ray_infeasibility_));
}
 
::google::protobuf::Metadata InfeasibilityInformation::GetMetadata() const {
  return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full());
}
// ===================================================================
 
class PointMetadata::_Internal {
 public:
  using HasBits =
      decltype(::std::declval<PointMetadata>()._impl_._has_bits_);
  static constexpr ::int32_t kHasBitsOffset =
      8 * PROTOBUF_FIELD_OFFSET(PointMetadata, _impl_._has_bits_);
};
 
PointMetadata::PointMetadata(::google::protobuf::Arena* PROTOBUF_NULLABLE arena)
#if defined(PROTOBUF_CUSTOM_VTABLE)
    : ::google::protobuf::Message(arena, PointMetadata_class_data_.base()) {
#else   // PROTOBUF_CUSTOM_VTABLE
    : ::google::protobuf::Message(arena) {
#endif  // PROTOBUF_CUSTOM_VTABLE
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:operations_research.pdlp.PointMetadata)
}
PROTOBUF_NDEBUG_INLINE PointMetadata::Impl_::Impl_(
    [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility,
    [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from,
    [[maybe_unused]] const ::operations_research::pdlp::PointMetadata& from_msg)
      : _has_bits_{from._has_bits_},
        _cached_size_{0},
        random_primal_projections_{visibility, arena, from.random_primal_projections_},
        random_dual_projections_{visibility, arena, from.random_dual_projections_} {}
 
PointMetadata::PointMetadata(
    ::google::protobuf::Arena* PROTOBUF_NULLABLE arena,
    const PointMetadata& from)
#if defined(PROTOBUF_CUSTOM_VTABLE)
    : ::google::protobuf::Message(arena, PointMetadata_class_data_.base()) {
#else   // PROTOBUF_CUSTOM_VTABLE
    : ::google::protobuf::Message(arena) {
#endif  // PROTOBUF_CUSTOM_VTABLE
  PointMetadata* const _this = this;
  (void)_this;
  _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(
      from._internal_metadata_);
  new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from);
  ::memcpy(reinterpret_cast<char*>(&_impl_) +
               offsetof(Impl_, active_primal_variable_count_),
           reinterpret_cast<const char*>(&from._impl_) +
               offsetof(Impl_, active_primal_variable_count_),
           offsetof(Impl_, point_type_) -
               offsetof(Impl_, active_primal_variable_count_) +
               sizeof(Impl_::point_type_));
 
  // @@protoc_insertion_point(copy_constructor:operations_research.pdlp.PointMetadata)
}
PROTOBUF_NDEBUG_INLINE PointMetadata::Impl_::Impl_(
    [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility,
    [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena)
      : _cached_size_{0},
        random_primal_projections_{visibility, arena},
        random_dual_projections_{visibility, arena} {}
 
inline void PointMetadata::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) {
  new (&_impl_) Impl_(internal_visibility(), arena);
  ::memset(reinterpret_cast<char*>(&_impl_) +
               offsetof(Impl_, active_primal_variable_count_),
           0,
           offsetof(Impl_, point_type_) -
               offsetof(Impl_, active_primal_variable_count_) +
               sizeof(Impl_::point_type_));
}
PointMetadata::~PointMetadata() {
  // @@protoc_insertion_point(destructor:operations_research.pdlp.PointMetadata)
  SharedDtor(*this);
}
inline void PointMetadata::SharedDtor(MessageLite& self) {
  PointMetadata& this_ = static_cast<PointMetadata&>(self);
  if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) {
    this_.CheckHasBitConsistency();
  }
  this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>();
  ABSL_DCHECK(this_.GetArena() == nullptr);
  this_._impl_.~Impl_();
}
 
inline void* PROTOBUF_NONNULL PointMetadata::PlacementNew_(
    const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem,
    ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) {
  return ::new (mem) PointMetadata(arena);
}
constexpr auto PointMetadata::InternalNewImpl_() {
  constexpr auto arena_bits = ::google::protobuf::internal::EncodePlacementArenaOffsets({
      PROTOBUF_FIELD_OFFSET(PointMetadata, _impl_.random_primal_projections_) +
          decltype(PointMetadata::_impl_.random_primal_projections_)::
              InternalGetArenaOffset(
                  ::google::protobuf::Message::internal_visibility()),
      PROTOBUF_FIELD_OFFSET(PointMetadata, _impl_.random_dual_projections_) +
          decltype(PointMetadata::_impl_.random_dual_projections_)::
              InternalGetArenaOffset(
                  ::google::protobuf::Message::internal_visibility()),
  });
  if (arena_bits.has_value()) {
    return ::google::protobuf::internal::MessageCreator::ZeroInit(
        sizeof(PointMetadata), alignof(PointMetadata), *arena_bits);
  } else {
    return ::google::protobuf::internal::MessageCreator(&PointMetadata::PlacementNew_,
                                 sizeof(PointMetadata),
                                 alignof(PointMetadata));
  }
}
constexpr auto PointMetadata::InternalGenerateClassData_() {
  return ::google::protobuf::internal::ClassDataFull{
      ::google::protobuf::internal::ClassData{
          &_PointMetadata_default_instance_._instance,
          &_table_.header,
          nullptr,  // OnDemandRegisterArenaDtor
          nullptr,  // IsInitialized
          &PointMetadata::MergeImpl,
          ::google::protobuf::Message::GetNewImpl<PointMetadata>(),
#if defined(PROTOBUF_CUSTOM_VTABLE)
          &PointMetadata::SharedDtor,
          ::google::protobuf::Message::GetClearImpl<PointMetadata>(), &PointMetadata::ByteSizeLong,
              &PointMetadata::_InternalSerialize,
#endif  // PROTOBUF_CUSTOM_VTABLE
          PROTOBUF_FIELD_OFFSET(PointMetadata, _impl_._cached_size_),
          false,
      },
      &PointMetadata::kDescriptorMethods,
      &descriptor_table_ortools_2fpdlp_2fsolve_5flog_2eproto,
      nullptr,  // tracker
  };
}
 
PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const
    ::google::protobuf::internal::ClassDataFull PointMetadata_class_data_ =
        PointMetadata::InternalGenerateClassData_();
 
PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL
PointMetadata::GetClassData() const {
  ::google::protobuf::internal::PrefetchToLocalCache(&PointMetadata_class_data_);
  ::google::protobuf::internal::PrefetchToLocalCache(PointMetadata_class_data_.tc_table);
  return PointMetadata_class_data_.base();
}
PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1
const ::_pbi::TcParseTable<3, 7, 1, 0, 2>
PointMetadata::_table_ = {
  {
    PROTOBUF_FIELD_OFFSET(PointMetadata, _impl_._has_bits_),
    0, // no _extensions_
    7, 56,  // max_field_number, fast_idx_mask
    offsetof(decltype(_table_), field_lookup_table),
    4294967168,  // skipmap
    offsetof(decltype(_table_), field_entries),
    7,  // num_field_entries
    1,  // num_aux_entries
    offsetof(decltype(_table_), aux_entries),
    PointMetadata_class_data_.base(),
    nullptr,  // post_loop_handler
    ::_pbi::TcParser::GenericFallback,  // fallback
    #ifdef PROTOBUF_PREFETCH_PARSE_TABLE
    ::_pbi::TcParser::GetTable<::operations_research::pdlp::PointMetadata>(),  // to_prefetch
    #endif  // PROTOBUF_PREFETCH_PARSE_TABLE
  }, {{
    {::_pbi::TcParser::MiniParse, {}},
    // optional .operations_research.pdlp.PointType point_type = 1;
    {::_pbi::TcParser::FastEr0S1,
     {8, 6, 6,
      PROTOBUF_FIELD_OFFSET(PointMetadata, _impl_.point_type_)}},
    // repeated double random_primal_projections = 2 [packed = true];
    {::_pbi::TcParser::FastF64P1,
     {18, 0, 0,
      PROTOBUF_FIELD_OFFSET(PointMetadata, _impl_.random_primal_projections_)}},
    // repeated double random_dual_projections = 3 [packed = true];
    {::_pbi::TcParser::FastF64P1,
     {26, 1, 0,
      PROTOBUF_FIELD_OFFSET(PointMetadata, _impl_.random_dual_projections_)}},
    // optional int64 active_primal_variable_count = 4;
    {::_pbi::TcParser::SingularVarintNoZag1<::uint64_t, offsetof(PointMetadata, _impl_.active_primal_variable_count_), 2>(),
     {32, 2, 0,
      PROTOBUF_FIELD_OFFSET(PointMetadata, _impl_.active_primal_variable_count_)}},
    // optional int64 active_dual_variable_count = 5;
    {::_pbi::TcParser::SingularVarintNoZag1<::uint64_t, offsetof(PointMetadata, _impl_.active_dual_variable_count_), 3>(),
     {40, 3, 0,
      PROTOBUF_FIELD_OFFSET(PointMetadata, _impl_.active_dual_variable_count_)}},
    // optional int64 active_primal_variable_change = 6;
    {::_pbi::TcParser::SingularVarintNoZag1<::uint64_t, offsetof(PointMetadata, _impl_.active_primal_variable_change_), 4>(),
     {48, 4, 0,
      PROTOBUF_FIELD_OFFSET(PointMetadata, _impl_.active_primal_variable_change_)}},
    // optional int64 active_dual_variable_change = 7;
    {::_pbi::TcParser::SingularVarintNoZag1<::uint64_t, offsetof(PointMetadata, _impl_.active_dual_variable_change_), 5>(),
     {56, 5, 0,
      PROTOBUF_FIELD_OFFSET(PointMetadata, _impl_.active_dual_variable_change_)}},
  }}, {{
    65535, 65535
  }}, {{
    // optional .operations_research.pdlp.PointType point_type = 1;
    {PROTOBUF_FIELD_OFFSET(PointMetadata, _impl_.point_type_), _Internal::kHasBitsOffset + 6, 0, (0 | ::_fl::kFcOptional | ::_fl::kEnumRange)},
    // repeated double random_primal_projections = 2 [packed = true];
    {PROTOBUF_FIELD_OFFSET(PointMetadata, _impl_.random_primal_projections_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcRepeated | ::_fl::kPackedDouble)},
    // repeated double random_dual_projections = 3 [packed = true];
    {PROTOBUF_FIELD_OFFSET(PointMetadata, _impl_.random_dual_projections_), _Internal::kHasBitsOffset + 1, 0, (0 | ::_fl::kFcRepeated | ::_fl::kPackedDouble)},
    // optional int64 active_primal_variable_count = 4;
    {PROTOBUF_FIELD_OFFSET(PointMetadata, _impl_.active_primal_variable_count_), _Internal::kHasBitsOffset + 2, 0, (0 | ::_fl::kFcOptional | ::_fl::kInt64)},
    // optional int64 active_dual_variable_count = 5;
    {PROTOBUF_FIELD_OFFSET(PointMetadata, _impl_.active_dual_variable_count_), _Internal::kHasBitsOffset + 3, 0, (0 | ::_fl::kFcOptional | ::_fl::kInt64)},
    // optional int64 active_primal_variable_change = 6;
    {PROTOBUF_FIELD_OFFSET(PointMetadata, _impl_.active_primal_variable_change_), _Internal::kHasBitsOffset + 4, 0, (0 | ::_fl::kFcOptional | ::_fl::kInt64)},
    // optional int64 active_dual_variable_change = 7;
    {PROTOBUF_FIELD_OFFSET(PointMetadata, _impl_.active_dual_variable_change_), _Internal::kHasBitsOffset + 5, 0, (0 | ::_fl::kFcOptional | ::_fl::kInt64)},
  }},
  {{
      {0, 6},
  }},
  {{
  }},
};
PROTOBUF_NOINLINE void PointMetadata::Clear() {
// @@protoc_insertion_point(message_clear_start:operations_research.pdlp.PointMetadata)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;
 
  cached_has_bits = _impl_._has_bits_[0];
  if (BatchCheckHasBit(cached_has_bits, 0x00000003U)) {
    if (CheckHasBitForRepeated(cached_has_bits, 0x00000001U)) {
      _impl_.random_primal_projections_.Clear();
    }
    if (CheckHasBitForRepeated(cached_has_bits, 0x00000002U)) {
      _impl_.random_dual_projections_.Clear();
    }
  }
  if (BatchCheckHasBit(cached_has_bits, 0x0000007cU)) {
    ::memset(&_impl_.active_primal_variable_count_, 0, static_cast<::size_t>(
        reinterpret_cast<char*>(&_impl_.point_type_) -
        reinterpret_cast<char*>(&_impl_.active_primal_variable_count_)) + sizeof(_impl_.point_type_));
  }
  _impl_._has_bits_.Clear();
  _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>();
}
 
#if defined(PROTOBUF_CUSTOM_VTABLE)
::uint8_t* PROTOBUF_NONNULL PointMetadata::_InternalSerialize(
    const ::google::protobuf::MessageLite& base, ::uint8_t* PROTOBUF_NONNULL target,
    ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) {
  const PointMetadata& this_ = static_cast<const PointMetadata&>(base);
#else   // PROTOBUF_CUSTOM_VTABLE
::uint8_t* PROTOBUF_NONNULL PointMetadata::_InternalSerialize(
    ::uint8_t* PROTOBUF_NONNULL target,
    ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const {
  const PointMetadata& this_ = *this;
#endif  // PROTOBUF_CUSTOM_VTABLE
  if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) {
    this_.CheckHasBitConsistency();
  }
  // @@protoc_insertion_point(serialize_to_array_start:operations_research.pdlp.PointMetadata)
  ::uint32_t cached_has_bits = 0;
  (void)cached_has_bits;
 
  cached_has_bits = this_._impl_._has_bits_[0];
  // optional .operations_research.pdlp.PointType point_type = 1;
  if (CheckHasBit(cached_has_bits, 0x00000040U)) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteEnumToArray(
        1, this_._internal_point_type(), target);
  }
 
  // repeated double random_primal_projections = 2 [packed = true];
  if (CheckHasBitForRepeated(cached_has_bits, 0x00000001U)) {
    if (this_._internal_random_primal_projections_size() > 0) {
      target = stream->WriteFixedPacked(2, this_._internal_random_primal_projections(), target);
    }
  }
 
  // repeated double random_dual_projections = 3 [packed = true];
  if (CheckHasBitForRepeated(cached_has_bits, 0x00000002U)) {
    if (this_._internal_random_dual_projections_size() > 0) {
      target = stream->WriteFixedPacked(3, this_._internal_random_dual_projections(), target);
    }
  }
 
  // optional int64 active_primal_variable_count = 4;
  if (CheckHasBit(cached_has_bits, 0x00000004U)) {
    target =
        ::google::protobuf::internal::WireFormatLite::WriteInt64ToArrayWithField<4>(
            stream, this_._internal_active_primal_variable_count(), target);
  }
 
  // optional int64 active_dual_variable_count = 5;
  if (CheckHasBit(cached_has_bits, 0x00000008U)) {
    target =
        ::google::protobuf::internal::WireFormatLite::WriteInt64ToArrayWithField<5>(
            stream, this_._internal_active_dual_variable_count(), target);
  }
 
  // optional int64 active_primal_variable_change = 6;
  if (CheckHasBit(cached_has_bits, 0x00000010U)) {
    target =
        ::google::protobuf::internal::WireFormatLite::WriteInt64ToArrayWithField<6>(
            stream, this_._internal_active_primal_variable_change(), target);
  }
 
  // optional int64 active_dual_variable_change = 7;
  if (CheckHasBit(cached_has_bits, 0x00000020U)) {
    target =
        ::google::protobuf::internal::WireFormatLite::WriteInt64ToArrayWithField<7>(
            stream, this_._internal_active_dual_variable_change(), target);
  }
 
  if (ABSL_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) {
    target =
        ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray(
            this_._internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:operations_research.pdlp.PointMetadata)
  return target;
}
 
#if defined(PROTOBUF_CUSTOM_VTABLE)
::size_t PointMetadata::ByteSizeLong(const MessageLite& base) {
  const PointMetadata& this_ = static_cast<const PointMetadata&>(base);
#else   // PROTOBUF_CUSTOM_VTABLE
::size_t PointMetadata::ByteSizeLong() const {
  const PointMetadata& this_ = *this;
#endif  // PROTOBUF_CUSTOM_VTABLE
  // @@protoc_insertion_point(message_byte_size_start:operations_research.pdlp.PointMetadata)
  ::size_t total_size = 0;
 
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void)cached_has_bits;
 
  ::_pbi::Prefetch5LinesFrom7Lines(&this_);
  cached_has_bits = this_._impl_._has_bits_[0];
  if (BatchCheckHasBit(cached_has_bits, 0x0000007fU)) {
    // repeated double random_primal_projections = 2 [packed = true];
    if (CheckHasBitForRepeated(cached_has_bits, 0x00000001U)) {
      ::size_t data_size = ::size_t{8} *
          ::_pbi::FromIntSize(this_._internal_random_primal_projections_size());
      ::size_t tag_size = data_size == 0
          ? 0
          : 1 + ::_pbi::WireFormatLite::Int32Size(
                              static_cast<::int32_t>(data_size));
      total_size += tag_size + data_size;
    }
    // repeated double random_dual_projections = 3 [packed = true];
    if (CheckHasBitForRepeated(cached_has_bits, 0x00000002U)) {
      ::size_t data_size = ::size_t{8} *
          ::_pbi::FromIntSize(this_._internal_random_dual_projections_size());
      ::size_t tag_size = data_size == 0
          ? 0
          : 1 + ::_pbi::WireFormatLite::Int32Size(
                              static_cast<::int32_t>(data_size));
      total_size += tag_size + data_size;
    }
    // optional int64 active_primal_variable_count = 4;
    if (CheckHasBit(cached_has_bits, 0x00000004U)) {
      total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(
          this_._internal_active_primal_variable_count());
    }
    // optional int64 active_dual_variable_count = 5;
    if (CheckHasBit(cached_has_bits, 0x00000008U)) {
      total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(
          this_._internal_active_dual_variable_count());
    }
    // optional int64 active_primal_variable_change = 6;
    if (CheckHasBit(cached_has_bits, 0x00000010U)) {
      total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(
          this_._internal_active_primal_variable_change());
    }
    // optional int64 active_dual_variable_change = 7;
    if (CheckHasBit(cached_has_bits, 0x00000020U)) {
      total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(
          this_._internal_active_dual_variable_change());
    }
    // optional .operations_research.pdlp.PointType point_type = 1;
    if (CheckHasBit(cached_has_bits, 0x00000040U)) {
      total_size += 1 +
                    ::_pbi::WireFormatLite::EnumSize(this_._internal_point_type());
    }
  }
  return this_.MaybeComputeUnknownFieldsSize(total_size,
                                             &this_._impl_._cached_size_);
}
 
void PointMetadata::MergeImpl(::google::protobuf::MessageLite& to_msg,
                            const ::google::protobuf::MessageLite& from_msg) {
   auto* const _this =
      static_cast<PointMetadata*>(&to_msg);
  auto& from = static_cast<const PointMetadata&>(from_msg);
  if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) {
    from.CheckHasBitConsistency();
  }
  // @@protoc_insertion_point(class_specific_merge_from_start:operations_research.pdlp.PointMetadata)
  ABSL_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void)cached_has_bits;
 
  cached_has_bits = from._impl_._has_bits_[0];
  if (BatchCheckHasBit(cached_has_bits, 0x0000007fU)) {
    if (CheckHasBitForRepeated(cached_has_bits, 0x00000001U)) {
      _this->_internal_mutable_random_primal_projections()->MergeFrom(from._internal_random_primal_projections());
    }
    if (CheckHasBitForRepeated(cached_has_bits, 0x00000002U)) {
      _this->_internal_mutable_random_dual_projections()->MergeFrom(from._internal_random_dual_projections());
    }
    if (CheckHasBit(cached_has_bits, 0x00000004U)) {
      _this->_impl_.active_primal_variable_count_ = from._impl_.active_primal_variable_count_;
    }
    if (CheckHasBit(cached_has_bits, 0x00000008U)) {
      _this->_impl_.active_dual_variable_count_ = from._impl_.active_dual_variable_count_;
    }
    if (CheckHasBit(cached_has_bits, 0x00000010U)) {
      _this->_impl_.active_primal_variable_change_ = from._impl_.active_primal_variable_change_;
    }
    if (CheckHasBit(cached_has_bits, 0x00000020U)) {
      _this->_impl_.active_dual_variable_change_ = from._impl_.active_dual_variable_change_;
    }
    if (CheckHasBit(cached_has_bits, 0x00000040U)) {
      _this->_impl_.point_type_ = from._impl_.point_type_;
    }
  }
  _this->_impl_._has_bits_[0] |= cached_has_bits;
  _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(
      from._internal_metadata_);
}
 
void PointMetadata::CopyFrom(const PointMetadata& from) {
  // @@protoc_insertion_point(class_specific_copy_from_start:operations_research.pdlp.PointMetadata)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}
 
 
void PointMetadata::InternalSwap(PointMetadata* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) {
  using ::std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
  _impl_.random_primal_projections_.InternalSwap(&other->_impl_.random_primal_projections_);
  _impl_.random_dual_projections_.InternalSwap(&other->_impl_.random_dual_projections_);
  ::google::protobuf::internal::memswap<
      PROTOBUF_FIELD_OFFSET(PointMetadata, _impl_.point_type_)
      + sizeof(PointMetadata::_impl_.point_type_)
      - PROTOBUF_FIELD_OFFSET(PointMetadata, _impl_.active_primal_variable_count_)>(
          reinterpret_cast<char*>(&_impl_.active_primal_variable_count_),
          reinterpret_cast<char*>(&other->_impl_.active_primal_variable_count_));
}
 
::google::protobuf::Metadata PointMetadata::GetMetadata() const {
  return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full());
}
// ===================================================================
 
class IterationStats::_Internal {
 public:
  using HasBits =
      decltype(::std::declval<IterationStats>()._impl_._has_bits_);
  static constexpr ::int32_t kHasBitsOffset =
      8 * PROTOBUF_FIELD_OFFSET(IterationStats, _impl_._has_bits_);
};
 
IterationStats::IterationStats(::google::protobuf::Arena* PROTOBUF_NULLABLE arena)
#if defined(PROTOBUF_CUSTOM_VTABLE)
    : ::google::protobuf::Message(arena, IterationStats_class_data_.base()) {
#else   // PROTOBUF_CUSTOM_VTABLE
    : ::google::protobuf::Message(arena) {
#endif  // PROTOBUF_CUSTOM_VTABLE
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:operations_research.pdlp.IterationStats)
}
PROTOBUF_NDEBUG_INLINE IterationStats::Impl_::Impl_(
    [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility,
    [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from,
    [[maybe_unused]] const ::operations_research::pdlp::IterationStats& from_msg)
      : _has_bits_{from._has_bits_},
        _cached_size_{0},
        convergence_information_{visibility, arena, from.convergence_information_},
        infeasibility_information_{visibility, arena, from.infeasibility_information_},
        point_metadata_{visibility, arena, from.point_metadata_} {}
 
IterationStats::IterationStats(
    ::google::protobuf::Arena* PROTOBUF_NULLABLE arena,
    const IterationStats& from)
#if defined(PROTOBUF_CUSTOM_VTABLE)
    : ::google::protobuf::Message(arena, IterationStats_class_data_.base()) {
#else   // PROTOBUF_CUSTOM_VTABLE
    : ::google::protobuf::Message(arena) {
#endif  // PROTOBUF_CUSTOM_VTABLE
  IterationStats* const _this = this;
  (void)_this;
  _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(
      from._internal_metadata_);
  new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from);
  ::memcpy(reinterpret_cast<char*>(&_impl_) +
               offsetof(Impl_, iteration_number_),
           reinterpret_cast<const char*>(&from._impl_) +
               offsetof(Impl_, iteration_number_),
           offsetof(Impl_, restart_used_) -
               offsetof(Impl_, iteration_number_) +
               sizeof(Impl_::restart_used_));
 
  // @@protoc_insertion_point(copy_constructor:operations_research.pdlp.IterationStats)
}
PROTOBUF_NDEBUG_INLINE IterationStats::Impl_::Impl_(
    [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility,
    [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena)
      : _cached_size_{0},
        convergence_information_{visibility, arena},
        infeasibility_information_{visibility, arena},
        point_metadata_{visibility, arena} {}
 
inline void IterationStats::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) {
  new (&_impl_) Impl_(internal_visibility(), arena);
  ::memset(reinterpret_cast<char*>(&_impl_) +
               offsetof(Impl_, iteration_number_),
           0,
           offsetof(Impl_, restart_used_) -
               offsetof(Impl_, iteration_number_) +
               sizeof(Impl_::restart_used_));
}
IterationStats::~IterationStats() {
  // @@protoc_insertion_point(destructor:operations_research.pdlp.IterationStats)
  SharedDtor(*this);
}
inline void IterationStats::SharedDtor(MessageLite& self) {
  IterationStats& this_ = static_cast<IterationStats&>(self);
  if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) {
    this_.CheckHasBitConsistency();
  }
  this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>();
  ABSL_DCHECK(this_.GetArena() == nullptr);
  this_._impl_.~Impl_();
}
 
inline void* PROTOBUF_NONNULL IterationStats::PlacementNew_(
    const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem,
    ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) {
  return ::new (mem) IterationStats(arena);
}
constexpr auto IterationStats::InternalNewImpl_() {
  constexpr auto arena_bits = ::google::protobuf::internal::EncodePlacementArenaOffsets({
      PROTOBUF_FIELD_OFFSET(IterationStats, _impl_.convergence_information_) +
          decltype(IterationStats::_impl_.convergence_information_)::
              InternalGetArenaOffset(
                  ::google::protobuf::Message::internal_visibility()),
      PROTOBUF_FIELD_OFFSET(IterationStats, _impl_.infeasibility_information_) +
          decltype(IterationStats::_impl_.infeasibility_information_)::
              InternalGetArenaOffset(
                  ::google::protobuf::Message::internal_visibility()),
      PROTOBUF_FIELD_OFFSET(IterationStats, _impl_.point_metadata_) +
          decltype(IterationStats::_impl_.point_metadata_)::
              InternalGetArenaOffset(
                  ::google::protobuf::Message::internal_visibility()),
  });
  if (arena_bits.has_value()) {
    return ::google::protobuf::internal::MessageCreator::ZeroInit(
        sizeof(IterationStats), alignof(IterationStats), *arena_bits);
  } else {
    return ::google::protobuf::internal::MessageCreator(&IterationStats::PlacementNew_,
                                 sizeof(IterationStats),
                                 alignof(IterationStats));
  }
}
constexpr auto IterationStats::InternalGenerateClassData_() {
  return ::google::protobuf::internal::ClassDataFull{
      ::google::protobuf::internal::ClassData{
          &_IterationStats_default_instance_._instance,
          &_table_.header,
          nullptr,  // OnDemandRegisterArenaDtor
          nullptr,  // IsInitialized
          &IterationStats::MergeImpl,
          ::google::protobuf::Message::GetNewImpl<IterationStats>(),
#if defined(PROTOBUF_CUSTOM_VTABLE)
          &IterationStats::SharedDtor,
          ::google::protobuf::Message::GetClearImpl<IterationStats>(), &IterationStats::ByteSizeLong,
              &IterationStats::_InternalSerialize,
#endif  // PROTOBUF_CUSTOM_VTABLE
          PROTOBUF_FIELD_OFFSET(IterationStats, _impl_._cached_size_),
          false,
      },
      &IterationStats::kDescriptorMethods,
      &descriptor_table_ortools_2fpdlp_2fsolve_5flog_2eproto,
      nullptr,  // tracker
  };
}
 
PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const
    ::google::protobuf::internal::ClassDataFull IterationStats_class_data_ =
        IterationStats::InternalGenerateClassData_();
 
PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL
IterationStats::GetClassData() const {
  ::google::protobuf::internal::PrefetchToLocalCache(&IterationStats_class_data_);
  ::google::protobuf::internal::PrefetchToLocalCache(IterationStats_class_data_.tc_table);
  return IterationStats_class_data_.base();
}
PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1
const ::_pbi::TcParseTable<4, 10, 4, 0, 2>
IterationStats::_table_ = {
  {
    PROTOBUF_FIELD_OFFSET(IterationStats, _impl_._has_bits_),
    0, // no _extensions_
    11, 120,  // max_field_number, fast_idx_mask
    offsetof(decltype(_table_), field_lookup_table),
    4294965760,  // skipmap
    offsetof(decltype(_table_), field_entries),
    10,  // num_field_entries
    4,  // num_aux_entries
    offsetof(decltype(_table_), aux_entries),
    IterationStats_class_data_.base(),
    nullptr,  // post_loop_handler
    ::_pbi::TcParser::GenericFallback,  // fallback
    #ifdef PROTOBUF_PREFETCH_PARSE_TABLE
    ::_pbi::TcParser::GetTable<::operations_research::pdlp::IterationStats>(),  // to_prefetch
    #endif  // PROTOBUF_PREFETCH_PARSE_TABLE
  }, {{
    {::_pbi::TcParser::MiniParse, {}},
    // optional int32 iteration_number = 1;
    {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(IterationStats, _impl_.iteration_number_), 3>(),
     {8, 3, 0,
      PROTOBUF_FIELD_OFFSET(IterationStats, _impl_.iteration_number_)}},
    // repeated .operations_research.pdlp.ConvergenceInformation convergence_information = 2;
    {::_pbi::TcParser::FastMtR1,
     {18, 0, 0,
      PROTOBUF_FIELD_OFFSET(IterationStats, _impl_.convergence_information_)}},
    // repeated .operations_research.pdlp.InfeasibilityInformation infeasibility_information = 3;
    {::_pbi::TcParser::FastMtR1,
     {26, 1, 1,
      PROTOBUF_FIELD_OFFSET(IterationStats, _impl_.infeasibility_information_)}},
    // optional double cumulative_kkt_matrix_passes = 4;
    {::_pbi::TcParser::FastF64S1,
     {33, 5, 0,
      PROTOBUF_FIELD_OFFSET(IterationStats, _impl_.cumulative_kkt_matrix_passes_)}},
    // optional int32 cumulative_rejected_steps = 5;
    {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(IterationStats, _impl_.cumulative_rejected_steps_), 4>(),
     {40, 4, 0,
      PROTOBUF_FIELD_OFFSET(IterationStats, _impl_.cumulative_rejected_steps_)}},
    // optional double cumulative_time_sec = 6;
    {::_pbi::TcParser::FastF64S1,
     {49, 6, 0,
      PROTOBUF_FIELD_OFFSET(IterationStats, _impl_.cumulative_time_sec_)}},
    // optional .operations_research.pdlp.RestartChoice restart_used = 7;
    {::_pbi::TcParser::FastEr0S1,
     {56, 9, 3,
      PROTOBUF_FIELD_OFFSET(IterationStats, _impl_.restart_used_)}},
    // optional double step_size = 8;
    {::_pbi::TcParser::FastF64S1,
     {65, 7, 0,
      PROTOBUF_FIELD_OFFSET(IterationStats, _impl_.step_size_)}},
    // optional double primal_weight = 9;
    {::_pbi::TcParser::FastF64S1,
     {73, 8, 0,
      PROTOBUF_FIELD_OFFSET(IterationStats, _impl_.primal_weight_)}},
    {::_pbi::TcParser::MiniParse, {}},
    // repeated .operations_research.pdlp.PointMetadata point_metadata = 11;
    {::_pbi::TcParser::FastMtR1,
     {90, 2, 2,
      PROTOBUF_FIELD_OFFSET(IterationStats, _impl_.point_metadata_)}},
    {::_pbi::TcParser::MiniParse, {}},
    {::_pbi::TcParser::MiniParse, {}},
    {::_pbi::TcParser::MiniParse, {}},
    {::_pbi::TcParser::MiniParse, {}},
  }}, {{
    65535, 65535
  }}, {{
    // optional int32 iteration_number = 1;
    {PROTOBUF_FIELD_OFFSET(IterationStats, _impl_.iteration_number_), _Internal::kHasBitsOffset + 3, 0, (0 | ::_fl::kFcOptional | ::_fl::kInt32)},
    // repeated .operations_research.pdlp.ConvergenceInformation convergence_information = 2;
    {PROTOBUF_FIELD_OFFSET(IterationStats, _impl_.convergence_information_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcRepeated | ::_fl::kMessage | ::_fl::kTvTable)},
    // repeated .operations_research.pdlp.InfeasibilityInformation infeasibility_information = 3;
    {PROTOBUF_FIELD_OFFSET(IterationStats, _impl_.infeasibility_information_), _Internal::kHasBitsOffset + 1, 1, (0 | ::_fl::kFcRepeated | ::_fl::kMessage | ::_fl::kTvTable)},
    // optional double cumulative_kkt_matrix_passes = 4;
    {PROTOBUF_FIELD_OFFSET(IterationStats, _impl_.cumulative_kkt_matrix_passes_), _Internal::kHasBitsOffset + 5, 0, (0 | ::_fl::kFcOptional | ::_fl::kDouble)},
    // optional int32 cumulative_rejected_steps = 5;
    {PROTOBUF_FIELD_OFFSET(IterationStats, _impl_.cumulative_rejected_steps_), _Internal::kHasBitsOffset + 4, 0, (0 | ::_fl::kFcOptional | ::_fl::kInt32)},
    // optional double cumulative_time_sec = 6;
    {PROTOBUF_FIELD_OFFSET(IterationStats, _impl_.cumulative_time_sec_), _Internal::kHasBitsOffset + 6, 0, (0 | ::_fl::kFcOptional | ::_fl::kDouble)},
    // optional .operations_research.pdlp.RestartChoice restart_used = 7;
    {PROTOBUF_FIELD_OFFSET(IterationStats, _impl_.restart_used_), _Internal::kHasBitsOffset + 9, 3, (0 | ::_fl::kFcOptional | ::_fl::kEnumRange)},
    // optional double step_size = 8;
    {PROTOBUF_FIELD_OFFSET(IterationStats, _impl_.step_size_), _Internal::kHasBitsOffset + 7, 0, (0 | ::_fl::kFcOptional | ::_fl::kDouble)},
    // optional double primal_weight = 9;
    {PROTOBUF_FIELD_OFFSET(IterationStats, _impl_.primal_weight_), _Internal::kHasBitsOffset + 8, 0, (0 | ::_fl::kFcOptional | ::_fl::kDouble)},
    // repeated .operations_research.pdlp.PointMetadata point_metadata = 11;
    {PROTOBUF_FIELD_OFFSET(IterationStats, _impl_.point_metadata_), _Internal::kHasBitsOffset + 2, 2, (0 | ::_fl::kFcRepeated | ::_fl::kMessage | ::_fl::kTvTable)},
  }},
  {{
      {::_pbi::TcParser::GetTable<::operations_research::pdlp::ConvergenceInformation>()},
      {::_pbi::TcParser::GetTable<::operations_research::pdlp::InfeasibilityInformation>()},
      {::_pbi::TcParser::GetTable<::operations_research::pdlp::PointMetadata>()},
      {0, 3},
  }},
  {{
  }},
};
PROTOBUF_NOINLINE void IterationStats::Clear() {
// @@protoc_insertion_point(message_clear_start:operations_research.pdlp.IterationStats)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;
 
  cached_has_bits = _impl_._has_bits_[0];
  if (BatchCheckHasBit(cached_has_bits, 0x00000007U)) {
    if (CheckHasBitForRepeated(cached_has_bits, 0x00000001U)) {
      _impl_.convergence_information_.Clear();
    }
    if (CheckHasBitForRepeated(cached_has_bits, 0x00000002U)) {
      _impl_.infeasibility_information_.Clear();
    }
    if (CheckHasBitForRepeated(cached_has_bits, 0x00000004U)) {
      _impl_.point_metadata_.Clear();
    }
  }
  if (BatchCheckHasBit(cached_has_bits, 0x000000f8U)) {
    ::memset(&_impl_.iteration_number_, 0, static_cast<::size_t>(
        reinterpret_cast<char*>(&_impl_.step_size_) -
        reinterpret_cast<char*>(&_impl_.iteration_number_)) + sizeof(_impl_.step_size_));
  }
  if (BatchCheckHasBit(cached_has_bits, 0x00000300U)) {
    ::memset(&_impl_.primal_weight_, 0, static_cast<::size_t>(
        reinterpret_cast<char*>(&_impl_.restart_used_) -
        reinterpret_cast<char*>(&_impl_.primal_weight_)) + sizeof(_impl_.restart_used_));
  }
  _impl_._has_bits_.Clear();
  _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>();
}
 
#if defined(PROTOBUF_CUSTOM_VTABLE)
::uint8_t* PROTOBUF_NONNULL IterationStats::_InternalSerialize(
    const ::google::protobuf::MessageLite& base, ::uint8_t* PROTOBUF_NONNULL target,
    ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) {
  const IterationStats& this_ = static_cast<const IterationStats&>(base);
#else   // PROTOBUF_CUSTOM_VTABLE
::uint8_t* PROTOBUF_NONNULL IterationStats::_InternalSerialize(
    ::uint8_t* PROTOBUF_NONNULL target,
    ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const {
  const IterationStats& this_ = *this;
#endif  // PROTOBUF_CUSTOM_VTABLE
  if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) {
    this_.CheckHasBitConsistency();
  }
  // @@protoc_insertion_point(serialize_to_array_start:operations_research.pdlp.IterationStats)
  ::uint32_t cached_has_bits = 0;
  (void)cached_has_bits;
 
  cached_has_bits = this_._impl_._has_bits_[0];
  // optional int32 iteration_number = 1;
  if (CheckHasBit(cached_has_bits, 0x00000008U)) {
    target =
        ::google::protobuf::internal::WireFormatLite::WriteInt32ToArrayWithField<1>(
            stream, this_._internal_iteration_number(), target);
  }
 
  // repeated .operations_research.pdlp.ConvergenceInformation convergence_information = 2;
  if (CheckHasBitForRepeated(cached_has_bits, 0x00000001U)) {
    for (unsigned i = 0, n = static_cast<unsigned>(
                             this_._internal_convergence_information_size());
         i < n; i++) {
      const auto& repfield = this_._internal_convergence_information().Get(i);
      target =
          ::google::protobuf::internal::WireFormatLite::InternalWriteMessage(
              2, repfield, repfield.GetCachedSize(),
              target, stream);
    }
  }
 
  // repeated .operations_research.pdlp.InfeasibilityInformation infeasibility_information = 3;
  if (CheckHasBitForRepeated(cached_has_bits, 0x00000002U)) {
    for (unsigned i = 0, n = static_cast<unsigned>(
                             this_._internal_infeasibility_information_size());
         i < n; i++) {
      const auto& repfield = this_._internal_infeasibility_information().Get(i);
      target =
          ::google::protobuf::internal::WireFormatLite::InternalWriteMessage(
              3, repfield, repfield.GetCachedSize(),
              target, stream);
    }
  }
 
  // optional double cumulative_kkt_matrix_passes = 4;
  if (CheckHasBit(cached_has_bits, 0x00000020U)) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteDoubleToArray(
        4, this_._internal_cumulative_kkt_matrix_passes(), target);
  }
 
  // optional int32 cumulative_rejected_steps = 5;
  if (CheckHasBit(cached_has_bits, 0x00000010U)) {
    target =
        ::google::protobuf::internal::WireFormatLite::WriteInt32ToArrayWithField<5>(
            stream, this_._internal_cumulative_rejected_steps(), target);
  }
 
  // optional double cumulative_time_sec = 6;
  if (CheckHasBit(cached_has_bits, 0x00000040U)) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteDoubleToArray(
        6, this_._internal_cumulative_time_sec(), target);
  }
 
  // optional .operations_research.pdlp.RestartChoice restart_used = 7;
  if (CheckHasBit(cached_has_bits, 0x00000200U)) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteEnumToArray(
        7, this_._internal_restart_used(), target);
  }
 
  // optional double step_size = 8;
  if (CheckHasBit(cached_has_bits, 0x00000080U)) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteDoubleToArray(
        8, this_._internal_step_size(), target);
  }
 
  // optional double primal_weight = 9;
  if (CheckHasBit(cached_has_bits, 0x00000100U)) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteDoubleToArray(
        9, this_._internal_primal_weight(), target);
  }
 
  // repeated .operations_research.pdlp.PointMetadata point_metadata = 11;
  if (CheckHasBitForRepeated(cached_has_bits, 0x00000004U)) {
    for (unsigned i = 0, n = static_cast<unsigned>(
                             this_._internal_point_metadata_size());
         i < n; i++) {
      const auto& repfield = this_._internal_point_metadata().Get(i);
      target =
          ::google::protobuf::internal::WireFormatLite::InternalWriteMessage(
              11, repfield, repfield.GetCachedSize(),
              target, stream);
    }
  }
 
  if (ABSL_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) {
    target =
        ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray(
            this_._internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:operations_research.pdlp.IterationStats)
  return target;
}
 
#if defined(PROTOBUF_CUSTOM_VTABLE)
::size_t IterationStats::ByteSizeLong(const MessageLite& base) {
  const IterationStats& this_ = static_cast<const IterationStats&>(base);
#else   // PROTOBUF_CUSTOM_VTABLE
::size_t IterationStats::ByteSizeLong() const {
  const IterationStats& this_ = *this;
#endif  // PROTOBUF_CUSTOM_VTABLE
  // @@protoc_insertion_point(message_byte_size_start:operations_research.pdlp.IterationStats)
  ::size_t total_size = 0;
 
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void)cached_has_bits;
 
  ::_pbi::Prefetch5LinesFrom7Lines(&this_);
  cached_has_bits = this_._impl_._has_bits_[0];
  total_size += ::absl::popcount(0x000001e0U & cached_has_bits) * 9;
  if (BatchCheckHasBit(cached_has_bits, 0x0000001fU)) {
    // repeated .operations_research.pdlp.ConvergenceInformation convergence_information = 2;
    if (CheckHasBitForRepeated(cached_has_bits, 0x00000001U)) {
      total_size += 1UL * this_._internal_convergence_information_size();
      for (const auto& msg : this_._internal_convergence_information()) {
        total_size += ::google::protobuf::internal::WireFormatLite::MessageSize(msg);
      }
    }
    // repeated .operations_research.pdlp.InfeasibilityInformation infeasibility_information = 3;
    if (CheckHasBitForRepeated(cached_has_bits, 0x00000002U)) {
      total_size += 1UL * this_._internal_infeasibility_information_size();
      for (const auto& msg : this_._internal_infeasibility_information()) {
        total_size += ::google::protobuf::internal::WireFormatLite::MessageSize(msg);
      }
    }
    // repeated .operations_research.pdlp.PointMetadata point_metadata = 11;
    if (CheckHasBitForRepeated(cached_has_bits, 0x00000004U)) {
      total_size += 1UL * this_._internal_point_metadata_size();
      for (const auto& msg : this_._internal_point_metadata()) {
        total_size += ::google::protobuf::internal::WireFormatLite::MessageSize(msg);
      }
    }
    // optional int32 iteration_number = 1;
    if (CheckHasBit(cached_has_bits, 0x00000008U)) {
      total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(
          this_._internal_iteration_number());
    }
    // optional int32 cumulative_rejected_steps = 5;
    if (CheckHasBit(cached_has_bits, 0x00000010U)) {
      total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(
          this_._internal_cumulative_rejected_steps());
    }
  }
   {
    // optional .operations_research.pdlp.RestartChoice restart_used = 7;
    if (CheckHasBit(cached_has_bits, 0x00000200U)) {
      total_size += 1 +
                    ::_pbi::WireFormatLite::EnumSize(this_._internal_restart_used());
    }
  }
  return this_.MaybeComputeUnknownFieldsSize(total_size,
                                             &this_._impl_._cached_size_);
}
 
void IterationStats::MergeImpl(::google::protobuf::MessageLite& to_msg,
                            const ::google::protobuf::MessageLite& from_msg) {
   auto* const _this =
      static_cast<IterationStats*>(&to_msg);
  auto& from = static_cast<const IterationStats&>(from_msg);
  if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) {
    from.CheckHasBitConsistency();
  }
  ::google::protobuf::Arena* arena = _this->GetArena();
  // @@protoc_insertion_point(class_specific_merge_from_start:operations_research.pdlp.IterationStats)
  ABSL_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void)cached_has_bits;
 
  cached_has_bits = from._impl_._has_bits_[0];
  if (BatchCheckHasBit(cached_has_bits, 0x000000ffU)) {
    if (CheckHasBitForRepeated(cached_has_bits, 0x00000001U)) {
      _this->_internal_mutable_convergence_information()->InternalMergeFromWithArena(
          ::google::protobuf::MessageLite::internal_visibility(), arena,
          from._internal_convergence_information());
    }
    if (CheckHasBitForRepeated(cached_has_bits, 0x00000002U)) {
      _this->_internal_mutable_infeasibility_information()->InternalMergeFromWithArena(
          ::google::protobuf::MessageLite::internal_visibility(), arena,
          from._internal_infeasibility_information());
    }
    if (CheckHasBitForRepeated(cached_has_bits, 0x00000004U)) {
      _this->_internal_mutable_point_metadata()->InternalMergeFromWithArena(
          ::google::protobuf::MessageLite::internal_visibility(), arena,
          from._internal_point_metadata());
    }
    if (CheckHasBit(cached_has_bits, 0x00000008U)) {
      _this->_impl_.iteration_number_ = from._impl_.iteration_number_;
    }
    if (CheckHasBit(cached_has_bits, 0x00000010U)) {
      _this->_impl_.cumulative_rejected_steps_ = from._impl_.cumulative_rejected_steps_;
    }
    if (CheckHasBit(cached_has_bits, 0x00000020U)) {
      _this->_impl_.cumulative_kkt_matrix_passes_ = from._impl_.cumulative_kkt_matrix_passes_;
    }
    if (CheckHasBit(cached_has_bits, 0x00000040U)) {
      _this->_impl_.cumulative_time_sec_ = from._impl_.cumulative_time_sec_;
    }
    if (CheckHasBit(cached_has_bits, 0x00000080U)) {
      _this->_impl_.step_size_ = from._impl_.step_size_;
    }
  }
  if (BatchCheckHasBit(cached_has_bits, 0x00000300U)) {
    if (CheckHasBit(cached_has_bits, 0x00000100U)) {
      _this->_impl_.primal_weight_ = from._impl_.primal_weight_;
    }
    if (CheckHasBit(cached_has_bits, 0x00000200U)) {
      _this->_impl_.restart_used_ = from._impl_.restart_used_;
    }
  }
  _this->_impl_._has_bits_[0] |= cached_has_bits;
  _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(
      from._internal_metadata_);
}
 
void IterationStats::CopyFrom(const IterationStats& from) {
  // @@protoc_insertion_point(class_specific_copy_from_start:operations_research.pdlp.IterationStats)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}
 
 
void IterationStats::InternalSwap(IterationStats* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) {
  using ::std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
  _impl_.convergence_information_.InternalSwap(&other->_impl_.convergence_information_);
  _impl_.infeasibility_information_.InternalSwap(&other->_impl_.infeasibility_information_);
  _impl_.point_metadata_.InternalSwap(&other->_impl_.point_metadata_);
  ::google::protobuf::internal::memswap<
      PROTOBUF_FIELD_OFFSET(IterationStats, _impl_.restart_used_)
      + sizeof(IterationStats::_impl_.restart_used_)
      - PROTOBUF_FIELD_OFFSET(IterationStats, _impl_.iteration_number_)>(
          reinterpret_cast<char*>(&_impl_.iteration_number_),
          reinterpret_cast<char*>(&other->_impl_.iteration_number_));
}
 
::google::protobuf::Metadata IterationStats::GetMetadata() const {
  return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full());
}
// ===================================================================
 
class FeasibilityPolishingDetails::_Internal {
 public:
  using HasBits =
      decltype(::std::declval<FeasibilityPolishingDetails>()._impl_._has_bits_);
  static constexpr ::int32_t kHasBitsOffset =
      8 * PROTOBUF_FIELD_OFFSET(FeasibilityPolishingDetails, _impl_._has_bits_);
};
 
void FeasibilityPolishingDetails::clear_params() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.params_ != nullptr) _impl_.params_->Clear();
  ClearHasBit(_impl_._has_bits_[0],
                  0x00000002U);
}
FeasibilityPolishingDetails::FeasibilityPolishingDetails(::google::protobuf::Arena* PROTOBUF_NULLABLE arena)
#if defined(PROTOBUF_CUSTOM_VTABLE)
    : ::google::protobuf::Message(arena, FeasibilityPolishingDetails_class_data_.base()) {
#else   // PROTOBUF_CUSTOM_VTABLE
    : ::google::protobuf::Message(arena) {
#endif  // PROTOBUF_CUSTOM_VTABLE
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:operations_research.pdlp.FeasibilityPolishingDetails)
}
PROTOBUF_NDEBUG_INLINE FeasibilityPolishingDetails::Impl_::Impl_(
    [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility,
    [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from,
    [[maybe_unused]] const ::operations_research::pdlp::FeasibilityPolishingDetails& from_msg)
      : _has_bits_{from._has_bits_},
        _cached_size_{0},
        iteration_stats_{visibility, arena, from.iteration_stats_} {}
 
FeasibilityPolishingDetails::FeasibilityPolishingDetails(
    ::google::protobuf::Arena* PROTOBUF_NULLABLE arena,
    const FeasibilityPolishingDetails& from)
#if defined(PROTOBUF_CUSTOM_VTABLE)
    : ::google::protobuf::Message(arena, FeasibilityPolishingDetails_class_data_.base()) {
#else   // PROTOBUF_CUSTOM_VTABLE
    : ::google::protobuf::Message(arena) {
#endif  // PROTOBUF_CUSTOM_VTABLE
  FeasibilityPolishingDetails* const _this = this;
  (void)_this;
  _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(
      from._internal_metadata_);
  new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from);
  ::uint32_t cached_has_bits = _impl_._has_bits_[0];
  _impl_.params_ = (CheckHasBit(cached_has_bits, 0x00000002U))
                ? ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.params_)
                : nullptr;
  _impl_.solution_stats_ = (CheckHasBit(cached_has_bits, 0x00000004U))
                ? ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.solution_stats_)
                : nullptr;
  ::memcpy(reinterpret_cast<char*>(&_impl_) +
               offsetof(Impl_, polishing_phase_type_),
           reinterpret_cast<const char*>(&from._impl_) +
               offsetof(Impl_, polishing_phase_type_),
           offsetof(Impl_, solution_type_) -
               offsetof(Impl_, polishing_phase_type_) +
               sizeof(Impl_::solution_type_));
 
  // @@protoc_insertion_point(copy_constructor:operations_research.pdlp.FeasibilityPolishingDetails)
}
PROTOBUF_NDEBUG_INLINE FeasibilityPolishingDetails::Impl_::Impl_(
    [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility,
    [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena)
      : _cached_size_{0},
        iteration_stats_{visibility, arena} {}
 
inline void FeasibilityPolishingDetails::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) {
  new (&_impl_) Impl_(internal_visibility(), arena);
  ::memset(reinterpret_cast<char*>(&_impl_) +
               offsetof(Impl_, params_),
           0,
           offsetof(Impl_, solution_type_) -
               offsetof(Impl_, params_) +
               sizeof(Impl_::solution_type_));
}
FeasibilityPolishingDetails::~FeasibilityPolishingDetails() {
  // @@protoc_insertion_point(destructor:operations_research.pdlp.FeasibilityPolishingDetails)
  SharedDtor(*this);
}
inline void FeasibilityPolishingDetails::SharedDtor(MessageLite& self) {
  FeasibilityPolishingDetails& this_ = static_cast<FeasibilityPolishingDetails&>(self);
  if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) {
    this_.CheckHasBitConsistency();
  }
  this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>();
  ABSL_DCHECK(this_.GetArena() == nullptr);
  delete this_._impl_.params_;
  delete this_._impl_.solution_stats_;
  this_._impl_.~Impl_();
}
 
inline void* PROTOBUF_NONNULL FeasibilityPolishingDetails::PlacementNew_(
    const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem,
    ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) {
  return ::new (mem) FeasibilityPolishingDetails(arena);
}
constexpr auto FeasibilityPolishingDetails::InternalNewImpl_() {
  constexpr auto arena_bits = ::google::protobuf::internal::EncodePlacementArenaOffsets({
      PROTOBUF_FIELD_OFFSET(FeasibilityPolishingDetails, _impl_.iteration_stats_) +
          decltype(FeasibilityPolishingDetails::_impl_.iteration_stats_)::
              InternalGetArenaOffset(
                  ::google::protobuf::Message::internal_visibility()),
  });
  if (arena_bits.has_value()) {
    return ::google::protobuf::internal::MessageCreator::ZeroInit(
        sizeof(FeasibilityPolishingDetails), alignof(FeasibilityPolishingDetails), *arena_bits);
  } else {
    return ::google::protobuf::internal::MessageCreator(&FeasibilityPolishingDetails::PlacementNew_,
                                 sizeof(FeasibilityPolishingDetails),
                                 alignof(FeasibilityPolishingDetails));
  }
}
constexpr auto FeasibilityPolishingDetails::InternalGenerateClassData_() {
  return ::google::protobuf::internal::ClassDataFull{
      ::google::protobuf::internal::ClassData{
          &_FeasibilityPolishingDetails_default_instance_._instance,
          &_table_.header,
          nullptr,  // OnDemandRegisterArenaDtor
          nullptr,  // IsInitialized
          &FeasibilityPolishingDetails::MergeImpl,
          ::google::protobuf::Message::GetNewImpl<FeasibilityPolishingDetails>(),
#if defined(PROTOBUF_CUSTOM_VTABLE)
          &FeasibilityPolishingDetails::SharedDtor,
          ::google::protobuf::Message::GetClearImpl<FeasibilityPolishingDetails>(), &FeasibilityPolishingDetails::ByteSizeLong,
              &FeasibilityPolishingDetails::_InternalSerialize,
#endif  // PROTOBUF_CUSTOM_VTABLE
          PROTOBUF_FIELD_OFFSET(FeasibilityPolishingDetails, _impl_._cached_size_),
          false,
      },
      &FeasibilityPolishingDetails::kDescriptorMethods,
      &descriptor_table_ortools_2fpdlp_2fsolve_5flog_2eproto,
      nullptr,  // tracker
  };
}
 
PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const
    ::google::protobuf::internal::ClassDataFull FeasibilityPolishingDetails_class_data_ =
        FeasibilityPolishingDetails::InternalGenerateClassData_();
 
PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL
FeasibilityPolishingDetails::GetClassData() const {
  ::google::protobuf::internal::PrefetchToLocalCache(&FeasibilityPolishingDetails_class_data_);
  ::google::protobuf::internal::PrefetchToLocalCache(FeasibilityPolishingDetails_class_data_.tc_table);
  return FeasibilityPolishingDetails_class_data_.base();
}
PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1
const ::_pbi::TcParseTable<4, 9, 6, 0, 2>
FeasibilityPolishingDetails::_table_ = {
  {
    PROTOBUF_FIELD_OFFSET(FeasibilityPolishingDetails, _impl_._has_bits_),
    0, // no _extensions_
    9, 120,  // max_field_number, fast_idx_mask
    offsetof(decltype(_table_), field_lookup_table),
    4294966784,  // skipmap
    offsetof(decltype(_table_), field_entries),
    9,  // num_field_entries
    6,  // num_aux_entries
    offsetof(decltype(_table_), aux_entries),
    FeasibilityPolishingDetails_class_data_.base(),
    nullptr,  // post_loop_handler
    ::_pbi::TcParser::GenericFallback,  // fallback
    #ifdef PROTOBUF_PREFETCH_PARSE_TABLE
    ::_pbi::TcParser::GetTable<::operations_research::pdlp::FeasibilityPolishingDetails>(),  // to_prefetch
    #endif  // PROTOBUF_PREFETCH_PARSE_TABLE
  }, {{
    {::_pbi::TcParser::MiniParse, {}},
    // optional .operations_research.pdlp.PolishingPhaseType polishing_phase_type = 1;
    {::_pbi::TcParser::FastEr0S1,
     {8, 3, 2,
      PROTOBUF_FIELD_OFFSET(FeasibilityPolishingDetails, _impl_.polishing_phase_type_)}},
    // optional int32 main_iteration_count = 2;
    {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(FeasibilityPolishingDetails, _impl_.main_iteration_count_), 4>(),
     {16, 4, 0,
      PROTOBUF_FIELD_OFFSET(FeasibilityPolishingDetails, _impl_.main_iteration_count_)}},
    // optional .operations_research.pdlp.PrimalDualHybridGradientParams params = 3;
    {::_pbi::TcParser::FastMtS1,
     {26, 1, 0,
      PROTOBUF_FIELD_OFFSET(FeasibilityPolishingDetails, _impl_.params_)}},
    // optional .operations_research.pdlp.TerminationReason termination_reason = 4;
    {::_pbi::TcParser::FastEr0S1,
     {32, 5, 13,
      PROTOBUF_FIELD_OFFSET(FeasibilityPolishingDetails, _impl_.termination_reason_)}},
    // optional int32 iteration_count = 5;
    {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(FeasibilityPolishingDetails, _impl_.iteration_count_), 6>(),
     {40, 6, 0,
      PROTOBUF_FIELD_OFFSET(FeasibilityPolishingDetails, _impl_.iteration_count_)}},
    // optional double solve_time_sec = 6;
    {::_pbi::TcParser::FastF64S1,
     {49, 7, 0,
      PROTOBUF_FIELD_OFFSET(FeasibilityPolishingDetails, _impl_.solve_time_sec_)}},
    // optional .operations_research.pdlp.IterationStats solution_stats = 7;
    {::_pbi::TcParser::FastMtS1,
     {58, 2, 1,
      PROTOBUF_FIELD_OFFSET(FeasibilityPolishingDetails, _impl_.solution_stats_)}},
    // optional .operations_research.pdlp.PointType solution_type = 8;
    {::_pbi::TcParser::FastEr0S1,
     {64, 8, 6,
      PROTOBUF_FIELD_OFFSET(FeasibilityPolishingDetails, _impl_.solution_type_)}},
    // repeated .operations_research.pdlp.IterationStats iteration_stats = 9;
    {::_pbi::TcParser::FastMtR1,
     {74, 0, 2,
      PROTOBUF_FIELD_OFFSET(FeasibilityPolishingDetails, _impl_.iteration_stats_)}},
    {::_pbi::TcParser::MiniParse, {}},
    {::_pbi::TcParser::MiniParse, {}},
    {::_pbi::TcParser::MiniParse, {}},
    {::_pbi::TcParser::MiniParse, {}},
    {::_pbi::TcParser::MiniParse, {}},
    {::_pbi::TcParser::MiniParse, {}},
  }}, {{
    65535, 65535
  }}, {{
    // optional .operations_research.pdlp.PolishingPhaseType polishing_phase_type = 1;
    {PROTOBUF_FIELD_OFFSET(FeasibilityPolishingDetails, _impl_.polishing_phase_type_), _Internal::kHasBitsOffset + 3, 3, (0 | ::_fl::kFcOptional | ::_fl::kEnumRange)},
    // optional int32 main_iteration_count = 2;
    {PROTOBUF_FIELD_OFFSET(FeasibilityPolishingDetails, _impl_.main_iteration_count_), _Internal::kHasBitsOffset + 4, 0, (0 | ::_fl::kFcOptional | ::_fl::kInt32)},
    // optional .operations_research.pdlp.PrimalDualHybridGradientParams params = 3;
    {PROTOBUF_FIELD_OFFSET(FeasibilityPolishingDetails, _impl_.params_), _Internal::kHasBitsOffset + 1, 0, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)},
    // optional .operations_research.pdlp.TerminationReason termination_reason = 4;
    {PROTOBUF_FIELD_OFFSET(FeasibilityPolishingDetails, _impl_.termination_reason_), _Internal::kHasBitsOffset + 5, 4, (0 | ::_fl::kFcOptional | ::_fl::kEnumRange)},
    // optional int32 iteration_count = 5;
    {PROTOBUF_FIELD_OFFSET(FeasibilityPolishingDetails, _impl_.iteration_count_), _Internal::kHasBitsOffset + 6, 0, (0 | ::_fl::kFcOptional | ::_fl::kInt32)},
    // optional double solve_time_sec = 6;
    {PROTOBUF_FIELD_OFFSET(FeasibilityPolishingDetails, _impl_.solve_time_sec_), _Internal::kHasBitsOffset + 7, 0, (0 | ::_fl::kFcOptional | ::_fl::kDouble)},
    // optional .operations_research.pdlp.IterationStats solution_stats = 7;
    {PROTOBUF_FIELD_OFFSET(FeasibilityPolishingDetails, _impl_.solution_stats_), _Internal::kHasBitsOffset + 2, 1, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)},
    // optional .operations_research.pdlp.PointType solution_type = 8;
    {PROTOBUF_FIELD_OFFSET(FeasibilityPolishingDetails, _impl_.solution_type_), _Internal::kHasBitsOffset + 8, 5, (0 | ::_fl::kFcOptional | ::_fl::kEnumRange)},
    // repeated .operations_research.pdlp.IterationStats iteration_stats = 9;
    {PROTOBUF_FIELD_OFFSET(FeasibilityPolishingDetails, _impl_.iteration_stats_), _Internal::kHasBitsOffset + 0, 2, (0 | ::_fl::kFcRepeated | ::_fl::kMessage | ::_fl::kTvTable)},
  }},
  {{
      {::_pbi::TcParser::GetTable<::operations_research::pdlp::PrimalDualHybridGradientParams>()},
      {::_pbi::TcParser::GetTable<::operations_research::pdlp::IterationStats>()},
      {::_pbi::TcParser::GetTable<::operations_research::pdlp::IterationStats>()},
      {0, 2},
      {0, 13},
      {0, 6},
  }},
  {{
  }},
};
PROTOBUF_NOINLINE void FeasibilityPolishingDetails::Clear() {
// @@protoc_insertion_point(message_clear_start:operations_research.pdlp.FeasibilityPolishingDetails)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;
 
  cached_has_bits = _impl_._has_bits_[0];
  if (BatchCheckHasBit(cached_has_bits, 0x00000007U)) {
    if (CheckHasBitForRepeated(cached_has_bits, 0x00000001U)) {
      _impl_.iteration_stats_.Clear();
    }
    if (CheckHasBit(cached_has_bits, 0x00000002U)) {
      ABSL_DCHECK(_impl_.params_ != nullptr);
      _impl_.params_->Clear();
    }
    if (CheckHasBit(cached_has_bits, 0x00000004U)) {
      ABSL_DCHECK(_impl_.solution_stats_ != nullptr);
      _impl_.solution_stats_->Clear();
    }
  }
  if (BatchCheckHasBit(cached_has_bits, 0x000000f8U)) {
    ::memset(&_impl_.polishing_phase_type_, 0, static_cast<::size_t>(
        reinterpret_cast<char*>(&_impl_.solve_time_sec_) -
        reinterpret_cast<char*>(&_impl_.polishing_phase_type_)) + sizeof(_impl_.solve_time_sec_));
  }
  _impl_.solution_type_ = 0;
  _impl_._has_bits_.Clear();
  _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>();
}
 
#if defined(PROTOBUF_CUSTOM_VTABLE)
::uint8_t* PROTOBUF_NONNULL FeasibilityPolishingDetails::_InternalSerialize(
    const ::google::protobuf::MessageLite& base, ::uint8_t* PROTOBUF_NONNULL target,
    ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) {
  const FeasibilityPolishingDetails& this_ = static_cast<const FeasibilityPolishingDetails&>(base);
#else   // PROTOBUF_CUSTOM_VTABLE
::uint8_t* PROTOBUF_NONNULL FeasibilityPolishingDetails::_InternalSerialize(
    ::uint8_t* PROTOBUF_NONNULL target,
    ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const {
  const FeasibilityPolishingDetails& this_ = *this;
#endif  // PROTOBUF_CUSTOM_VTABLE
  if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) {
    this_.CheckHasBitConsistency();
  }
  // @@protoc_insertion_point(serialize_to_array_start:operations_research.pdlp.FeasibilityPolishingDetails)
  ::uint32_t cached_has_bits = 0;
  (void)cached_has_bits;
 
  cached_has_bits = this_._impl_._has_bits_[0];
  // optional .operations_research.pdlp.PolishingPhaseType polishing_phase_type = 1;
  if (CheckHasBit(cached_has_bits, 0x00000008U)) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteEnumToArray(
        1, this_._internal_polishing_phase_type(), target);
  }
 
  // optional int32 main_iteration_count = 2;
  if (CheckHasBit(cached_has_bits, 0x00000010U)) {
    target =
        ::google::protobuf::internal::WireFormatLite::WriteInt32ToArrayWithField<2>(
            stream, this_._internal_main_iteration_count(), target);
  }
 
  // optional .operations_research.pdlp.PrimalDualHybridGradientParams params = 3;
  if (CheckHasBit(cached_has_bits, 0x00000002U)) {
    target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage(
        3, *this_._impl_.params_, this_._impl_.params_->GetCachedSize(), target,
        stream);
  }
 
  // optional .operations_research.pdlp.TerminationReason termination_reason = 4;
  if (CheckHasBit(cached_has_bits, 0x00000020U)) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteEnumToArray(
        4, this_._internal_termination_reason(), target);
  }
 
  // optional int32 iteration_count = 5;
  if (CheckHasBit(cached_has_bits, 0x00000040U)) {
    target =
        ::google::protobuf::internal::WireFormatLite::WriteInt32ToArrayWithField<5>(
            stream, this_._internal_iteration_count(), target);
  }
 
  // optional double solve_time_sec = 6;
  if (CheckHasBit(cached_has_bits, 0x00000080U)) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteDoubleToArray(
        6, this_._internal_solve_time_sec(), target);
  }
 
  // optional .operations_research.pdlp.IterationStats solution_stats = 7;
  if (CheckHasBit(cached_has_bits, 0x00000004U)) {
    target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage(
        7, *this_._impl_.solution_stats_, this_._impl_.solution_stats_->GetCachedSize(), target,
        stream);
  }
 
  // optional .operations_research.pdlp.PointType solution_type = 8;
  if (CheckHasBit(cached_has_bits, 0x00000100U)) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteEnumToArray(
        8, this_._internal_solution_type(), target);
  }
 
  // repeated .operations_research.pdlp.IterationStats iteration_stats = 9;
  if (CheckHasBitForRepeated(cached_has_bits, 0x00000001U)) {
    for (unsigned i = 0, n = static_cast<unsigned>(
                             this_._internal_iteration_stats_size());
         i < n; i++) {
      const auto& repfield = this_._internal_iteration_stats().Get(i);
      target =
          ::google::protobuf::internal::WireFormatLite::InternalWriteMessage(
              9, repfield, repfield.GetCachedSize(),
              target, stream);
    }
  }
 
  if (ABSL_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) {
    target =
        ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray(
            this_._internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:operations_research.pdlp.FeasibilityPolishingDetails)
  return target;
}
 
#if defined(PROTOBUF_CUSTOM_VTABLE)
::size_t FeasibilityPolishingDetails::ByteSizeLong(const MessageLite& base) {
  const FeasibilityPolishingDetails& this_ = static_cast<const FeasibilityPolishingDetails&>(base);
#else   // PROTOBUF_CUSTOM_VTABLE
::size_t FeasibilityPolishingDetails::ByteSizeLong() const {
  const FeasibilityPolishingDetails& this_ = *this;
#endif  // PROTOBUF_CUSTOM_VTABLE
  // @@protoc_insertion_point(message_byte_size_start:operations_research.pdlp.FeasibilityPolishingDetails)
  ::size_t total_size = 0;
 
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void)cached_has_bits;
 
  ::_pbi::Prefetch5LinesFrom7Lines(&this_);
  cached_has_bits = this_._impl_._has_bits_[0];
  total_size += static_cast<bool>(0x00000080U & cached_has_bits) * 9;
  if (BatchCheckHasBit(cached_has_bits, 0x0000007fU)) {
    // repeated .operations_research.pdlp.IterationStats iteration_stats = 9;
    if (CheckHasBitForRepeated(cached_has_bits, 0x00000001U)) {
      total_size += 1UL * this_._internal_iteration_stats_size();
      for (const auto& msg : this_._internal_iteration_stats()) {
        total_size += ::google::protobuf::internal::WireFormatLite::MessageSize(msg);
      }
    }
    // optional .operations_research.pdlp.PrimalDualHybridGradientParams params = 3;
    if (CheckHasBit(cached_has_bits, 0x00000002U)) {
      total_size += 1 +
                    ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.params_);
    }
    // optional .operations_research.pdlp.IterationStats solution_stats = 7;
    if (CheckHasBit(cached_has_bits, 0x00000004U)) {
      total_size += 1 +
                    ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.solution_stats_);
    }
    // optional .operations_research.pdlp.PolishingPhaseType polishing_phase_type = 1;
    if (CheckHasBit(cached_has_bits, 0x00000008U)) {
      total_size += 1 +
                    ::_pbi::WireFormatLite::EnumSize(this_._internal_polishing_phase_type());
    }
    // optional int32 main_iteration_count = 2;
    if (CheckHasBit(cached_has_bits, 0x00000010U)) {
      total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(
          this_._internal_main_iteration_count());
    }
    // optional .operations_research.pdlp.TerminationReason termination_reason = 4;
    if (CheckHasBit(cached_has_bits, 0x00000020U)) {
      total_size += 1 +
                    ::_pbi::WireFormatLite::EnumSize(this_._internal_termination_reason());
    }
    // optional int32 iteration_count = 5;
    if (CheckHasBit(cached_has_bits, 0x00000040U)) {
      total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(
          this_._internal_iteration_count());
    }
  }
   {
    // optional .operations_research.pdlp.PointType solution_type = 8;
    if (CheckHasBit(cached_has_bits, 0x00000100U)) {
      total_size += 1 +
                    ::_pbi::WireFormatLite::EnumSize(this_._internal_solution_type());
    }
  }
  return this_.MaybeComputeUnknownFieldsSize(total_size,
                                             &this_._impl_._cached_size_);
}
 
void FeasibilityPolishingDetails::MergeImpl(::google::protobuf::MessageLite& to_msg,
                            const ::google::protobuf::MessageLite& from_msg) {
   auto* const _this =
      static_cast<FeasibilityPolishingDetails*>(&to_msg);
  auto& from = static_cast<const FeasibilityPolishingDetails&>(from_msg);
  if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) {
    from.CheckHasBitConsistency();
  }
  ::google::protobuf::Arena* arena = _this->GetArena();
  // @@protoc_insertion_point(class_specific_merge_from_start:operations_research.pdlp.FeasibilityPolishingDetails)
  ABSL_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void)cached_has_bits;
 
  cached_has_bits = from._impl_._has_bits_[0];
  if (BatchCheckHasBit(cached_has_bits, 0x000000ffU)) {
    if (CheckHasBitForRepeated(cached_has_bits, 0x00000001U)) {
      _this->_internal_mutable_iteration_stats()->InternalMergeFromWithArena(
          ::google::protobuf::MessageLite::internal_visibility(), arena,
          from._internal_iteration_stats());
    }
    if (CheckHasBit(cached_has_bits, 0x00000002U)) {
      ABSL_DCHECK(from._impl_.params_ != nullptr);
      if (_this->_impl_.params_ == nullptr) {
        _this->_impl_.params_ = ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.params_);
      } else {
        _this->_impl_.params_->MergeFrom(*from._impl_.params_);
      }
    }
    if (CheckHasBit(cached_has_bits, 0x00000004U)) {
      ABSL_DCHECK(from._impl_.solution_stats_ != nullptr);
      if (_this->_impl_.solution_stats_ == nullptr) {
        _this->_impl_.solution_stats_ = ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.solution_stats_);
      } else {
        _this->_impl_.solution_stats_->MergeFrom(*from._impl_.solution_stats_);
      }
    }
    if (CheckHasBit(cached_has_bits, 0x00000008U)) {
      _this->_impl_.polishing_phase_type_ = from._impl_.polishing_phase_type_;
    }
    if (CheckHasBit(cached_has_bits, 0x00000010U)) {
      _this->_impl_.main_iteration_count_ = from._impl_.main_iteration_count_;
    }
    if (CheckHasBit(cached_has_bits, 0x00000020U)) {
      _this->_impl_.termination_reason_ = from._impl_.termination_reason_;
    }
    if (CheckHasBit(cached_has_bits, 0x00000040U)) {
      _this->_impl_.iteration_count_ = from._impl_.iteration_count_;
    }
    if (CheckHasBit(cached_has_bits, 0x00000080U)) {
      _this->_impl_.solve_time_sec_ = from._impl_.solve_time_sec_;
    }
  }
  if (CheckHasBit(cached_has_bits, 0x00000100U)) {
    _this->_impl_.solution_type_ = from._impl_.solution_type_;
  }
  _this->_impl_._has_bits_[0] |= cached_has_bits;
  _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(
      from._internal_metadata_);
}
 
void FeasibilityPolishingDetails::CopyFrom(const FeasibilityPolishingDetails& from) {
  // @@protoc_insertion_point(class_specific_copy_from_start:operations_research.pdlp.FeasibilityPolishingDetails)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}
 
 
void FeasibilityPolishingDetails::InternalSwap(FeasibilityPolishingDetails* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) {
  using ::std::swap;
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
  _impl_.iteration_stats_.InternalSwap(&other->_impl_.iteration_stats_);
  ::google::protobuf::internal::memswap<
      PROTOBUF_FIELD_OFFSET(FeasibilityPolishingDetails, _impl_.solution_type_)
      + sizeof(FeasibilityPolishingDetails::_impl_.solution_type_)
      - PROTOBUF_FIELD_OFFSET(FeasibilityPolishingDetails, _impl_.params_)>(
          reinterpret_cast<char*>(&_impl_.params_),
          reinterpret_cast<char*>(&other->_impl_.params_));
}
 
::google::protobuf::Metadata FeasibilityPolishingDetails::GetMetadata() const {
  return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full());
}
// ===================================================================
 
class SolveLog::_Internal {
 public:
  using HasBits =
      decltype(::std::declval<SolveLog>()._impl_._has_bits_);
  static constexpr ::int32_t kHasBitsOffset =
      8 * PROTOBUF_FIELD_OFFSET(SolveLog, _impl_._has_bits_);
};
 
void SolveLog::clear_params() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.params_ != nullptr) _impl_.params_->Clear();
  ClearHasBit(_impl_._has_bits_[0],
                  0x00000080U);
}
SolveLog::SolveLog(::google::protobuf::Arena* PROTOBUF_NULLABLE arena)
#if defined(PROTOBUF_CUSTOM_VTABLE)
    : ::google::protobuf::Message(arena, SolveLog_class_data_.base()) {
#else   // PROTOBUF_CUSTOM_VTABLE
    : ::google::protobuf::Message(arena) {
#endif  // PROTOBUF_CUSTOM_VTABLE
  SharedCtor(arena);
  // @@protoc_insertion_point(arena_constructor:operations_research.pdlp.SolveLog)
}
PROTOBUF_NDEBUG_INLINE SolveLog::Impl_::Impl_(
    [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility,
    [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from,
    [[maybe_unused]] const ::operations_research::pdlp::SolveLog& from_msg)
      : _has_bits_{from._has_bits_},
        _cached_size_{0},
        iteration_stats_{visibility, arena, from.iteration_stats_},
        feasibility_polishing_details_{visibility, arena, from.feasibility_polishing_details_},
        instance_name_(arena, from.instance_name_),
        termination_string_(arena, from.termination_string_) {}
 
SolveLog::SolveLog(
    ::google::protobuf::Arena* PROTOBUF_NULLABLE arena,
    const SolveLog& from)
#if defined(PROTOBUF_CUSTOM_VTABLE)
    : ::google::protobuf::Message(arena, SolveLog_class_data_.base()) {
#else   // PROTOBUF_CUSTOM_VTABLE
    : ::google::protobuf::Message(arena) {
#endif  // PROTOBUF_CUSTOM_VTABLE
  SolveLog* const _this = this;
  (void)_this;
  _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(
      from._internal_metadata_);
  new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from);
  ::uint32_t cached_has_bits = _impl_._has_bits_[0];
  _impl_.solution_stats_ = (CheckHasBit(cached_has_bits, 0x00000010U))
                ? ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.solution_stats_)
                : nullptr;
  _impl_.original_problem_stats_ = (CheckHasBit(cached_has_bits, 0x00000020U))
                ? ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.original_problem_stats_)
                : nullptr;
  _impl_.preprocessed_problem_stats_ = (CheckHasBit(cached_has_bits, 0x00000040U))
                ? ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.preprocessed_problem_stats_)
                : nullptr;
  _impl_.params_ = (CheckHasBit(cached_has_bits, 0x00000080U))
                ? ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.params_)
                : nullptr;
  ::memcpy(reinterpret_cast<char*>(&_impl_) +
               offsetof(Impl_, termination_reason_),
           reinterpret_cast<const char*>(&from._impl_) +
               offsetof(Impl_, termination_reason_),
           offsetof(Impl_, solution_type_) -
               offsetof(Impl_, termination_reason_) +
               sizeof(Impl_::solution_type_));
 
  // @@protoc_insertion_point(copy_constructor:operations_research.pdlp.SolveLog)
}
PROTOBUF_NDEBUG_INLINE SolveLog::Impl_::Impl_(
    [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility,
    [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena)
      : _cached_size_{0},
        iteration_stats_{visibility, arena},
        feasibility_polishing_details_{visibility, arena},
        instance_name_(arena),
        termination_string_(arena) {}
 
inline void SolveLog::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) {
  new (&_impl_) Impl_(internal_visibility(), arena);
  ::memset(reinterpret_cast<char*>(&_impl_) +
               offsetof(Impl_, solution_stats_),
           0,
           offsetof(Impl_, solution_type_) -
               offsetof(Impl_, solution_stats_) +
               sizeof(Impl_::solution_type_));
}
SolveLog::~SolveLog() {
  // @@protoc_insertion_point(destructor:operations_research.pdlp.SolveLog)
  SharedDtor(*this);
}
inline void SolveLog::SharedDtor(MessageLite& self) {
  SolveLog& this_ = static_cast<SolveLog&>(self);
  if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) {
    this_.CheckHasBitConsistency();
  }
  this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>();
  ABSL_DCHECK(this_.GetArena() == nullptr);
  this_._impl_.instance_name_.Destroy();
  this_._impl_.termination_string_.Destroy();
  delete this_._impl_.solution_stats_;
  delete this_._impl_.original_problem_stats_;
  delete this_._impl_.preprocessed_problem_stats_;
  delete this_._impl_.params_;
  this_._impl_.~Impl_();
}
 
inline void* PROTOBUF_NONNULL SolveLog::PlacementNew_(
    const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem,
    ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) {
  return ::new (mem) SolveLog(arena);
}
constexpr auto SolveLog::InternalNewImpl_() {
  constexpr auto arena_bits = ::google::protobuf::internal::EncodePlacementArenaOffsets({
      PROTOBUF_FIELD_OFFSET(SolveLog, _impl_.iteration_stats_) +
          decltype(SolveLog::_impl_.iteration_stats_)::
              InternalGetArenaOffset(
                  ::google::protobuf::Message::internal_visibility()),
      PROTOBUF_FIELD_OFFSET(SolveLog, _impl_.feasibility_polishing_details_) +
          decltype(SolveLog::_impl_.feasibility_polishing_details_)::
              InternalGetArenaOffset(
                  ::google::protobuf::Message::internal_visibility()),
  });
  if (arena_bits.has_value()) {
    return ::google::protobuf::internal::MessageCreator::CopyInit(
        sizeof(SolveLog), alignof(SolveLog), *arena_bits);
  } else {
    return ::google::protobuf::internal::MessageCreator(&SolveLog::PlacementNew_,
                                 sizeof(SolveLog),
                                 alignof(SolveLog));
  }
}
constexpr auto SolveLog::InternalGenerateClassData_() {
  return ::google::protobuf::internal::ClassDataFull{
      ::google::protobuf::internal::ClassData{
          &_SolveLog_default_instance_._instance,
          &_table_.header,
          nullptr,  // OnDemandRegisterArenaDtor
          nullptr,  // IsInitialized
          &SolveLog::MergeImpl,
          ::google::protobuf::Message::GetNewImpl<SolveLog>(),
#if defined(PROTOBUF_CUSTOM_VTABLE)
          &SolveLog::SharedDtor,
          ::google::protobuf::Message::GetClearImpl<SolveLog>(), &SolveLog::ByteSizeLong,
              &SolveLog::_InternalSerialize,
#endif  // PROTOBUF_CUSTOM_VTABLE
          PROTOBUF_FIELD_OFFSET(SolveLog, _impl_._cached_size_),
          false,
      },
      &SolveLog::kDescriptorMethods,
      &descriptor_table_ortools_2fpdlp_2fsolve_5flog_2eproto,
      nullptr,  // tracker
  };
}
 
PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const
    ::google::protobuf::internal::ClassDataFull SolveLog_class_data_ =
        SolveLog::InternalGenerateClassData_();
 
PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL
SolveLog::GetClassData() const {
  ::google::protobuf::internal::PrefetchToLocalCache(&SolveLog_class_data_);
  ::google::protobuf::internal::PrefetchToLocalCache(SolveLog_class_data_.tc_table);
  return SolveLog_class_data_.base();
}
PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1
const ::_pbi::TcParseTable<4, 13, 8, 0, 2>
SolveLog::_table_ = {
  {
    PROTOBUF_FIELD_OFFSET(SolveLog, _impl_._has_bits_),
    0, // no _extensions_
    15, 120,  // max_field_number, fast_idx_mask
    offsetof(decltype(_table_), field_lookup_table),
    4294934786,  // skipmap
    offsetof(decltype(_table_), field_entries),
    13,  // num_field_entries
    8,  // num_aux_entries
    offsetof(decltype(_table_), aux_entries),
    SolveLog_class_data_.base(),
    nullptr,  // post_loop_handler
    ::_pbi::TcParser::GenericFallback,  // fallback
    #ifdef PROTOBUF_PREFETCH_PARSE_TABLE
    ::_pbi::TcParser::GetTable<::operations_research::pdlp::SolveLog>(),  // to_prefetch
    #endif  // PROTOBUF_PREFETCH_PARSE_TABLE
  }, {{
    {::_pbi::TcParser::MiniParse, {}},
    // optional string instance_name = 1;
    {::_pbi::TcParser::FastBS1,
     {10, 2, 0,
      PROTOBUF_FIELD_OFFSET(SolveLog, _impl_.instance_name_)}},
    {::_pbi::TcParser::MiniParse, {}},
    // optional .operations_research.pdlp.TerminationReason termination_reason = 3;
    {::_pbi::TcParser::FastEr0S1,
     {24, 8, 13,
      PROTOBUF_FIELD_OFFSET(SolveLog, _impl_.termination_reason_)}},
    // optional string termination_string = 4;
    {::_pbi::TcParser::FastBS1,
     {34, 3, 0,
      PROTOBUF_FIELD_OFFSET(SolveLog, _impl_.termination_string_)}},
    // optional int32 iteration_count = 5;
    {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(SolveLog, _impl_.iteration_count_), 9>(),
     {40, 9, 0,
      PROTOBUF_FIELD_OFFSET(SolveLog, _impl_.iteration_count_)}},
    // optional double solve_time_sec = 6;
    {::_pbi::TcParser::FastF64S1,
     {49, 10, 0,
      PROTOBUF_FIELD_OFFSET(SolveLog, _impl_.solve_time_sec_)}},
    // repeated .operations_research.pdlp.IterationStats iteration_stats = 7;
    {::_pbi::TcParser::FastMtR1,
     {58, 0, 0,
      PROTOBUF_FIELD_OFFSET(SolveLog, _impl_.iteration_stats_)}},
    // optional .operations_research.pdlp.IterationStats solution_stats = 8;
    {::_pbi::TcParser::FastMtS1,
     {66, 4, 1,
      PROTOBUF_FIELD_OFFSET(SolveLog, _impl_.solution_stats_)}},
    {::_pbi::TcParser::MiniParse, {}},
    // optional .operations_research.pdlp.PointType solution_type = 10;
    {::_pbi::TcParser::FastEr0S1,
     {80, 12, 6,
      PROTOBUF_FIELD_OFFSET(SolveLog, _impl_.solution_type_)}},
    // optional .operations_research.pdlp.QuadraticProgramStats original_problem_stats = 11;
    {::_pbi::TcParser::FastMtS1,
     {90, 5, 2,
      PROTOBUF_FIELD_OFFSET(SolveLog, _impl_.original_problem_stats_)}},
    // optional .operations_research.pdlp.QuadraticProgramStats preprocessed_problem_stats = 12;
    {::_pbi::TcParser::FastMtS1,
     {98, 6, 3,
      PROTOBUF_FIELD_OFFSET(SolveLog, _impl_.preprocessed_problem_stats_)}},
    // optional double preprocessing_time_sec = 13;
    {::_pbi::TcParser::FastF64S1,
     {105, 11, 0,
      PROTOBUF_FIELD_OFFSET(SolveLog, _impl_.preprocessing_time_sec_)}},
    // optional .operations_research.pdlp.PrimalDualHybridGradientParams params = 14;
    {::_pbi::TcParser::FastMtS1,
     {114, 7, 4,
      PROTOBUF_FIELD_OFFSET(SolveLog, _impl_.params_)}},
    // repeated .operations_research.pdlp.FeasibilityPolishingDetails feasibility_polishing_details = 15;
    {::_pbi::TcParser::FastMtR1,
     {122, 1, 5,
      PROTOBUF_FIELD_OFFSET(SolveLog, _impl_.feasibility_polishing_details_)}},
  }}, {{
    65535, 65535
  }}, {{
    // optional string instance_name = 1;
    {PROTOBUF_FIELD_OFFSET(SolveLog, _impl_.instance_name_), _Internal::kHasBitsOffset + 2, 0, (0 | ::_fl::kFcOptional | ::_fl::kBytes | ::_fl::kRepAString)},
    // optional .operations_research.pdlp.TerminationReason termination_reason = 3;
    {PROTOBUF_FIELD_OFFSET(SolveLog, _impl_.termination_reason_), _Internal::kHasBitsOffset + 8, 6, (0 | ::_fl::kFcOptional | ::_fl::kEnumRange)},
    // optional string termination_string = 4;
    {PROTOBUF_FIELD_OFFSET(SolveLog, _impl_.termination_string_), _Internal::kHasBitsOffset + 3, 0, (0 | ::_fl::kFcOptional | ::_fl::kBytes | ::_fl::kRepAString)},
    // optional int32 iteration_count = 5;
    {PROTOBUF_FIELD_OFFSET(SolveLog, _impl_.iteration_count_), _Internal::kHasBitsOffset + 9, 0, (0 | ::_fl::kFcOptional | ::_fl::kInt32)},
    // optional double solve_time_sec = 6;
    {PROTOBUF_FIELD_OFFSET(SolveLog, _impl_.solve_time_sec_), _Internal::kHasBitsOffset + 10, 0, (0 | ::_fl::kFcOptional | ::_fl::kDouble)},
    // repeated .operations_research.pdlp.IterationStats iteration_stats = 7;
    {PROTOBUF_FIELD_OFFSET(SolveLog, _impl_.iteration_stats_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcRepeated | ::_fl::kMessage | ::_fl::kTvTable)},
    // optional .operations_research.pdlp.IterationStats solution_stats = 8;
    {PROTOBUF_FIELD_OFFSET(SolveLog, _impl_.solution_stats_), _Internal::kHasBitsOffset + 4, 1, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)},
    // optional .operations_research.pdlp.PointType solution_type = 10;
    {PROTOBUF_FIELD_OFFSET(SolveLog, _impl_.solution_type_), _Internal::kHasBitsOffset + 12, 7, (0 | ::_fl::kFcOptional | ::_fl::kEnumRange)},
    // optional .operations_research.pdlp.QuadraticProgramStats original_problem_stats = 11;
    {PROTOBUF_FIELD_OFFSET(SolveLog, _impl_.original_problem_stats_), _Internal::kHasBitsOffset + 5, 2, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)},
    // optional .operations_research.pdlp.QuadraticProgramStats preprocessed_problem_stats = 12;
    {PROTOBUF_FIELD_OFFSET(SolveLog, _impl_.preprocessed_problem_stats_), _Internal::kHasBitsOffset + 6, 3, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)},
    // optional double preprocessing_time_sec = 13;
    {PROTOBUF_FIELD_OFFSET(SolveLog, _impl_.preprocessing_time_sec_), _Internal::kHasBitsOffset + 11, 0, (0 | ::_fl::kFcOptional | ::_fl::kDouble)},
    // optional .operations_research.pdlp.PrimalDualHybridGradientParams params = 14;
    {PROTOBUF_FIELD_OFFSET(SolveLog, _impl_.params_), _Internal::kHasBitsOffset + 7, 4, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)},
    // repeated .operations_research.pdlp.FeasibilityPolishingDetails feasibility_polishing_details = 15;
    {PROTOBUF_FIELD_OFFSET(SolveLog, _impl_.feasibility_polishing_details_), _Internal::kHasBitsOffset + 1, 5, (0 | ::_fl::kFcRepeated | ::_fl::kMessage | ::_fl::kTvTable)},
  }},
  {{
      {::_pbi::TcParser::GetTable<::operations_research::pdlp::IterationStats>()},
      {::_pbi::TcParser::GetTable<::operations_research::pdlp::IterationStats>()},
      {::_pbi::TcParser::GetTable<::operations_research::pdlp::QuadraticProgramStats>()},
      {::_pbi::TcParser::GetTable<::operations_research::pdlp::QuadraticProgramStats>()},
      {::_pbi::TcParser::GetTable<::operations_research::pdlp::PrimalDualHybridGradientParams>()},
      {::_pbi::TcParser::GetTable<::operations_research::pdlp::FeasibilityPolishingDetails>()},
      {0, 13},
      {0, 6},
  }},
  {{
  }},
};
PROTOBUF_NOINLINE void SolveLog::Clear() {
// @@protoc_insertion_point(message_clear_start:operations_research.pdlp.SolveLog)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void) cached_has_bits;
 
  cached_has_bits = _impl_._has_bits_[0];
  if (BatchCheckHasBit(cached_has_bits, 0x000000ffU)) {
    if (CheckHasBitForRepeated(cached_has_bits, 0x00000001U)) {
      _impl_.iteration_stats_.Clear();
    }
    if (CheckHasBitForRepeated(cached_has_bits, 0x00000002U)) {
      _impl_.feasibility_polishing_details_.Clear();
    }
    if (CheckHasBit(cached_has_bits, 0x00000004U)) {
      _impl_.instance_name_.ClearNonDefaultToEmpty();
    }
    if (CheckHasBit(cached_has_bits, 0x00000008U)) {
      _impl_.termination_string_.ClearNonDefaultToEmpty();
    }
    if (CheckHasBit(cached_has_bits, 0x00000010U)) {
      ABSL_DCHECK(_impl_.solution_stats_ != nullptr);
      _impl_.solution_stats_->Clear();
    }
    if (CheckHasBit(cached_has_bits, 0x00000020U)) {
      ABSL_DCHECK(_impl_.original_problem_stats_ != nullptr);
      _impl_.original_problem_stats_->Clear();
    }
    if (CheckHasBit(cached_has_bits, 0x00000040U)) {
      ABSL_DCHECK(_impl_.preprocessed_problem_stats_ != nullptr);
      _impl_.preprocessed_problem_stats_->Clear();
    }
    if (CheckHasBit(cached_has_bits, 0x00000080U)) {
      ABSL_DCHECK(_impl_.params_ != nullptr);
      _impl_.params_->Clear();
    }
  }
  if (BatchCheckHasBit(cached_has_bits, 0x00001f00U)) {
    ::memset(&_impl_.termination_reason_, 0, static_cast<::size_t>(
        reinterpret_cast<char*>(&_impl_.solution_type_) -
        reinterpret_cast<char*>(&_impl_.termination_reason_)) + sizeof(_impl_.solution_type_));
  }
  _impl_._has_bits_.Clear();
  _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>();
}
 
#if defined(PROTOBUF_CUSTOM_VTABLE)
::uint8_t* PROTOBUF_NONNULL SolveLog::_InternalSerialize(
    const ::google::protobuf::MessageLite& base, ::uint8_t* PROTOBUF_NONNULL target,
    ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) {
  const SolveLog& this_ = static_cast<const SolveLog&>(base);
#else   // PROTOBUF_CUSTOM_VTABLE
::uint8_t* PROTOBUF_NONNULL SolveLog::_InternalSerialize(
    ::uint8_t* PROTOBUF_NONNULL target,
    ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const {
  const SolveLog& this_ = *this;
#endif  // PROTOBUF_CUSTOM_VTABLE
  if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) {
    this_.CheckHasBitConsistency();
  }
  // @@protoc_insertion_point(serialize_to_array_start:operations_research.pdlp.SolveLog)
  ::uint32_t cached_has_bits = 0;
  (void)cached_has_bits;
 
  cached_has_bits = this_._impl_._has_bits_[0];
  // optional string instance_name = 1;
  if (CheckHasBit(cached_has_bits, 0x00000004U)) {
    const ::std::string& _s = this_._internal_instance_name();
    target = stream->WriteStringMaybeAliased(1, _s, target);
  }
 
  // optional .operations_research.pdlp.TerminationReason termination_reason = 3;
  if (CheckHasBit(cached_has_bits, 0x00000100U)) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteEnumToArray(
        3, this_._internal_termination_reason(), target);
  }
 
  // optional string termination_string = 4;
  if (CheckHasBit(cached_has_bits, 0x00000008U)) {
    const ::std::string& _s = this_._internal_termination_string();
    target = stream->WriteStringMaybeAliased(4, _s, target);
  }
 
  // optional int32 iteration_count = 5;
  if (CheckHasBit(cached_has_bits, 0x00000200U)) {
    target =
        ::google::protobuf::internal::WireFormatLite::WriteInt32ToArrayWithField<5>(
            stream, this_._internal_iteration_count(), target);
  }
 
  // optional double solve_time_sec = 6;
  if (CheckHasBit(cached_has_bits, 0x00000400U)) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteDoubleToArray(
        6, this_._internal_solve_time_sec(), target);
  }
 
  // repeated .operations_research.pdlp.IterationStats iteration_stats = 7;
  if (CheckHasBitForRepeated(cached_has_bits, 0x00000001U)) {
    for (unsigned i = 0, n = static_cast<unsigned>(
                             this_._internal_iteration_stats_size());
         i < n; i++) {
      const auto& repfield = this_._internal_iteration_stats().Get(i);
      target =
          ::google::protobuf::internal::WireFormatLite::InternalWriteMessage(
              7, repfield, repfield.GetCachedSize(),
              target, stream);
    }
  }
 
  // optional .operations_research.pdlp.IterationStats solution_stats = 8;
  if (CheckHasBit(cached_has_bits, 0x00000010U)) {
    target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage(
        8, *this_._impl_.solution_stats_, this_._impl_.solution_stats_->GetCachedSize(), target,
        stream);
  }
 
  // optional .operations_research.pdlp.PointType solution_type = 10;
  if (CheckHasBit(cached_has_bits, 0x00001000U)) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteEnumToArray(
        10, this_._internal_solution_type(), target);
  }
 
  // optional .operations_research.pdlp.QuadraticProgramStats original_problem_stats = 11;
  if (CheckHasBit(cached_has_bits, 0x00000020U)) {
    target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage(
        11, *this_._impl_.original_problem_stats_, this_._impl_.original_problem_stats_->GetCachedSize(), target,
        stream);
  }
 
  // optional .operations_research.pdlp.QuadraticProgramStats preprocessed_problem_stats = 12;
  if (CheckHasBit(cached_has_bits, 0x00000040U)) {
    target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage(
        12, *this_._impl_.preprocessed_problem_stats_, this_._impl_.preprocessed_problem_stats_->GetCachedSize(), target,
        stream);
  }
 
  // optional double preprocessing_time_sec = 13;
  if (CheckHasBit(cached_has_bits, 0x00000800U)) {
    target = stream->EnsureSpace(target);
    target = ::_pbi::WireFormatLite::WriteDoubleToArray(
        13, this_._internal_preprocessing_time_sec(), target);
  }
 
  // optional .operations_research.pdlp.PrimalDualHybridGradientParams params = 14;
  if (CheckHasBit(cached_has_bits, 0x00000080U)) {
    target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage(
        14, *this_._impl_.params_, this_._impl_.params_->GetCachedSize(), target,
        stream);
  }
 
  // repeated .operations_research.pdlp.FeasibilityPolishingDetails feasibility_polishing_details = 15;
  if (CheckHasBitForRepeated(cached_has_bits, 0x00000002U)) {
    for (unsigned i = 0, n = static_cast<unsigned>(
                             this_._internal_feasibility_polishing_details_size());
         i < n; i++) {
      const auto& repfield = this_._internal_feasibility_polishing_details().Get(i);
      target =
          ::google::protobuf::internal::WireFormatLite::InternalWriteMessage(
              15, repfield, repfield.GetCachedSize(),
              target, stream);
    }
  }
 
  if (ABSL_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) {
    target =
        ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray(
            this_._internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream);
  }
  // @@protoc_insertion_point(serialize_to_array_end:operations_research.pdlp.SolveLog)
  return target;
}
 
#if defined(PROTOBUF_CUSTOM_VTABLE)
::size_t SolveLog::ByteSizeLong(const MessageLite& base) {
  const SolveLog& this_ = static_cast<const SolveLog&>(base);
#else   // PROTOBUF_CUSTOM_VTABLE
::size_t SolveLog::ByteSizeLong() const {
  const SolveLog& this_ = *this;
#endif  // PROTOBUF_CUSTOM_VTABLE
  // @@protoc_insertion_point(message_byte_size_start:operations_research.pdlp.SolveLog)
  ::size_t total_size = 0;
 
  ::uint32_t cached_has_bits = 0;
  // Prevent compiler warnings about cached_has_bits being unused
  (void)cached_has_bits;
 
  ::_pbi::Prefetch5LinesFrom7Lines(&this_);
  cached_has_bits = this_._impl_._has_bits_[0];
  total_size += ::absl::popcount(0x00000c00U & cached_has_bits) * 9;
  if (BatchCheckHasBit(cached_has_bits, 0x000000ffU)) {
    // repeated .operations_research.pdlp.IterationStats iteration_stats = 7;
    if (CheckHasBitForRepeated(cached_has_bits, 0x00000001U)) {
      total_size += 1UL * this_._internal_iteration_stats_size();
      for (const auto& msg : this_._internal_iteration_stats()) {
        total_size += ::google::protobuf::internal::WireFormatLite::MessageSize(msg);
      }
    }
    // repeated .operations_research.pdlp.FeasibilityPolishingDetails feasibility_polishing_details = 15;
    if (CheckHasBitForRepeated(cached_has_bits, 0x00000002U)) {
      total_size += 1UL * this_._internal_feasibility_polishing_details_size();
      for (const auto& msg : this_._internal_feasibility_polishing_details()) {
        total_size += ::google::protobuf::internal::WireFormatLite::MessageSize(msg);
      }
    }
    // optional string instance_name = 1;
    if (CheckHasBit(cached_has_bits, 0x00000004U)) {
      total_size += 1 + ::google::protobuf::internal::WireFormatLite::StringSize(
                                      this_._internal_instance_name());
    }
    // optional string termination_string = 4;
    if (CheckHasBit(cached_has_bits, 0x00000008U)) {
      total_size += 1 + ::google::protobuf::internal::WireFormatLite::StringSize(
                                      this_._internal_termination_string());
    }
    // optional .operations_research.pdlp.IterationStats solution_stats = 8;
    if (CheckHasBit(cached_has_bits, 0x00000010U)) {
      total_size += 1 +
                    ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.solution_stats_);
    }
    // optional .operations_research.pdlp.QuadraticProgramStats original_problem_stats = 11;
    if (CheckHasBit(cached_has_bits, 0x00000020U)) {
      total_size += 1 +
                    ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.original_problem_stats_);
    }
    // optional .operations_research.pdlp.QuadraticProgramStats preprocessed_problem_stats = 12;
    if (CheckHasBit(cached_has_bits, 0x00000040U)) {
      total_size += 1 +
                    ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.preprocessed_problem_stats_);
    }
    // optional .operations_research.pdlp.PrimalDualHybridGradientParams params = 14;
    if (CheckHasBit(cached_has_bits, 0x00000080U)) {
      total_size += 1 +
                    ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.params_);
    }
  }
  if (BatchCheckHasBit(cached_has_bits, 0x00001300U)) {
    // optional .operations_research.pdlp.TerminationReason termination_reason = 3;
    if (CheckHasBit(cached_has_bits, 0x00000100U)) {
      total_size += 1 +
                    ::_pbi::WireFormatLite::EnumSize(this_._internal_termination_reason());
    }
    // optional int32 iteration_count = 5;
    if (CheckHasBit(cached_has_bits, 0x00000200U)) {
      total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(
          this_._internal_iteration_count());
    }
    // optional .operations_research.pdlp.PointType solution_type = 10;
    if (CheckHasBit(cached_has_bits, 0x00001000U)) {
      total_size += 1 +
                    ::_pbi::WireFormatLite::EnumSize(this_._internal_solution_type());
    }
  }
  return this_.MaybeComputeUnknownFieldsSize(total_size,
                                             &this_._impl_._cached_size_);
}
 
void SolveLog::MergeImpl(::google::protobuf::MessageLite& to_msg,
                            const ::google::protobuf::MessageLite& from_msg) {
   auto* const _this =
      static_cast<SolveLog*>(&to_msg);
  auto& from = static_cast<const SolveLog&>(from_msg);
  if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) {
    from.CheckHasBitConsistency();
  }
  ::google::protobuf::Arena* arena = _this->GetArena();
  // @@protoc_insertion_point(class_specific_merge_from_start:operations_research.pdlp.SolveLog)
  ABSL_DCHECK_NE(&from, _this);
  ::uint32_t cached_has_bits = 0;
  (void)cached_has_bits;
 
  cached_has_bits = from._impl_._has_bits_[0];
  if (BatchCheckHasBit(cached_has_bits, 0x000000ffU)) {
    if (CheckHasBitForRepeated(cached_has_bits, 0x00000001U)) {
      _this->_internal_mutable_iteration_stats()->InternalMergeFromWithArena(
          ::google::protobuf::MessageLite::internal_visibility(), arena,
          from._internal_iteration_stats());
    }
    if (CheckHasBitForRepeated(cached_has_bits, 0x00000002U)) {
      _this->_internal_mutable_feasibility_polishing_details()->InternalMergeFromWithArena(
          ::google::protobuf::MessageLite::internal_visibility(), arena,
          from._internal_feasibility_polishing_details());
    }
    if (CheckHasBit(cached_has_bits, 0x00000004U)) {
      _this->_internal_set_instance_name(from._internal_instance_name());
    }
    if (CheckHasBit(cached_has_bits, 0x00000008U)) {
      _this->_internal_set_termination_string(from._internal_termination_string());
    }
    if (CheckHasBit(cached_has_bits, 0x00000010U)) {
      ABSL_DCHECK(from._impl_.solution_stats_ != nullptr);
      if (_this->_impl_.solution_stats_ == nullptr) {
        _this->_impl_.solution_stats_ = ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.solution_stats_);
      } else {
        _this->_impl_.solution_stats_->MergeFrom(*from._impl_.solution_stats_);
      }
    }
    if (CheckHasBit(cached_has_bits, 0x00000020U)) {
      ABSL_DCHECK(from._impl_.original_problem_stats_ != nullptr);
      if (_this->_impl_.original_problem_stats_ == nullptr) {
        _this->_impl_.original_problem_stats_ = ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.original_problem_stats_);
      } else {
        _this->_impl_.original_problem_stats_->MergeFrom(*from._impl_.original_problem_stats_);
      }
    }
    if (CheckHasBit(cached_has_bits, 0x00000040U)) {
      ABSL_DCHECK(from._impl_.preprocessed_problem_stats_ != nullptr);
      if (_this->_impl_.preprocessed_problem_stats_ == nullptr) {
        _this->_impl_.preprocessed_problem_stats_ = ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.preprocessed_problem_stats_);
      } else {
        _this->_impl_.preprocessed_problem_stats_->MergeFrom(*from._impl_.preprocessed_problem_stats_);
      }
    }
    if (CheckHasBit(cached_has_bits, 0x00000080U)) {
      ABSL_DCHECK(from._impl_.params_ != nullptr);
      if (_this->_impl_.params_ == nullptr) {
        _this->_impl_.params_ = ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.params_);
      } else {
        _this->_impl_.params_->MergeFrom(*from._impl_.params_);
      }
    }
  }
  if (BatchCheckHasBit(cached_has_bits, 0x00001f00U)) {
    if (CheckHasBit(cached_has_bits, 0x00000100U)) {
      _this->_impl_.termination_reason_ = from._impl_.termination_reason_;
    }
    if (CheckHasBit(cached_has_bits, 0x00000200U)) {
      _this->_impl_.iteration_count_ = from._impl_.iteration_count_;
    }
    if (CheckHasBit(cached_has_bits, 0x00000400U)) {
      _this->_impl_.solve_time_sec_ = from._impl_.solve_time_sec_;
    }
    if (CheckHasBit(cached_has_bits, 0x00000800U)) {
      _this->_impl_.preprocessing_time_sec_ = from._impl_.preprocessing_time_sec_;
    }
    if (CheckHasBit(cached_has_bits, 0x00001000U)) {
      _this->_impl_.solution_type_ = from._impl_.solution_type_;
    }
  }
  _this->_impl_._has_bits_[0] |= cached_has_bits;
  _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>(
      from._internal_metadata_);
}
 
void SolveLog::CopyFrom(const SolveLog& from) {
  // @@protoc_insertion_point(class_specific_copy_from_start:operations_research.pdlp.SolveLog)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}
 
 
void SolveLog::InternalSwap(SolveLog* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) {
  using ::std::swap;
  auto* arena = GetArena();
  ABSL_DCHECK_EQ(arena, other->GetArena());
  _internal_metadata_.InternalSwap(&other->_internal_metadata_);
  swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
  _impl_.iteration_stats_.InternalSwap(&other->_impl_.iteration_stats_);
  _impl_.feasibility_polishing_details_.InternalSwap(&other->_impl_.feasibility_polishing_details_);
  ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.instance_name_, &other->_impl_.instance_name_, arena);
  ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.termination_string_, &other->_impl_.termination_string_, arena);
  ::google::protobuf::internal::memswap<
      PROTOBUF_FIELD_OFFSET(SolveLog, _impl_.solution_type_)
      + sizeof(SolveLog::_impl_.solution_type_)
      - PROTOBUF_FIELD_OFFSET(SolveLog, _impl_.solution_stats_)>(
          reinterpret_cast<char*>(&_impl_.solution_stats_),
          reinterpret_cast<char*>(&other->_impl_.solution_stats_));
}
 
::google::protobuf::Metadata SolveLog::GetMetadata() const {
  return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full());
}
// @@protoc_insertion_point(namespace_scope)
}  // namespace pdlp
}  // namespace operations_research
namespace google {
namespace protobuf {
}  // namespace protobuf
}  // namespace google
// @@protoc_insertion_point(global_scope)
PROTOBUF_ATTRIBUTE_INIT_PRIORITY2 static ::std::false_type
    _static_init2_ [[maybe_unused]] =
        (::_pbi::AddDescriptors(&descriptor_table_ortools_2fpdlp_2fsolve_5flog_2eproto),
         ::std::false_type{});
#include "google/protobuf/port_undef.inc"