/* automatically generated by rust-bindgen 0.71.1 */

pub type HighsInt = ::std::os::raw::c_int;
#[doc = " Struct to handle callback output data\n"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct HighsCallbackDataOut {
    pub cbdata: *mut ::std::os::raw::c_void,
    pub log_type: ::std::os::raw::c_int,
    pub running_time: f64,
    pub simplex_iteration_count: HighsInt,
    pub ipm_iteration_count: HighsInt,
    pub pdlp_iteration_count: HighsInt,
    pub objective_function_value: f64,
    pub mip_node_count: i64,
    pub mip_total_lp_iterations: i64,
    pub mip_primal_bound: f64,
    pub mip_dual_bound: f64,
    pub mip_gap: f64,
    pub mip_solution: *mut f64,
    pub mip_solution_size: HighsInt,
    pub cutpool_num_col: HighsInt,
    pub cutpool_num_cut: HighsInt,
    pub cutpool_num_nz: HighsInt,
    pub cutpool_start: *mut HighsInt,
    pub cutpool_index: *mut HighsInt,
    pub cutpool_value: *mut f64,
    pub cutpool_lower: *mut f64,
    pub cutpool_upper: *mut f64,
    pub user_solution_callback_origin: HighsInt,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of HighsCallbackDataOut"][::std::mem::size_of::<HighsCallbackDataOut>() - 160usize];
    ["Alignment of HighsCallbackDataOut"][::std::mem::align_of::<HighsCallbackDataOut>() - 8usize];
    ["Offset of field: HighsCallbackDataOut::cbdata"]
        [::std::mem::offset_of!(HighsCallbackDataOut, cbdata) - 0usize];
    ["Offset of field: HighsCallbackDataOut::log_type"]
        [::std::mem::offset_of!(HighsCallbackDataOut, log_type) - 8usize];
    ["Offset of field: HighsCallbackDataOut::running_time"]
        [::std::mem::offset_of!(HighsCallbackDataOut, running_time) - 16usize];
    ["Offset of field: HighsCallbackDataOut::simplex_iteration_count"]
        [::std::mem::offset_of!(HighsCallbackDataOut, simplex_iteration_count) - 24usize];
    ["Offset of field: HighsCallbackDataOut::ipm_iteration_count"]
        [::std::mem::offset_of!(HighsCallbackDataOut, ipm_iteration_count) - 28usize];
    ["Offset of field: HighsCallbackDataOut::pdlp_iteration_count"]
        [::std::mem::offset_of!(HighsCallbackDataOut, pdlp_iteration_count) - 32usize];
    ["Offset of field: HighsCallbackDataOut::objective_function_value"]
        [::std::mem::offset_of!(HighsCallbackDataOut, objective_function_value) - 40usize];
    ["Offset of field: HighsCallbackDataOut::mip_node_count"]
        [::std::mem::offset_of!(HighsCallbackDataOut, mip_node_count) - 48usize];
    ["Offset of field: HighsCallbackDataOut::mip_total_lp_iterations"]
        [::std::mem::offset_of!(HighsCallbackDataOut, mip_total_lp_iterations) - 56usize];
    ["Offset of field: HighsCallbackDataOut::mip_primal_bound"]
        [::std::mem::offset_of!(HighsCallbackDataOut, mip_primal_bound) - 64usize];
    ["Offset of field: HighsCallbackDataOut::mip_dual_bound"]
        [::std::mem::offset_of!(HighsCallbackDataOut, mip_dual_bound) - 72usize];
    ["Offset of field: HighsCallbackDataOut::mip_gap"]
        [::std::mem::offset_of!(HighsCallbackDataOut, mip_gap) - 80usize];
    ["Offset of field: HighsCallbackDataOut::mip_solution"]
        [::std::mem::offset_of!(HighsCallbackDataOut, mip_solution) - 88usize];
    ["Offset of field: HighsCallbackDataOut::mip_solution_size"]
        [::std::mem::offset_of!(HighsCallbackDataOut, mip_solution_size) - 96usize];
    ["Offset of field: HighsCallbackDataOut::cutpool_num_col"]
        [::std::mem::offset_of!(HighsCallbackDataOut, cutpool_num_col) - 100usize];
    ["Offset of field: HighsCallbackDataOut::cutpool_num_cut"]
        [::std::mem::offset_of!(HighsCallbackDataOut, cutpool_num_cut) - 104usize];
    ["Offset of field: HighsCallbackDataOut::cutpool_num_nz"]
        [::std::mem::offset_of!(HighsCallbackDataOut, cutpool_num_nz) - 108usize];
    ["Offset of field: HighsCallbackDataOut::cutpool_start"]
        [::std::mem::offset_of!(HighsCallbackDataOut, cutpool_start) - 112usize];
    ["Offset of field: HighsCallbackDataOut::cutpool_index"]
        [::std::mem::offset_of!(HighsCallbackDataOut, cutpool_index) - 120usize];
    ["Offset of field: HighsCallbackDataOut::cutpool_value"]
        [::std::mem::offset_of!(HighsCallbackDataOut, cutpool_value) - 128usize];
    ["Offset of field: HighsCallbackDataOut::cutpool_lower"]
        [::std::mem::offset_of!(HighsCallbackDataOut, cutpool_lower) - 136usize];
    ["Offset of field: HighsCallbackDataOut::cutpool_upper"]
        [::std::mem::offset_of!(HighsCallbackDataOut, cutpool_upper) - 144usize];
    ["Offset of field: HighsCallbackDataOut::user_solution_callback_origin"]
        [::std::mem::offset_of!(HighsCallbackDataOut, user_solution_callback_origin) - 152usize];
};
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct HighsCallbackDataIn {
    pub user_interrupt: ::std::os::raw::c_int,
    pub user_solution: *mut f64,
    pub cbdata: *mut ::std::os::raw::c_void,
    pub user_has_solution: ::std::os::raw::c_int,
    pub user_solution_size: HighsInt,
}
#[allow(clippy::unnecessary_operation, clippy::identity_op)]
const _: () = {
    ["Size of HighsCallbackDataIn"][::std::mem::size_of::<HighsCallbackDataIn>() - 32usize];
    ["Alignment of HighsCallbackDataIn"][::std::mem::align_of::<HighsCallbackDataIn>() - 8usize];
    ["Offset of field: HighsCallbackDataIn::user_interrupt"]
        [::std::mem::offset_of!(HighsCallbackDataIn, user_interrupt) - 0usize];
    ["Offset of field: HighsCallbackDataIn::user_solution"]
        [::std::mem::offset_of!(HighsCallbackDataIn, user_solution) - 8usize];
    ["Offset of field: HighsCallbackDataIn::cbdata"]
        [::std::mem::offset_of!(HighsCallbackDataIn, cbdata) - 16usize];
    ["Offset of field: HighsCallbackDataIn::user_has_solution"]
        [::std::mem::offset_of!(HighsCallbackDataIn, user_has_solution) - 24usize];
    ["Offset of field: HighsCallbackDataIn::user_solution_size"]
        [::std::mem::offset_of!(HighsCallbackDataIn, user_solution_size) - 28usize];
};
pub type HighsCCallbackType = ::std::option::Option<
    unsafe extern "C" fn(
        arg1: ::std::os::raw::c_int,
        arg2: *const ::std::os::raw::c_char,
        arg3: *const HighsCallbackDataOut,
        arg4: *mut HighsCallbackDataIn,
        arg5: *mut ::std::os::raw::c_void,
    ),
>;
unsafe extern "C" {
    #[doc = " Formulate and solve a linear program using HiGHS.\n\n @param num_col   The number of columns.\n @param num_row   The number of rows.\n @param num_nz    The number of nonzeros in the constraint matrix.\n @param a_format  The format of the constraint matrix as a\n                  `kHighsMatrixFormat` constant.\n @param sense     The optimization sense as a `kHighsObjSense` constant.\n @param offset    The objective constant.\n @param col_cost  An array of length [num_col] with the column costs.\n @param col_lower An array of length [num_col] with the column lower bounds.\n @param col_upper An array of length [num_col] with the column upper bounds.\n @param row_lower An array of length [num_row] with the row lower bounds.\n @param row_upper An array of length [num_row] with the row upper bounds.\n @param a_start   The constraint matrix is provided to HiGHS in compressed\n                  sparse column form (if `a_format` is\n                  `kHighsMatrixFormatColwise`, otherwise compressed sparse row\n                  form). The sparse matrix consists of three arrays,\n                  `a_start`, `a_index`, and `a_value`. `a_start` is an array\n                  of length [num_col] containing the starting index of each\n                  column in `a_index`. If `a_format` is\n                  `kHighsMatrixFormatRowwise` the array is of length [num_row]\n                  corresponding to each row.\n @param a_index   An array of length [num_nz] with indices of matrix entries.\n @param a_value   An array of length [num_nz] with values of matrix entries.\n\n @param col_value      An array of length [num_col], to be filled with the\n                       primal column solution.\n @param col_dual       An array of length [num_col], to be filled with the\n                       dual column solution.\n @param row_value      An array of length [num_row], to be filled with the\n                       primal row solution.\n @param row_dual       An array of length [num_row], to be filled with the\n                       dual row solution.\n @param col_basis_status  An array of length [num_col], to be filled with the\n                          basis status of the columns in the form of a\n                          `kHighsBasisStatus` constant.\n @param row_basis_status  An array of length [num_row], to be filled with the\n                          basis status of the rows in the form of a\n                          `kHighsBasisStatus` constant.\n @param model_status      The location in which to place the termination\n                          status of the model after the solve in the form of a\n                          `kHighsModelStatus` constant.\n\n @returns A `kHighsStatus` constant indicating whether the call succeeded."]
    pub fn Highs_lpCall(
        num_col: HighsInt,
        num_row: HighsInt,
        num_nz: HighsInt,
        a_format: HighsInt,
        sense: HighsInt,
        offset: f64,
        col_cost: *const f64,
        col_lower: *const f64,
        col_upper: *const f64,
        row_lower: *const f64,
        row_upper: *const f64,
        a_start: *const HighsInt,
        a_index: *const HighsInt,
        a_value: *const f64,
        col_value: *mut f64,
        col_dual: *mut f64,
        row_value: *mut f64,
        row_dual: *mut f64,
        col_basis_status: *mut HighsInt,
        row_basis_status: *mut HighsInt,
        model_status: *mut HighsInt,
    ) -> HighsInt;
}
unsafe extern "C" {
    #[doc = " Formulate and solve a mixed-integer linear program using HiGHS.\n\n The signature of this method is identical to `Highs_lpCall`, except that it\n has an additional `integrality` argument, and that it is missing the\n `col_dual`, `row_dual`, `col_basis_status` and `row_basis_status` arguments.\n\n @param integrality   An array of length [num_col], containing a\n                      `kHighsVarType` constant for each column.\n\n @returns A `kHighsStatus` constant indicating whether the call succeeded."]
    pub fn Highs_mipCall(
        num_col: HighsInt,
        num_row: HighsInt,
        num_nz: HighsInt,
        a_format: HighsInt,
        sense: HighsInt,
        offset: f64,
        col_cost: *const f64,
        col_lower: *const f64,
        col_upper: *const f64,
        row_lower: *const f64,
        row_upper: *const f64,
        a_start: *const HighsInt,
        a_index: *const HighsInt,
        a_value: *const f64,
        integrality: *const HighsInt,
        col_value: *mut f64,
        row_value: *mut f64,
        model_status: *mut HighsInt,
    ) -> HighsInt;
}
unsafe extern "C" {
    #[doc = " Formulate and solve a quadratic program using HiGHS.\n\n The signature of this method is identical to `Highs_lpCall`, except that it\n has additional arguments for specifying the Hessian matrix.\n\n @param q_num_nz  The number of nonzeros in the Hessian matrix.\n @param q_format  The format of the Hessian matrix in the form of a\n                  `kHighsHessianStatus` constant. If q_num_nz > 0, this must\n                  be `kHighsHessianFormatTriangular`.\n @param q_start   The Hessian matrix is provided to HiGHS as the lower\n                  triangular component in compressed sparse column form\n                  (or, equivalently, as the upper triangular component\n                  in compressed sparse row form). The sparse matrix consists\n                  of three arrays, `q_start`, `q_index`, and `q_value`.\n                  `q_start` is an array of length [num_col].\n @param q_index   An array of length [q_num_nz] with indices of matrix\n                  entries.\n @param q_value   An array of length [q_num_nz] with values of matrix entries.\n\n @returns A `kHighsStatus` constant indicating whether the call succeeded."]
    pub fn Highs_qpCall(
        num_col: HighsInt,
        num_row: HighsInt,
        num_nz: HighsInt,
        q_num_nz: HighsInt,
        a_format: HighsInt,
        q_format: HighsInt,
        sense: HighsInt,
        offset: f64,
        col_cost: *const f64,
        col_lower: *const f64,
        col_upper: *const f64,
        row_lower: *const f64,
        row_upper: *const f64,
        a_start: *const HighsInt,
        a_index: *const HighsInt,
        a_value: *const f64,
        q_start: *const HighsInt,
        q_index: *const HighsInt,
        q_value: *const f64,
        col_value: *mut f64,
        col_dual: *mut f64,
        row_value: *mut f64,
        row_dual: *mut f64,
        col_basis_status: *mut HighsInt,
        row_basis_status: *mut HighsInt,
        model_status: *mut HighsInt,
    ) -> HighsInt;
}
unsafe extern "C" {
    #[doc = " Create a Highs instance and return the reference.\n\n Call `Highs_destroy` on the returned reference to clean up allocated memory.\n\n @returns A pointer to the Highs instance."]
    pub fn Highs_create() -> *mut ::std::os::raw::c_void;
}
unsafe extern "C" {
    #[doc = " Destroy the model `highs` created by `Highs_create` and free all\n corresponding memory. Future calls using `highs` are not allowed.\n\n To empty a model without invalidating `highs`, see `Highs_clearModel`.\n\n @param highs     A pointer to the Highs instance."]
    pub fn Highs_destroy(highs: *mut ::std::os::raw::c_void);
}
unsafe extern "C" {
    #[doc = " Return the HiGHS version number as a string of the form \"vX.Y.Z\".\n\n @returns The HiGHS version as a `char*`."]
    pub fn Highs_version() -> *const ::std::os::raw::c_char;
}
unsafe extern "C" {
    #[doc = " Return the HiGHS major version number.\n\n @returns The HiGHS major version number."]
    pub fn Highs_versionMajor() -> HighsInt;
}
unsafe extern "C" {
    #[doc = " Return the HiGHS minor version number.\n\n @returns The HiGHS minor version number."]
    pub fn Highs_versionMinor() -> HighsInt;
}
unsafe extern "C" {
    #[doc = " Return the HiGHS patch version number.\n\n @returns The HiGHS patch version number."]
    pub fn Highs_versionPatch() -> HighsInt;
}
unsafe extern "C" {
    #[doc = " Return the HiGHS githash.\n\n @returns The HiGHS githash."]
    pub fn Highs_githash() -> *const ::std::os::raw::c_char;
}
unsafe extern "C" {
    #[doc = " Read a model from `filename` into `highs`.\n\n @param highs     A pointer to the Highs instance.\n @param filename  The filename to read.\n\n @returns A `kHighsStatus` constant indicating whether the call succeeded."]
    pub fn Highs_readModel(
        highs: *mut ::std::os::raw::c_void,
        filename: *const ::std::os::raw::c_char,
    ) -> HighsInt;
}
unsafe extern "C" {
    #[doc = " Write the model in `highs` to `filename`.\n\n @param highs     A pointer to the Highs instance.\n @param filename  The filename to write.\n\n @returns A `kHighsStatus` constant indicating whether the call succeeded."]
    pub fn Highs_writeModel(
        highs: *mut ::std::os::raw::c_void,
        filename: *const ::std::os::raw::c_char,
    ) -> HighsInt;
}
unsafe extern "C" {
    #[doc = " Write the presolved model in `highs` to `filename`.\n\n @param highs     A pointer to the Highs instance.\n @param filename  The filename to write.\n\n @returns A `kHighsStatus` constant indicating whether the call succeeded."]
    pub fn Highs_writePresolvedModel(
        highs: *mut ::std::os::raw::c_void,
        filename: *const ::std::os::raw::c_char,
    ) -> HighsInt;
}
unsafe extern "C" {
    #[doc = " Reset the options and then call `clearModel`.\n\n See `Highs_destroy` to free all associated memory.\n\n @param highs     A pointer to the Highs instance.\n\n @returns A `kHighsStatus` constant indicating whether the call succeeded."]
    pub fn Highs_clear(highs: *mut ::std::os::raw::c_void) -> HighsInt;
}
unsafe extern "C" {
    #[doc = " Remove all variables and constraints from the model `highs`, but do not\n invalidate the pointer `highs`. Future calls (for example, adding new\n variables and constraints) are allowed.\n\n @param highs     A pointer to the Highs instance.\n\n @returns A `kHighsStatus` constant indicating whether the call succeeded."]
    pub fn Highs_clearModel(highs: *mut ::std::os::raw::c_void) -> HighsInt;
}
unsafe extern "C" {
    #[doc = " Clear all solution data associated with the model.\n\n See `Highs_destroy` to clear the model and free all associated memory.\n\n @param highs     A pointer to the Highs instance.\n\n @returns A `kHighsStatus` constant indicating whether the call succeeded."]
    pub fn Highs_clearSolver(highs: *mut ::std::os::raw::c_void) -> HighsInt;
}
unsafe extern "C" {
    #[doc = " Presolve a model.\n\n @param highs     A pointer to the Highs instance.\n\n @returns A `kHighsStatus` constant indicating whether the call succeeded."]
    pub fn Highs_presolve(highs: *mut ::std::os::raw::c_void) -> HighsInt;
}
unsafe extern "C" {
    #[doc = " Optimize a model. The algorithm used by HiGHS depends on the options that\n have been set.\n\n @param highs     A pointer to the Highs instance.\n\n @returns A `kHighsStatus` constant indicating whether the call succeeded."]
    pub fn Highs_run(highs: *mut ::std::os::raw::c_void) -> HighsInt;
}
unsafe extern "C" {
    #[doc = " Postsolve a model using a primal (and possibly dual) solution.\n\n @param highs       A pointer to the Highs instance.\n @param col_value   An array of length [num_col] with the column solution\n                    values.\n @param col_dual    An array of length [num_col] with the column dual\n                    values, or a null pointer if not known.\n @param row_dual    An array of length [num_row] with the row dual values,\n                    or a null pointer if not known.\n\n @returns A `kHighsStatus` constant indicating whether the call succeeded."]
    pub fn Highs_postsolve(
        highs: *mut ::std::os::raw::c_void,
        col_value: *const f64,
        col_dual: *const f64,
        row_dual: *const f64,
    ) -> HighsInt;
}
unsafe extern "C" {
    #[doc = " Write the solution information (including dual and basis status, if\n available) to a file.\n\n See also: `Highs_writeSolutionPretty`.\n\n @param highs     A pointer to the Highs instance.\n @param filename  The name of the file to write the results to.\n\n @returns A `kHighsStatus` constant indicating whether the call succeeded."]
    pub fn Highs_writeSolution(
        highs: *const ::std::os::raw::c_void,
        filename: *const ::std::os::raw::c_char,
    ) -> HighsInt;
}
unsafe extern "C" {
    #[doc = " Write the solution information (including dual and basis status, if\n available) to a file in a human-readable format.\n\n The method identical to `Highs_writeSolution`, except that the\n printout is in a human-readable format.\n\n @param highs     A pointer to the Highs instance.\n @param filename  The name of the file to write the results to.\n\n @returns A `kHighsStatus` constant indicating whether the call succeeded."]
    pub fn Highs_writeSolutionPretty(
        highs: *const ::std::os::raw::c_void,
        filename: *const ::std::os::raw::c_char,
    ) -> HighsInt;
}
unsafe extern "C" {
    #[doc = " Pass a linear program (LP) to HiGHS in a single function call.\n\n The signature of this function is identical to `Highs_passModel`, without the\n arguments for passing the Hessian matrix of a quadratic program and the\n integrality vector.\n\n @returns A `kHighsStatus` constant indicating whether the call succeeded."]
    pub fn Highs_passLp(
        highs: *mut ::std::os::raw::c_void,
        num_col: HighsInt,
        num_row: HighsInt,
        num_nz: HighsInt,
        a_format: HighsInt,
        sense: HighsInt,
        offset: f64,
        col_cost: *const f64,
        col_lower: *const f64,
        col_upper: *const f64,
        row_lower: *const f64,
        row_upper: *const f64,
        a_start: *const HighsInt,
        a_index: *const HighsInt,
        a_value: *const f64,
    ) -> HighsInt;
}
unsafe extern "C" {
    #[doc = " Pass a mixed-integer linear program (MILP) to HiGHS in a single function\n call.\n\n The signature of function is identical to `Highs_passModel`, without the\n arguments for passing the Hessian matrix of a quadratic program.\n\n @returns A `kHighsStatus` constant indicating whether the call succeeded."]
    pub fn Highs_passMip(
        highs: *mut ::std::os::raw::c_void,
        num_col: HighsInt,
        num_row: HighsInt,
        num_nz: HighsInt,
        a_format: HighsInt,
        sense: HighsInt,
        offset: f64,
        col_cost: *const f64,
        col_lower: *const f64,
        col_upper: *const f64,
        row_lower: *const f64,
        row_upper: *const f64,
        a_start: *const HighsInt,
        a_index: *const HighsInt,
        a_value: *const f64,
        integrality: *const HighsInt,
    ) -> HighsInt;
}
unsafe extern "C" {
    #[doc = " Pass a model to HiGHS in a single function call. This is faster than\n constructing the model using `Highs_addRow` and `Highs_addCol`.\n\n @param highs       A pointer to the Highs instance.\n @param num_col     The number of columns.\n @param num_row     The number of rows.\n @param num_nz      The number of elements in the constraint matrix.\n @param q_num_nz    The number of elements in the Hessian matrix.\n @param a_format    The format of the constraint matrix to use in the form of\n                    a `kHighsMatrixFormat` constant.\n @param q_format    The format of the Hessian matrix to use in the form of a\n                    `kHighsHessianFormat` constant.\n @param sense       The optimization sense in the form of a `kHighsObjSense`\n                    constant.\n @param offset      The constant term in the objective function.\n @param col_cost    An array of length [num_col] with the objective\n                    coefficients.\n @param col_lower   An array of length [num_col] with the lower column bounds.\n @param col_upper   An array of length [num_col] with the upper column bounds.\n @param row_lower   An array of length [num_row] with the upper row bounds.\n @param row_upper   An array of length [num_row] with the upper row bounds.\n @param a_start     The constraint matrix is provided to HiGHS in compressed\n                    sparse column form (if `a_format` is\n                    `kHighsMatrixFormatColwise`, otherwise compressed sparse\n                    row form). The sparse matrix consists of three arrays,\n                    `a_start`, `a_index`, and `a_value`. `a_start` is an array\n                    of length [num_col] containing the starting index of each\n                    column in `a_index`. If `a_format` is\n                    `kHighsMatrixFormatRowwise` the array is of length\n                    [num_row] corresponding to each row.\n @param a_index     An array of length [num_nz] with indices of matrix\n                    entries.\n @param a_value     An array of length [num_nz] with values of matrix entries.\n @param q_start     The Hessian matrix is provided to HiGHS as the lower\n                    triangular component in compressed sparse column form\n                    (or, equivalently, as the upper triangular component\n                    in compressed sparse row form). The sparse matrix consists\n                    of three arrays, `q_start`, `q_index`, and `q_value`.\n                    `q_start` is an array of length [num_col]. If the model\n                    is linear, pass NULL.\n @param q_index     An array of length [q_num_nz] with indices of matrix\n                    entries. If the model is linear, pass NULL.\n @param q_value     An array of length [q_num_nz] with values of matrix\n                     entries. If the model is linear, pass NULL.\n @param integrality An array of length [num_col] containing a `kHighsVarType`\n                    constant for each column.\n\n @returns A `kHighsStatus` constant indicating whether the call succeeded."]
    pub fn Highs_passModel(
        highs: *mut ::std::os::raw::c_void,
        num_col: HighsInt,
        num_row: HighsInt,
        num_nz: HighsInt,
        q_num_nz: HighsInt,
        a_format: HighsInt,
        q_format: HighsInt,
        sense: HighsInt,
        offset: f64,
        col_cost: *const f64,
        col_lower: *const f64,
        col_upper: *const f64,
        row_lower: *const f64,
        row_upper: *const f64,
        a_start: *const HighsInt,
        a_index: *const HighsInt,
        a_value: *const f64,
        q_start: *const HighsInt,
        q_index: *const HighsInt,
        q_value: *const f64,
        integrality: *const HighsInt,
    ) -> HighsInt;
}
unsafe extern "C" {
    #[doc = " Set the Hessian matrix for a quadratic objective.\n\n @param highs     A pointer to the Highs instance.\n @param dim       The dimension of the Hessian matrix. Should be [num_col].\n @param num_nz    The number of non-zero elements in the Hessian matrix.\n @param format    The format of the Hessian matrix as a `kHighsHessianFormat`\n                  constant. This must be `kHighsHessianFormatTriangular`.\n @param start     The Hessian matrix is provided to HiGHS as the lower\n                  triangular component in compressed sparse column form\n                  (or, equivalently, as the upper triangular component\n                  in compressed sparse row form), using `q_start`, `q_index`,\n                  and `q_value`.The Hessian matrix is provided to HiGHS as the\n                  lower triangular component in compressed sparse column form.\n                  The sparse matrix consists of three arrays, `start`,\n                  `index`, and `value`. `start` is an array of length\n                  [num_col] containing the starting index of each column in\n                  `index`.\n @param index     An array of length [num_nz] with indices of matrix entries.\n @param value     An array of length [num_nz] with values of matrix entries.\n\n @returns A `kHighsStatus` constant indicating whether the call succeeded."]
    pub fn Highs_passHessian(
        highs: *mut ::std::os::raw::c_void,
        dim: HighsInt,
        num_nz: HighsInt,
        format: HighsInt,
        start: *const HighsInt,
        index: *const HighsInt,
        value: *const f64,
    ) -> HighsInt;
}
unsafe extern "C" {
    #[doc = " Passes multiple linear objective data to HiGHS, clearing any such\n data already in HiGHS\n\n @param highs         A pointer to the Highs instance.\n @param weight        A pointer to the weights of the linear objective, with\n                      its positive/negative sign determining whether it is\n                      minimized or maximized during lexicographic optimization\n @param offset        A pointer to the objective offsets\n @param coefficients  A pointer to the objective coefficients\n @param abs_tolerance A pointer to the absolute tolerances used when\n                      constructing objective constraints during lexicographic\n                      optimization\n @param rel_tolerance A pointer to the relative tolerances used when\n                      constructing objective constraints during lexicographic\n                      optimization\n @param priority      A pointer to the priorities of the objectives during\n                      lexicographic optimization\n\n @returns A `kHighsStatus` constant indicating whether the call succeeded."]
    pub fn Highs_passLinearObjectives(
        highs: *const ::std::os::raw::c_void,
        num_linear_objective: HighsInt,
        weight: *const f64,
        offset: *const f64,
        coefficients: *const f64,
        abs_tolerance: *const f64,
        rel_tolerance: *const f64,
        priority: *const HighsInt,
    ) -> HighsInt;
}
unsafe extern "C" {
    #[doc = " Adds linear objective data to HiGHS\n\n @param highs         A pointer to the Highs instance.\n @param weight        The weight of the linear objective, with its\n                      positive/negative sign determining whether it is\n                      minimized or maximized during lexicographic\n                      optimization\n @param offset        The objective offset\n @param coefficients  A pointer to the objective coefficients\n @param abs_tolerance The absolute tolerance used when constructing an\n                      objective constraint during lexicographic optimization\n @param rel_tolerance The relative tolerance used when constructing an\n                      objective constraint during lexicographic optimization\n @param priority      The priority of this objective during lexicographic\n                      optimization\n\n @returns A `kHighsStatus` constant indicating whether the call succeeded."]
    pub fn Highs_addLinearObjective(
        highs: *const ::std::os::raw::c_void,
        weight: f64,
        offset: f64,
        coefficients: *const f64,
        abs_tolerance: f64,
        rel_tolerance: f64,
        priority: HighsInt,
    ) -> HighsInt;
}
unsafe extern "C" {
    #[doc = " Clears any multiple linear objective data in HiGHS\n\n @param highs A pointer to the Highs instance.\n\n @returns A `kHighsStatus` constant indicating whether the call succeeded."]
    pub fn Highs_clearLinearObjectives(highs: *const ::std::os::raw::c_void) -> HighsInt;
}
unsafe extern "C" {
    #[doc = " Pass the name of a row.\n\n @param highs A pointer to the Highs instance.\n @param row   The row for which the name is supplied.\n @param name  The name of the row.\n\n @returns A `kHighsStatus` constant indicating whether the call succeeded."]
    pub fn Highs_passRowName(
        highs: *const ::std::os::raw::c_void,
        row: HighsInt,
        name: *const ::std::os::raw::c_char,
    ) -> HighsInt;
}
unsafe extern "C" {
    #[doc = " Pass the name of a column.\n\n @param highs A pointer to the Highs instance.\n @param col   The column for which the name is supplied.\n @param name  The name of the column.\n\n @returns A `kHighsStatus` constant indicating whether the call succeeded."]
    pub fn Highs_passColName(
        highs: *const ::std::os::raw::c_void,
        col: HighsInt,
        name: *const ::std::os::raw::c_char,
    ) -> HighsInt;
}
unsafe extern "C" {
    #[doc = " Pass the name of the model.\n\n @param highs A pointer to the Highs instance.\n @param name  The name of the model.\n\n @returns A `kHighsStatus` constant indicating whether the call succeeded."]
    pub fn Highs_passModelName(
        highs: *const ::std::os::raw::c_void,
        name: *const ::std::os::raw::c_char,
    ) -> HighsInt;
}
unsafe extern "C" {
    #[doc = " Read the option values from file.\n\n @param highs     A pointer to the Highs instance.\n @param filename  The filename from which to read the option values.\n\n @returns A `kHighsStatus` constant indicating whether the call succeeded."]
    pub fn Highs_readOptions(
        highs: *const ::std::os::raw::c_void,
        filename: *const ::std::os::raw::c_char,
    ) -> HighsInt;
}
unsafe extern "C" {
    #[doc = " Set a boolean-valued option.\n\n @param highs     A pointer to the Highs instance.\n @param option    The name of the option.\n @param value     The new value of the option.\n\n @returns A `kHighsStatus` constant indicating whether the call succeeded."]
    pub fn Highs_setBoolOptionValue(
        highs: *mut ::std::os::raw::c_void,
        option: *const ::std::os::raw::c_char,
        value: HighsInt,
    ) -> HighsInt;
}
unsafe extern "C" {
    #[doc = " Set an int-valued option.\n\n @param highs     A pointer to the Highs instance.\n @param option    The name of the option.\n @param value     The new value of the option.\n\n @returns A `kHighsStatus` constant indicating whether the call succeeded."]
    pub fn Highs_setIntOptionValue(
        highs: *mut ::std::os::raw::c_void,
        option: *const ::std::os::raw::c_char,
        value: HighsInt,
    ) -> HighsInt;
}
unsafe extern "C" {
    #[doc = " Set a double-valued option.\n\n @param highs     A pointer to the Highs instance.\n @param option    The name of the option.\n @param value     The new value of the option.\n\n @returns A `kHighsStatus` constant indicating whether the call succeeded."]
    pub fn Highs_setDoubleOptionValue(
        highs: *mut ::std::os::raw::c_void,
        option: *const ::std::os::raw::c_char,
        value: f64,
    ) -> HighsInt;
}
unsafe extern "C" {
    #[doc = " Set a string-valued option.\n\n @param highs     A pointer to the Highs instance.\n @param option    The name of the option.\n @param value     The new value of the option.\n\n @returns A `kHighsStatus` constant indicating whether the call succeeded."]
    pub fn Highs_setStringOptionValue(
        highs: *mut ::std::os::raw::c_void,
        option: *const ::std::os::raw::c_char,
        value: *const ::std::os::raw::c_char,
    ) -> HighsInt;
}
unsafe extern "C" {
    #[doc = " Get a boolean-valued option.\n\n @param highs     A pointer to the Highs instance.\n @param option    The name of the option.\n @param value     The location in which the current value of the option should\n                  be placed.\n\n @returns A `kHighsStatus` constant indicating whether the call succeeded."]
    pub fn Highs_getBoolOptionValue(
        highs: *const ::std::os::raw::c_void,
        option: *const ::std::os::raw::c_char,
        value: *mut HighsInt,
    ) -> HighsInt;
}
unsafe extern "C" {
    #[doc = " Get an int-valued option.\n\n @param highs     A pointer to the Highs instance.\n @param option    The name of the option.\n @param value     The location in which the current value of the option should\n                  be placed.\n\n @returns A `kHighsStatus` constant indicating whether the call succeeded."]
    pub fn Highs_getIntOptionValue(
        highs: *const ::std::os::raw::c_void,
        option: *const ::std::os::raw::c_char,
        value: *mut HighsInt,
    ) -> HighsInt;
}
unsafe extern "C" {
    #[doc = " Get a double-valued option.\n\n @param highs     A pointer to the Highs instance.\n @param option    The name of the option.\n @param value     The location in which the current value of the option should\n                  be placed.\n\n @returns A `kHighsStatus` constant indicating whether the call succeeded."]
    pub fn Highs_getDoubleOptionValue(
        highs: *const ::std::os::raw::c_void,
        option: *const ::std::os::raw::c_char,
        value: *mut f64,
    ) -> HighsInt;
}
unsafe extern "C" {
    #[doc = " Get a string-valued option.\n\n @param highs     A pointer to the Highs instance.\n @param option    The name of the option.\n @param value     A pointer to allocated memory (of at least\n                  `kMaximumStringLength`) to store the current value of the\n                  option.\n\n @returns A `kHighsStatus` constant indicating whether the call succeeded."]
    pub fn Highs_getStringOptionValue(
        highs: *const ::std::os::raw::c_void,
        option: *const ::std::os::raw::c_char,
        value: *mut ::std::os::raw::c_char,
    ) -> HighsInt;
}
unsafe extern "C" {
    #[doc = " Get the type expected by an option.\n\n @param highs     A pointer to the Highs instance.\n @param option    The name of the option.\n @param type      A HighsInt in which the corresponding `kHighsOptionType`\n                  constant should be placed.\n\n @returns A `kHighsStatus` constant indicating whether the call succeeded."]
    pub fn Highs_getOptionType(
        highs: *const ::std::os::raw::c_void,
        option: *const ::std::os::raw::c_char,
        type_: *mut HighsInt,
    ) -> HighsInt;
}
unsafe extern "C" {
    #[doc = " Reset all options to their default value.\n\n @param highs     A pointer to the Highs instance.\n\n @returns A `kHighsStatus` constant indicating whether the call succeeded."]
    pub fn Highs_resetOptions(highs: *mut ::std::os::raw::c_void) -> HighsInt;
}
unsafe extern "C" {
    #[doc = " Write the current options to file.\n\n @param highs     A pointer to the Highs instance.\n @param filename  The filename to write the options to.\n\n @returns A `kHighsStatus` constant indicating whether the call succeeded."]
    pub fn Highs_writeOptions(
        highs: *const ::std::os::raw::c_void,
        filename: *const ::std::os::raw::c_char,
    ) -> HighsInt;
}
unsafe extern "C" {
    #[doc = " Write the value of non-default options to file.\n\n This is similar to `Highs_writeOptions`, except only options with\n non-default value are written to `filename`.\n\n @param highs     A pointer to the Highs instance.\n @param filename  The filename to write the options to.\n\n @returns A `kHighsStatus` constant indicating whether the call succeeded."]
    pub fn Highs_writeOptionsDeviations(
        highs: *const ::std::os::raw::c_void,
        filename: *const ::std::os::raw::c_char,
    ) -> HighsInt;
}
unsafe extern "C" {
    #[doc = " Return the number of options\n\n @param highs     A pointer to the Highs instance."]
    pub fn Highs_getNumOptions(highs: *const ::std::os::raw::c_void) -> HighsInt;
}
unsafe extern "C" {
    #[doc = " Get the name of an option identified by index\n\n @param highs     A pointer to the Highs instance.\n @param index     The index of the option.\n @param name      The name of the option.\n\n @returns A `kHighsStatus` constant indicating whether the call succeeded."]
    pub fn Highs_getOptionName(
        highs: *const ::std::os::raw::c_void,
        index: HighsInt,
        name: *mut *mut ::std::os::raw::c_char,
    ) -> HighsInt;
}
unsafe extern "C" {
    #[doc = " Get the current and default values of a bool option\n\n @param highs         A pointer to the Highs instance.\n @param current_value A pointer to the current value of the option.\n @param default_value A pointer to the default value of the option.\n\n @returns A `kHighsStatus` constant indicating whether the call succeeded."]
    pub fn Highs_getBoolOptionValues(
        highs: *const ::std::os::raw::c_void,
        option: *const ::std::os::raw::c_char,
        current_value: *mut HighsInt,
        default_value: *mut HighsInt,
    ) -> HighsInt;
}
unsafe extern "C" {
    #[doc = " Get the current and default values of a HighsInt option\n\n @param highs         A pointer to the Highs instance.\n @param current_value A pointer to the current value of the option.\n @param min_value     A pointer to the minimum value of the option.\n @param max_value     A pointer to the maximum value of the option.\n @param default_value A pointer to the default value of the option.\n\n @returns A `kHighsStatus` constant indicating whether the call succeeded."]
    pub fn Highs_getIntOptionValues(
        highs: *const ::std::os::raw::c_void,
        option: *const ::std::os::raw::c_char,
        current_value: *mut HighsInt,
        min_value: *mut HighsInt,
        max_value: *mut HighsInt,
        default_value: *mut HighsInt,
    ) -> HighsInt;
}
unsafe extern "C" {
    #[doc = " Get the current and default values of a double option\n\n @param highs         A pointer to the Highs instance.\n @param current_value A pointer to the current value of the option.\n @param min_value     A pointer to the minimum value of the option.\n @param max_value     A pointer to the maximum value of the option.\n @param default_value A pointer to the default value of the option.\n\n @returns A `kHighsStatus` constant indicating whether the call succeeded."]
    pub fn Highs_getDoubleOptionValues(
        highs: *const ::std::os::raw::c_void,
        option: *const ::std::os::raw::c_char,
        current_value: *mut f64,
        min_value: *mut f64,
        max_value: *mut f64,
        default_value: *mut f64,
    ) -> HighsInt;
}
unsafe extern "C" {
    #[doc = " Get the current and default values of a string option\n\n @param highs         A pointer to the Highs instance.\n @param current_value A pointer to the current value of the option.\n @param default_value A pointer to the default value of the option.\n\n @returns A `kHighsStatus` constant indicating whether the call succeeded."]
    pub fn Highs_getStringOptionValues(
        highs: *const ::std::os::raw::c_void,
        option: *const ::std::os::raw::c_char,
        current_value: *mut ::std::os::raw::c_char,
        default_value: *mut ::std::os::raw::c_char,
    ) -> HighsInt;
}
unsafe extern "C" {
    #[doc = " Get an int-valued info value.\n\n @param highs     A pointer to the Highs instance.\n @param info      The name of the info item.\n @param value     A reference to an integer that the result will be stored in.\n\n @returns A `kHighsStatus` constant indicating whether the call succeeded."]
    pub fn Highs_getIntInfoValue(
        highs: *const ::std::os::raw::c_void,
        info: *const ::std::os::raw::c_char,
        value: *mut HighsInt,
    ) -> HighsInt;
}
unsafe extern "C" {
    #[doc = " Get a double-valued info value.\n\n @param highs     A pointer to the Highs instance.\n @param info      The name of the info item.\n @param value     A reference to a double that the result will be stored in.\n\n @returns A `kHighsStatus` constant indicating whether the call succeeded."]
    pub fn Highs_getDoubleInfoValue(
        highs: *const ::std::os::raw::c_void,
        info: *const ::std::os::raw::c_char,
        value: *mut f64,
    ) -> HighsInt;
}
unsafe extern "C" {
    #[doc = " Get an int64-valued info value.\n\n @param highs     A pointer to the Highs instance.\n @param info      The name of the info item.\n @param value     A reference to an int64 that the result will be stored in.\n\n @returns A `kHighsStatus` constant indicating whether the call succeeded."]
    pub fn Highs_getInt64InfoValue(
        highs: *const ::std::os::raw::c_void,
        info: *const ::std::os::raw::c_char,
        value: *mut i64,
    ) -> HighsInt;
}
unsafe extern "C" {
    #[doc = " Get the type expected by an info item.\n\n @param highs     A pointer to the Highs instance.\n @param info      The name of the info item.\n @param type      A HighsInt in which the corresponding `kHighsOptionType`\n                  constant is stored.\n\n @returns A `kHighsStatus` constant indicating whether the call succeeded."]
    pub fn Highs_getInfoType(
        highs: *const ::std::os::raw::c_void,
        info: *const ::std::os::raw::c_char,
        type_: *mut HighsInt,
    ) -> HighsInt;
}
unsafe extern "C" {
    #[doc = " Get the primal and dual solution from an optimized model.\n\n @param highs      A pointer to the Highs instance.\n @param col_value  An array of length [num_col], to be filled with primal\n                   column values.\n @param col_dual   An array of length [num_col], to be filled with dual column\n                   values.\n @param row_value  An array of length [num_row], to be filled with primal row\n                   values.\n @param row_dual   An array of length [num_row], to be filled with dual row\n                   values.\n\n @returns A `kHighsStatus` constant indicating whether the call succeeded."]
    pub fn Highs_getSolution(
        highs: *const ::std::os::raw::c_void,
        col_value: *mut f64,
        col_dual: *mut f64,
        row_value: *mut f64,
        row_dual: *mut f64,
    ) -> HighsInt;
}
unsafe extern "C" {
    #[doc = " Given a linear program with a basic feasible solution, get the column and row\n basis statuses.\n\n @param highs       A pointer to the Highs instance.\n @param col_status  An array of length [num_col], to be filled with the column\n                    basis statuses in the form of a `kHighsBasisStatus`\n                    constant.\n @param row_status  An array of length [num_row], to be filled with the row\n                    basis statuses in the form of a `kHighsBasisStatus`\n                    constant.\n\n @returns A `kHighsStatus` constant indicating whether the call succeeded."]
    pub fn Highs_getBasis(
        highs: *const ::std::os::raw::c_void,
        col_status: *mut HighsInt,
        row_status: *mut HighsInt,
    ) -> HighsInt;
}
unsafe extern "C" {
    #[doc = " Return the optimization status of the model in the form of a\n `kHighsModelStatus` constant.\n\n @param highs     A pointer to the Highs instance.\n\n @returns An integer corresponding to the `kHighsModelStatus` constant"]
    pub fn Highs_getModelStatus(highs: *const ::std::os::raw::c_void) -> HighsInt;
}
unsafe extern "C" {
    #[doc = " Indicates whether a dual ray that is a certificate of primal\n infeasibility currently exists, and (at the expense of solving an\n LP) gets it if it does not and dual_ray_value is not nullptr.\n\n @param highs             A pointer to the Highs instance.\n @param has_dual_ray      A pointer to a HighsInt to store 1 if a dual ray\n                          currently exists.\n @param dual_ray_value    An array of length [num_row] filled with the\n                          unbounded ray.\n\n @returns A `kHighsStatus` constant indicating whether the call succeeded."]
    pub fn Highs_getDualRay(
        highs: *const ::std::os::raw::c_void,
        has_dual_ray: *mut HighsInt,
        dual_ray_value: *mut f64,
    ) -> HighsInt;
}
unsafe extern "C" {
    #[doc = " Indicates whether a dual unboundedness direction (corresponding to a\n certificate of primal infeasibility) exists, and (at the expense of\n solving an LP) gets it if it does not and\n dual_unboundedness_direction is not nullptr\n\n @param highs                                   A pointer to the Highs\n                                                instance.\n @param has_dual_unboundedness_direction        A pointer to a HighsInt to\n                                                store 1 if the dual\n                                                unboundedness direction\n                                                exists.\n @param dual_unboundedness_direction_value      An array of length [num_col]\n                                                filled with the unboundedness\n                                                direction."]
    pub fn Highs_getDualUnboundednessDirection(
        highs: *const ::std::os::raw::c_void,
        has_dual_unboundedness_direction: *mut HighsInt,
        dual_unboundedness_direction_value: *mut f64,
    ) -> HighsInt;
}
unsafe extern "C" {
    #[doc = " Indicates whether a primal ray that is a certificate of primal\n unboundedness currently exists, and (at the expense of solving an\n LP) gets it if it does not and primal_ray_value is not nullptr.\n\n @param highs             A pointer to the Highs instance.\n @param has_primal_ray    A pointer to a HighsInt to store 1 if the primal ray\n                          exists.\n @param primal_ray_value  An array of length [num_col] filled with the\n                          unbounded ray.\n\n @returns A `kHighsStatus` constant indicating whether the call succeeded."]
    pub fn Highs_getPrimalRay(
        highs: *const ::std::os::raw::c_void,
        has_primal_ray: *mut HighsInt,
        primal_ray_value: *mut f64,
    ) -> HighsInt;
}
unsafe extern "C" {
    #[doc = " Get the primal objective function value.\n\n @param highs     A pointer to the Highs instance.\n\n @returns The primal objective function value"]
    pub fn Highs_getObjectiveValue(highs: *const ::std::os::raw::c_void) -> f64;
}
unsafe extern "C" {
    #[doc = " Get the indices of the rows and columns that make up the basis matrix ``B``\n of a basic feasible solution.\n\n Non-negative entries are indices of columns, and negative entries are\n `-row_index - 1`. For example, `{1, -1}` would be the second column and first\n row.\n\n The order of these rows and columns is important for calls to the functions:\n\n  - `Highs_getBasisInverseRow`\n  - `Highs_getBasisInverseCol`\n  - `Highs_getBasisSolve`\n  - `Highs_getBasisTransposeSolve`\n  - `Highs_getReducedRow`\n  - `Highs_getReducedColumn`\n\n @param highs             A pointer to the Highs instance.\n @param basic_variables   An array of size [num_rows], filled with the indices\n                          of the basic variables.\n\n @returns A `kHighsStatus` constant indicating whether the call succeeded."]
    pub fn Highs_getBasicVariables(
        highs: *const ::std::os::raw::c_void,
        basic_variables: *mut HighsInt,
    ) -> HighsInt;
}
unsafe extern "C" {
    #[doc = " Get a row of the inverse basis matrix ``B^{-1}``.\n\n See `Highs_getBasicVariables` for a description of the ``B`` matrix.\n\n The arrays `row_vector` and `row_index` must have an allocated length of\n [num_row]. However, check `row_num_nz` to see how many non-zero elements are\n actually stored.\n\n @param highs         A pointer to the Highs instance.\n @param row           The index of the row to compute.\n @param row_vector    An array of length [num_row] in which to store the\n                      values of the non-zero elements.\n @param row_num_nz    The number of non-zeros in the row.\n @param row_index     An array of length [num_row] in which to store the\n                      indices of the non-zero elements.\n\n @returns A `kHighsStatus` constant indicating whether the call succeeded."]
    pub fn Highs_getBasisInverseRow(
        highs: *const ::std::os::raw::c_void,
        row: HighsInt,
        row_vector: *mut f64,
        row_num_nz: *mut HighsInt,
        row_index: *mut HighsInt,
    ) -> HighsInt;
}
unsafe extern "C" {
    #[doc = " Get a column of the inverse basis matrix ``B^{-1}``.\n\n See `Highs_getBasicVariables` for a description of the ``B`` matrix.\n\n The arrays `col_vector` and `col_index` must have an allocated length of\n [num_row]. However, check `col_num_nz` to see how many non-zero elements are\n actually stored.\n\n @param highs         A pointer to the Highs instance.\n @param col           The index of the column to compute.\n @param col_vector    An array of length [num_row] in which to store the\n                      values of the non-zero elements.\n @param col_num_nz    The number of non-zeros in the column.\n @param col_index     An array of length [num_row] in which to store the\n                      indices of the non-zero elements.\n\n @returns A `kHighsStatus` constant indicating whether the call succeeded."]
    pub fn Highs_getBasisInverseCol(
        highs: *const ::std::os::raw::c_void,
        col: HighsInt,
        col_vector: *mut f64,
        col_num_nz: *mut HighsInt,
        col_index: *mut HighsInt,
    ) -> HighsInt;
}
unsafe extern "C" {
    #[doc = " Compute ``\\mathbf{x}=B^{-1}\\mathbf{b}`` for a given vector\n ``\\mathbf{b}``.\n\n See `Highs_getBasicVariables` for a description of the ``B`` matrix.\n\n The arrays `solution_vector` and `solution_index` must have an allocated\n length of [num_row]. However, check `solution_num_nz` to see how many\n non-zero elements are actually stored.\n\n @param highs             A pointer to the Highs instance.\n @param rhs               The right-hand side vector ``b``.\n @param solution_vector   An array of length [num_row] in which to store the\n                          values of the non-zero elements.\n @param solution_num_nz   The number of non-zeros in the solution.\n @param solution_index    An array of length [num_row] in which to store the\n                          indices of the non-zero elements.\n\n @returns A `kHighsStatus` constant indicating whether the call succeeded."]
    pub fn Highs_getBasisSolve(
        highs: *const ::std::os::raw::c_void,
        rhs: *const f64,
        solution_vector: *mut f64,
        solution_num_nz: *mut HighsInt,
        solution_index: *mut HighsInt,
    ) -> HighsInt;
}
unsafe extern "C" {
    #[doc = " Compute ``\\mathbf{x}=B^{-T}\\mathbf{b}`` for a given vector\n ``\\mathbf{b}``.\n\n See `Highs_getBasicVariables` for a description of the ``B`` matrix.\n\n The arrays `solution_vector` and `solution_index` must have an allocated\n length of [num_row]. However, check `solution_num_nz` to see how many\n non-zero elements are actually stored.\n\n @param highs             A pointer to the Highs instance.\n @param rhs               The right-hand side vector ``b``\n @param solution_vector   An array of length [num_row] in which to store the\n                          values of the non-zero elements.\n @param solution_num_nz   The number of non-zeros in the solution.\n @param solution_index    An array of length [num_row] in which to store the\n                          indices of the non-zero elements.\n\n @returns A `kHighsStatus` constant indicating whether the call succeeded."]
    pub fn Highs_getBasisTransposeSolve(
        highs: *const ::std::os::raw::c_void,
        rhs: *const f64,
        solution_vector: *mut f64,
        solution_nz: *mut HighsInt,
        solution_index: *mut HighsInt,
    ) -> HighsInt;
}
unsafe extern "C" {
    #[doc = " Compute a row of ``B^{-1}A``.\n\n See `Highs_getBasicVariables` for a description of the ``B`` matrix.\n\n The arrays `row_vector` and `row_index` must have an allocated length of\n [num_col]. However, check `row_num_nz` to see how many non-zero elements are\n actually stored.\n\n @param highs         A pointer to the Highs instance.\n @param row           The index of the row to compute.\n @param row_vector    An array of length [num_col] in which to store the\n                      values of the non-zero elements.\n @param row_num_nz    The number of non-zeros in the row.\n @param row_index     An array of length [num_col] in which to store the\n                      indices of the non-zero elements.\n\n @returns A `kHighsStatus` constant indicating whether the call succeeded."]
    pub fn Highs_getReducedRow(
        highs: *const ::std::os::raw::c_void,
        row: HighsInt,
        row_vector: *mut f64,
        row_num_nz: *mut HighsInt,
        row_index: *mut HighsInt,
    ) -> HighsInt;
}
unsafe extern "C" {
    #[doc = " Compute a column of ``B^{-1}A``.\n\n See `Highs_getBasicVariables` for a description of the ``B`` matrix.\n\n The arrays `col_vector` and `col_index` must have an allocated length of\n [num_row]. However, check `col_num_nz` to see how many non-zero elements are\n actually stored.\n\n @param highs         A pointer to the Highs instance.\n @param col           The index of the column to compute.\n @param col_vector    An array of length [num_row] in which to store the\n                       values of the non-zero elements.\n @param col_num_nz    The number of non-zeros in the column.\n @param col_index     An array of length [num_row] in which to store the\n                       indices of the non-zero elements.\n\n @returns A `kHighsStatus` constant indicating whether the call succeeded."]
    pub fn Highs_getReducedColumn(
        highs: *const ::std::os::raw::c_void,
        col: HighsInt,
        col_vector: *mut f64,
        col_num_nz: *mut HighsInt,
        col_index: *mut HighsInt,
    ) -> HighsInt;
}
unsafe extern "C" {
    #[doc = " Set a basic feasible solution by passing the column and row basis statuses to\n the model.\n\n @param highs       A pointer to the Highs instance.\n @param col_status  an array of length [num_col] with the column basis status\n                    in the form of `kHighsBasisStatus` constants\n @param row_status  an array of length [num_row] with the row basis status\n                    in the form of `kHighsBasisStatus` constants\n\n @returns A `kHighsStatus` constant indicating whether the call succeeded."]
    pub fn Highs_setBasis(
        highs: *mut ::std::os::raw::c_void,
        col_status: *const HighsInt,
        row_status: *const HighsInt,
    ) -> HighsInt;
}
unsafe extern "C" {
    #[doc = " Set a logical basis in the model.\n\n @param highs     A pointer to the Highs instance.\n\n @returns A `kHighsStatus` constant indicating whether the call succeeded."]
    pub fn Highs_setLogicalBasis(highs: *mut ::std::os::raw::c_void) -> HighsInt;
}
unsafe extern "C" {
    #[doc = " Set a solution by passing the column and row primal and dual solution values.\n\n For any values that are unavailable, pass NULL.\n\n @param highs       A pointer to the Highs instance.\n @param col_value   An array of length [num_col] with the column solution\n                    values.\n @param row_value   An array of length [num_row] with the row solution\n                    values.\n @param col_dual    An array of length [num_col] with the column dual values.\n @param row_dual    An array of length [num_row] with the row dual values.\n\n @returns A `kHighsStatus` constant indicating whether the call succeeded."]
    pub fn Highs_setSolution(
        highs: *mut ::std::os::raw::c_void,
        col_value: *const f64,
        row_value: *const f64,
        col_dual: *const f64,
        row_dual: *const f64,
    ) -> HighsInt;
}
unsafe extern "C" {
    #[doc = " Set a partial primal solution by passing values for a set of variables\n\n @param highs       A pointer to the Highs instance.\n @param num_entries Number of variables in the set\n @param index       Indices of variables in the set\n @param value       Values of variables in the set\n\n @returns A `kHighsStatus` constant indicating whether the call succeeded."]
    pub fn Highs_setSparseSolution(
        highs: *mut ::std::os::raw::c_void,
        num_entries: HighsInt,
        index: *const HighsInt,
        value: *const f64,
    ) -> HighsInt;
}
unsafe extern "C" {
    #[doc = " Set the callback method to use for HiGHS\n\n @param highs              A pointer to the Highs instance.\n @param user_callback      A pointer to the user callback\n @param user_callback_data A pointer to the user callback data\n\n @returns A `kHighsStatus` constant indicating whether the call succeeded."]
    pub fn Highs_setCallback(
        highs: *mut ::std::os::raw::c_void,
        user_callback: HighsCCallbackType,
        user_callback_data: *mut ::std::os::raw::c_void,
    ) -> HighsInt;
}
unsafe extern "C" {
    #[doc = " Start callback of given type\n\n @param highs         A pointer to the Highs instance.\n @param callback_type The type of callback to be started\n\n @returns A `kHighsStatus` constant indicating whether the call succeeded."]
    pub fn Highs_startCallback(
        highs: *mut ::std::os::raw::c_void,
        callback_type: HighsInt,
    ) -> HighsInt;
}
unsafe extern "C" {
    #[doc = " Stop callback of given type\n\n @param highs         A pointer to the Highs instance.\n @param callback_type The type of callback to be stopped\n\n @returns A `kHighsStatus` constant indicating whether the call succeeded."]
    pub fn Highs_stopCallback(
        highs: *mut ::std::os::raw::c_void,
        callback_type: HighsInt,
    ) -> HighsInt;
}
unsafe extern "C" {
    #[doc = " Return the cumulative wall-clock time spent in `Highs_run`.\n\n @param highs     A pointer to the Highs instance.\n\n @returns The cumulative wall-clock time spent in `Highs_run`"]
    pub fn Highs_getRunTime(highs: *const ::std::os::raw::c_void) -> f64;
}
unsafe extern "C" {
    #[doc = " Reset the clocks in a `highs` model.\n\n Each `highs` model contains a single instance of clock that records how much\n time is spent in various parts of the algorithm. This clock is not reset on\n entry to `Highs_run`, so repeated calls to `Highs_run` report the cumulative\n time spent in the algorithm. A side-effect is that this will trigger a time\n limit termination once the cumulative run time exceeds the time limit, rather\n than the run time of each individual call to `Highs_run`.\n\n As a work-around, call `Highs_zeroAllClocks` before each call to `Highs_run`.\n\n @param highs     A pointer to the Highs instance.\n\n @returns A `kHighsStatus` constant indicating whether the call succeeded."]
    pub fn Highs_zeroAllClocks(highs: *const ::std::os::raw::c_void) -> HighsInt;
}
unsafe extern "C" {
    #[doc = " Add a new column (variable) to the model.\n\n @param highs         A pointer to the Highs instance.\n @param cost          The objective coefficient of the column.\n @param lower         The lower bound of the column.\n @param upper         The upper bound of the column.\n @param num_new_nz    The number of non-zeros in the column.\n @param index         An array of size [num_new_nz] with the row indices.\n @param value         An array of size [num_new_nz] with row values.\n\n @returns A `kHighsStatus` constant indicating whether the call succeeded."]
    pub fn Highs_addCol(
        highs: *mut ::std::os::raw::c_void,
        cost: f64,
        lower: f64,
        upper: f64,
        num_new_nz: HighsInt,
        index: *const HighsInt,
        value: *const f64,
    ) -> HighsInt;
}
unsafe extern "C" {
    #[doc = " Add multiple columns (variables) to the model.\n\n @param highs         A pointer to the Highs instance.\n @param num_new_col   The number of new columns to add.\n @param costs         An array of size [num_new_col] with objective\n                      coefficients.\n @param lower         An array of size [num_new_col] with lower bounds.\n @param upper         An array of size [num_new_col] with upper bounds.\n @param num_new_nz    The number of new nonzeros in the constraint matrix.\n @param starts        The constraint coefficients are given as a matrix in\n                      compressed sparse column form by the arrays `starts`,\n                      `index`, and `value`. `starts` is an array of size\n                      [num_new_cols] with the start index of each row in\n                      indices and values.\n @param index         An array of size [num_new_nz] with row indices.\n @param value         An array of size [num_new_nz] with row values.\n\n @returns A `kHighsStatus` constant indicating whether the call succeeded."]
    pub fn Highs_addCols(
        highs: *mut ::std::os::raw::c_void,
        num_new_col: HighsInt,
        costs: *const f64,
        lower: *const f64,
        upper: *const f64,
        num_new_nz: HighsInt,
        starts: *const HighsInt,
        index: *const HighsInt,
        value: *const f64,
    ) -> HighsInt;
}
unsafe extern "C" {
    #[doc = " Add a new variable to the model.\n\n @param highs         A pointer to the Highs instance.\n @param lower         The lower bound of the column.\n @param upper         The upper bound of the column.\n\n @returns A `kHighsStatus` constant indicating whether the call succeeded."]
    pub fn Highs_addVar(highs: *mut ::std::os::raw::c_void, lower: f64, upper: f64) -> HighsInt;
}
unsafe extern "C" {
    #[doc = " Add multiple variables to the model.\n\n @param highs         A pointer to the Highs instance.\n @param num_new_var   The number of new variables to add.\n @param lower         An array of size [num_new_var] with lower bounds.\n @param upper         An array of size [num_new_var] with upper bounds.\n\n @returns A `kHighsStatus` constant indicating whether the call succeeded."]
    pub fn Highs_addVars(
        highs: *mut ::std::os::raw::c_void,
        num_new_var: HighsInt,
        lower: *const f64,
        upper: *const f64,
    ) -> HighsInt;
}
unsafe extern "C" {
    #[doc = " Add a new row (a linear constraint) to the model.\n\n @param highs         A pointer to the Highs instance.\n @param lower         The lower bound of the row.\n @param upper         The upper bound of the row.\n @param num_new_nz    The number of non-zeros in the row\n @param index         An array of size [num_new_nz] with column indices.\n @param value         An array of size [num_new_nz] with column values.\n\n @returns A `kHighsStatus` constant indicating whether the call succeeded."]
    pub fn Highs_addRow(
        highs: *mut ::std::os::raw::c_void,
        lower: f64,
        upper: f64,
        num_new_nz: HighsInt,
        index: *const HighsInt,
        value: *const f64,
    ) -> HighsInt;
}
unsafe extern "C" {
    #[doc = " Add multiple rows (linear constraints) to the model.\n\n @param highs         A pointer to the Highs instance.\n @param num_new_row   The number of new rows to add\n @param lower         An array of size [num_new_row] with the lower bounds of\n                      the rows.\n @param upper         An array of size [num_new_row] with the upper bounds of\n                      the rows.\n @param num_new_nz    The number of non-zeros in the rows.\n @param starts        The constraint coefficients are given as a matrix in\n                      compressed sparse row form by the arrays `starts`,\n                      `index`, and `value`. `starts` is an array of size\n                      [num_new_rows] with the start index of each row in\n                      indices and values.\n @param index         An array of size [num_new_nz] with column indices.\n @param value         An array of size [num_new_nz] with column values.\n\n @returns A `kHighsStatus` constant indicating whether the call succeeded."]
    pub fn Highs_addRows(
        highs: *mut ::std::os::raw::c_void,
        num_new_row: HighsInt,
        lower: *const f64,
        upper: *const f64,
        num_new_nz: HighsInt,
        starts: *const HighsInt,
        index: *const HighsInt,
        value: *const f64,
    ) -> HighsInt;
}
unsafe extern "C" {
    #[doc = " Ensure that the constraint matrix of the incumbent model is stored\n column-wise.\n\n @param highs         A pointer to the Highs instance.\n\n @returns A `kHighsStatus` constant indicating whether the call succeeded."]
    pub fn Highs_ensureColwise(highs: *mut ::std::os::raw::c_void) -> HighsInt;
}
unsafe extern "C" {
    #[doc = " Ensure that the constraint matrix of the incumbent model is stored row-wise.\n\n @param highs         A pointer to the Highs instance.\n\n @returns A `kHighsStatus` constant indicating whether the call succeeded."]
    pub fn Highs_ensureRowwise(highs: *mut ::std::os::raw::c_void) -> HighsInt;
}
unsafe extern "C" {
    #[doc = " Change the objective sense of the model.\n\n @param highs     A pointer to the Highs instance.\n @param sense     The new optimization sense in the form of a `kHighsObjSense`\n                  constant.\n\n @returns A `kHighsStatus` constant indicating whether the call succeeded."]
    pub fn Highs_changeObjectiveSense(
        highs: *mut ::std::os::raw::c_void,
        sense: HighsInt,
    ) -> HighsInt;
}
unsafe extern "C" {
    #[doc = " Change the objective offset of the model.\n\n @param highs     A pointer to the Highs instance.\n @param offset    The new objective offset.\n\n @returns A `kHighsStatus` constant indicating whether the call succeeded."]
    pub fn Highs_changeObjectiveOffset(highs: *mut ::std::os::raw::c_void, offset: f64)
        -> HighsInt;
}
unsafe extern "C" {
    #[doc = " Change the integrality of a column.\n\n @param highs         A pointer to the Highs instance.\n @param col           The column index to change.\n @param integrality   The new integrality of the column in the form of a\n                      `kHighsVarType` constant.\n\n @returns A `kHighsStatus` constant indicating whether the call succeeded."]
    pub fn Highs_changeColIntegrality(
        highs: *mut ::std::os::raw::c_void,
        col: HighsInt,
        integrality: HighsInt,
    ) -> HighsInt;
}
unsafe extern "C" {
    #[doc = " Change the integrality of multiple adjacent columns.\n\n @param highs         A pointer to the Highs instance.\n @param from_col      The index of the first column whose integrality changes.\n @param to_col        The index of the last column whose integrality\n                      changes.\n @param integrality   An array of length [to_col - from_col + 1] with the new\n                      integralities of the columns in the form of\n                      `kHighsVarType` constants.\n\n @returns A `kHighsStatus` constant indicating whether the call succeeded."]
    pub fn Highs_changeColsIntegralityByRange(
        highs: *mut ::std::os::raw::c_void,
        from_col: HighsInt,
        to_col: HighsInt,
        integrality: *const HighsInt,
    ) -> HighsInt;
}
unsafe extern "C" {
    #[doc = " Change the integrality of multiple columns given by an array of indices.\n\n @param highs             A pointer to the Highs instance.\n @param num_set_entries   The number of columns to change.\n @param set               An array of size [num_set_entries] with the indices\n                          of the columns to change.\n @param integrality       An array of length [num_set_entries] with the new\n                          integralities of the columns in the form of\n                          `kHighsVarType` constants.\n\n @returns A `kHighsStatus` constant indicating whether the call succeeded."]
    pub fn Highs_changeColsIntegralityBySet(
        highs: *mut ::std::os::raw::c_void,
        num_set_entries: HighsInt,
        set: *const HighsInt,
        integrality: *const HighsInt,
    ) -> HighsInt;
}
unsafe extern "C" {
    #[doc = " Change the integrality of multiple columns given by a mask.\n\n @param highs         A pointer to the Highs instance.\n @param mask          An array of length [num_col] with 1 if the column\n                      integrality should be changed and 0 otherwise.\n @param integrality   An array of length [num_col] with the new\n                      integralities of the columns in the form of\n                      `kHighsVarType` constants.\n\n @returns A `kHighsStatus` constant indicating whether the call succeeded."]
    pub fn Highs_changeColsIntegralityByMask(
        highs: *mut ::std::os::raw::c_void,
        mask: *const HighsInt,
        integrality: *const HighsInt,
    ) -> HighsInt;
}
unsafe extern "C" {
    #[doc = " Clear the integrality of all columns\n\n @param highs         A pointer to the Highs instance.\n\n @returns A `kHighsStatus` constant indicating whether the call succeeded."]
    pub fn Highs_clearIntegrality(highs: *mut ::std::os::raw::c_void) -> HighsInt;
}
unsafe extern "C" {
    #[doc = " Change the objective coefficient of a column.\n\n @param highs     A pointer to the Highs instance.\n @param col       The index of the column fo change.\n @param cost      The new objective coefficient.\n\n @returns A `kHighsStatus` constant indicating whether the call succeeded."]
    pub fn Highs_changeColCost(
        highs: *mut ::std::os::raw::c_void,
        col: HighsInt,
        cost: f64,
    ) -> HighsInt;
}
unsafe extern "C" {
    #[doc = " Change the cost coefficients of multiple adjacent columns.\n\n @param highs     A pointer to the Highs instance.\n @param from_col  The index of the first column whose cost changes.\n @param to_col    The index of the last column whose cost changes.\n @param cost      An array of length [to_col - from_col + 1] with the new\n                  objective coefficients.\n\n @returns A `kHighsStatus` constant indicating whether the call succeeded."]
    pub fn Highs_changeColsCostByRange(
        highs: *mut ::std::os::raw::c_void,
        from_col: HighsInt,
        to_col: HighsInt,
        cost: *const f64,
    ) -> HighsInt;
}
unsafe extern "C" {
    #[doc = " Change the cost of multiple columns given by an array of indices.\n\n @param highs             A pointer to the Highs instance.\n @param num_set_entries   The number of columns to change.\n @param set               An array of size [num_set_entries] with the indices\n                          of the columns to change.\n @param cost              An array of length [num_set_entries] with the new\n                          costs of the columns.\n\n @returns A `kHighsStatus` constant indicating whether the call succeeded."]
    pub fn Highs_changeColsCostBySet(
        highs: *mut ::std::os::raw::c_void,
        num_set_entries: HighsInt,
        set: *const HighsInt,
        cost: *const f64,
    ) -> HighsInt;
}
unsafe extern "C" {
    #[doc = " Change the cost of multiple columns given by a mask.\n\n @param highs     A pointer to the Highs instance.\n @param mask      An array of length [num_col] with 1 if the column\n                  cost should be changed and 0 otherwise.\n @param cost      An array of length [num_col] with the new costs.\n\n @returns A `kHighsStatus` constant indicating whether the call succeeded."]
    pub fn Highs_changeColsCostByMask(
        highs: *mut ::std::os::raw::c_void,
        mask: *const HighsInt,
        cost: *const f64,
    ) -> HighsInt;
}
unsafe extern "C" {
    #[doc = " Change the variable bounds of a column.\n\n @param highs     A pointer to the Highs instance.\n @param col       The index of the column whose bounds are to change.\n @param lower     The new lower bound.\n @param upper     The new upper bound.\n\n @returns A `kHighsStatus` constant indicating whether the call succeeded."]
    pub fn Highs_changeColBounds(
        highs: *mut ::std::os::raw::c_void,
        col: HighsInt,
        lower: f64,
        upper: f64,
    ) -> HighsInt;
}
unsafe extern "C" {
    #[doc = " Change the variable bounds of multiple adjacent columns.\n\n @param highs     A pointer to the Highs instance.\n @param from_col  The index of the first column whose bound changes.\n @param to_col    The index of the last column whose bound changes.\n @param lower     An array of length [to_col - from_col + 1] with the new\n                  lower bounds.\n @param upper     An array of length [to_col - from_col + 1] with the new\n                  upper bounds.\n\n @returns A `kHighsStatus` constant indicating whether the call succeeded."]
    pub fn Highs_changeColsBoundsByRange(
        highs: *mut ::std::os::raw::c_void,
        from_col: HighsInt,
        to_col: HighsInt,
        lower: *const f64,
        upper: *const f64,
    ) -> HighsInt;
}
unsafe extern "C" {
    #[doc = " Change the bounds of multiple columns given by an array of indices.\n\n @param highs             A pointer to the Highs instance.\n @param num_set_entries   The number of columns to change.\n @param set               An array of size [num_set_entries] with the indices\n                          of the columns to change.\n @param lower             An array of length [num_set_entries] with the new\n                          lower bounds.\n @param upper             An array of length [num_set_entries] with the new\n                          upper bounds.\n\n @returns A `kHighsStatus` constant indicating whether the call succeeded."]
    pub fn Highs_changeColsBoundsBySet(
        highs: *mut ::std::os::raw::c_void,
        num_set_entries: HighsInt,
        set: *const HighsInt,
        lower: *const f64,
        upper: *const f64,
    ) -> HighsInt;
}
unsafe extern "C" {
    #[doc = " Change the variable bounds of multiple columns given by a mask.\n\n @param highs     A pointer to the Highs instance.\n @param mask      An array of length [num_col] with 1 if the column\n                  bounds should be changed and 0 otherwise.\n @param lower     An array of length [num_col] with the new lower bounds.\n @param upper     An array of length [num_col] with the new upper bounds.\n\n @returns A `kHighsStatus` constant indicating whether the call succeeded."]
    pub fn Highs_changeColsBoundsByMask(
        highs: *mut ::std::os::raw::c_void,
        mask: *const HighsInt,
        lower: *const f64,
        upper: *const f64,
    ) -> HighsInt;
}
unsafe extern "C" {
    #[doc = " Change the bounds of a row.\n\n @param highs     A pointer to the Highs instance.\n @param row       The index of the row whose bounds are to change.\n @param lower     The new lower bound.\n @param upper     The new upper bound.\n\n @returns A `kHighsStatus` constant indicating whether the call succeeded."]
    pub fn Highs_changeRowBounds(
        highs: *mut ::std::os::raw::c_void,
        row: HighsInt,
        lower: f64,
        upper: f64,
    ) -> HighsInt;
}
unsafe extern "C" {
    #[doc = " Change the variable bounds of multiple adjacent rows.\n\n @param highs     A pointer to the Highs instance.\n @param from_row  The index of the first row whose bound changes.\n @param to_row    The index of the last row whose bound changes.\n @param lower     An array of length [to_row - from_row + 1] with the new\n                  lower bounds.\n @param upper     An array of length [to_row - from_row + 1] with the new\n                  upper bounds.\n\n @returns A `kHighsStatus` constant indicating whether the call succeeded."]
    pub fn Highs_changeRowsBoundsByRange(
        highs: *mut ::std::os::raw::c_void,
        from_row: HighsInt,
        to_row: HighsInt,
        lower: *const f64,
        upper: *const f64,
    ) -> HighsInt;
}
unsafe extern "C" {
    #[doc = " Change the bounds of multiple rows given by an array of indices.\n\n @param highs             A pointer to the Highs instance.\n @param num_set_entries   The number of rows to change.\n @param set               An array of size [num_set_entries] with the indices\n                          of the rows to change.\n @param lower             An array of length [num_set_entries] with the new\n                          lower bounds.\n @param upper             An array of length [num_set_entries] with the new\n                          upper bounds.\n\n @returns A `kHighsStatus` constant indicating whether the call succeeded."]
    pub fn Highs_changeRowsBoundsBySet(
        highs: *mut ::std::os::raw::c_void,
        num_set_entries: HighsInt,
        set: *const HighsInt,
        lower: *const f64,
        upper: *const f64,
    ) -> HighsInt;
}
unsafe extern "C" {
    #[doc = " Change the bounds of multiple rows given by a mask.\n\n @param highs     A pointer to the Highs instance.\n @param mask      An array of length [num_row] with 1 if the row\n                  bounds should be changed and 0 otherwise.\n @param lower     An array of length [num_row] with the new lower bounds.\n @param upper     An array of length [num_row] with the new upper bounds.\n\n @returns A `kHighsStatus` constant indicating whether the call succeeded."]
    pub fn Highs_changeRowsBoundsByMask(
        highs: *mut ::std::os::raw::c_void,
        mask: *const HighsInt,
        lower: *const f64,
        upper: *const f64,
    ) -> HighsInt;
}
unsafe extern "C" {
    #[doc = " Change a coefficient in the constraint matrix.\n\n @param highs     A pointer to the Highs instance.\n @param row       The index of the row to change.\n @param col       The index of the column to change.\n @param value     The new constraint coefficient.\n\n @returns A `kHighsStatus` constant indicating whether the call succeeded."]
    pub fn Highs_changeCoeff(
        highs: *mut ::std::os::raw::c_void,
        row: HighsInt,
        col: HighsInt,
        value: f64,
    ) -> HighsInt;
}
unsafe extern "C" {
    #[doc = " Get the objective sense.\n\n @param highs     A pointer to the Highs instance.\n @param sense     The location in which the current objective sense should be\n                  placed. The sense is a `kHighsObjSense` constant.\n\n @returns A `kHighsStatus` constant indicating whether the call succeeded."]
    pub fn Highs_getObjectiveSense(
        highs: *const ::std::os::raw::c_void,
        sense: *mut HighsInt,
    ) -> HighsInt;
}
unsafe extern "C" {
    #[doc = " Get the objective offset.\n\n @param highs     A pointer to the Highs instance.\n @param offset    The location in which the current objective offset should be\n                  placed.\n\n @returns A `kHighsStatus` constant indicating whether the call succeeded."]
    pub fn Highs_getObjectiveOffset(
        highs: *const ::std::os::raw::c_void,
        offset: *mut f64,
    ) -> HighsInt;
}
unsafe extern "C" {
    #[doc = " Get data associated with multiple adjacent columns from the model.\n\n To query the constraint coefficients, this function should be called twice.\n\n First, call this function with `matrix_start`, `matrix_index`, and\n `matrix_value` as `NULL`. This call will populate `num_nz` with the number of\n nonzero elements in the corresponding section of the constraint matrix.\n\n Second, allocate new `matrix_index` and `matrix_value` arrays of length\n `num_nz` and call this function again to populate the new arrays with their\n contents.\n\n @param highs         A pointer to the Highs instance.\n @param from_col      The first column for which to query data for.\n @param to_col        The last column (inclusive) for which to query data for.\n @param num_col       A HighsInt populated with the number of columns got from\n                      the model (this should equal `to_col - from_col + 1`).\n @param costs         An array of size [to_col - from_col + 1] for the column\n                      cost coefficients.\n @param lower         An array of size [to_col - from_col + 1] for the column\n                      lower bounds.\n @param upper         An array of size [to_col - from_col + 1] for the column\n                      upper bounds.\n @param num_nz        A HighsInt to be populated with the number of non-zero\n                      elements in the constraint matrix.\n @param matrix_start  An array of size [to_col - from_col + 1] with the start\n                      indices of each column in `matrix_index` and\n                      `matrix_value`.\n @param matrix_index  An array of size [num_nz] with the row indices of each\n                      element in the constraint matrix.\n @param matrix_value  An array of size [num_nz] with the non-zero elements of\n                      the constraint matrix.\n\n @returns A `kHighsStatus` constant indicating whether the call succeeded."]
    pub fn Highs_getColsByRange(
        highs: *const ::std::os::raw::c_void,
        from_col: HighsInt,
        to_col: HighsInt,
        num_col: *mut HighsInt,
        costs: *mut f64,
        lower: *mut f64,
        upper: *mut f64,
        num_nz: *mut HighsInt,
        matrix_start: *mut HighsInt,
        matrix_index: *mut HighsInt,
        matrix_value: *mut f64,
    ) -> HighsInt;
}
unsafe extern "C" {
    #[doc = " Get data associated with multiple columns given by an array.\n\n This function is identical to `Highs_getColsByRange`, except for how the\n columns are specified.\n\n @param num_set_indices   The number of indices in `set`.\n @param set               An array of size [num_set_entries] with the column\n                          indices to get.\n\n @returns A `kHighsStatus` constant indicating whether the call succeeded."]
    pub fn Highs_getColsBySet(
        highs: *const ::std::os::raw::c_void,
        num_set_entries: HighsInt,
        set: *const HighsInt,
        num_col: *mut HighsInt,
        costs: *mut f64,
        lower: *mut f64,
        upper: *mut f64,
        num_nz: *mut HighsInt,
        matrix_start: *mut HighsInt,
        matrix_index: *mut HighsInt,
        matrix_value: *mut f64,
    ) -> HighsInt;
}
unsafe extern "C" {
    #[doc = " Get data associated with multiple columns given by a mask.\n\n This function is identical to `Highs_getColsByRange`, except for how the\n columns are specified.\n\n @param mask  An array of length [num_col] containing a `1` to get the column\n              and `0` otherwise.\n\n @returns A `kHighsStatus` constant indicating whether the call succeeded."]
    pub fn Highs_getColsByMask(
        highs: *const ::std::os::raw::c_void,
        mask: *const HighsInt,
        num_col: *mut HighsInt,
        costs: *mut f64,
        lower: *mut f64,
        upper: *mut f64,
        num_nz: *mut HighsInt,
        matrix_start: *mut HighsInt,
        matrix_index: *mut HighsInt,
        matrix_value: *mut f64,
    ) -> HighsInt;
}
unsafe extern "C" {
    #[doc = " Get data associated with multiple adjacent rows from the model.\n\n To query the constraint coefficients, this function should be called twice.\n\n First, call this function with `matrix_start`, `matrix_index`, and\n `matrix_value` as `NULL`. This call will populate `num_nz` with the number of\n nonzero elements in the corresponding section of the constraint matrix.\n\n Second, allocate new `matrix_index` and `matrix_value` arrays of length\n `num_nz` and call this function again to populate the new arrays with their\n contents.\n\n @param highs         A pointer to the Highs instance.\n @param from_row      The first row for which to query data for.\n @param to_row        The last row (inclusive) for which to query data for.\n @param num_row       A HighsInt to be populated with the number of rows got\n                      from the model.\n @param lower         An array of size [to_row - from_row + 1] for the row\n                      lower bounds.\n @param upper         An array of size [to_row - from_row + 1] for the row\n                      upper bounds.\n @param num_nz        A HighsInt to be populated with the number of non-zero\n                      elements in the constraint matrix.\n @param matrix_start  An array of size [to_row - from_row + 1] with the start\n                      indices of each row in `matrix_index` and\n                      `matrix_value`.\n @param matrix_index  An array of size [num_nz] with the column indices of\n                      each element in the constraint matrix.\n @param matrix_value  An array of size [num_nz] with the non-zero elements of\n                      the constraint matrix.\n\n @returns A `kHighsStatus` constant indicating whether the call succeeded."]
    pub fn Highs_getRowsByRange(
        highs: *const ::std::os::raw::c_void,
        from_row: HighsInt,
        to_row: HighsInt,
        num_row: *mut HighsInt,
        lower: *mut f64,
        upper: *mut f64,
        num_nz: *mut HighsInt,
        matrix_start: *mut HighsInt,
        matrix_index: *mut HighsInt,
        matrix_value: *mut f64,
    ) -> HighsInt;
}
unsafe extern "C" {
    #[doc = " Get data associated with multiple rows given by an array.\n\n This function is identical to `Highs_getRowsByRange`, except for how the\n rows are specified.\n\n @param num_set_indices   The number of indices in `set`.\n @param set               An array of size [num_set_entries] containing the\n                          row indices to get.\n\n @returns A `kHighsStatus` constant indicating whether the call succeeded."]
    pub fn Highs_getRowsBySet(
        highs: *const ::std::os::raw::c_void,
        num_set_entries: HighsInt,
        set: *const HighsInt,
        num_row: *mut HighsInt,
        lower: *mut f64,
        upper: *mut f64,
        num_nz: *mut HighsInt,
        matrix_start: *mut HighsInt,
        matrix_index: *mut HighsInt,
        matrix_value: *mut f64,
    ) -> HighsInt;
}
unsafe extern "C" {
    #[doc = " Get data associated with multiple rows given by a mask.\n\n This function is identical to `Highs_getRowsByRange`, except for how the\n rows are specified.\n\n @param mask  An array of length [num_row] containing a `1` to get the row and\n              `0` otherwise.\n\n @returns A `kHighsStatus` constant indicating whether the call succeeded."]
    pub fn Highs_getRowsByMask(
        highs: *const ::std::os::raw::c_void,
        mask: *const HighsInt,
        num_row: *mut HighsInt,
        lower: *mut f64,
        upper: *mut f64,
        num_nz: *mut HighsInt,
        matrix_start: *mut HighsInt,
        matrix_index: *mut HighsInt,
        matrix_value: *mut f64,
    ) -> HighsInt;
}
unsafe extern "C" {
    #[doc = " Get the name of a row.\n\n @param row   The index of the row to query.\n @param name  A pointer in which to store the name of the row. This must have\n              length `kHighsMaximumStringLength`.\n\n @returns A `kHighsStatus` constant indicating whether the call succeeded."]
    pub fn Highs_getRowName(
        highs: *const ::std::os::raw::c_void,
        row: HighsInt,
        name: *mut ::std::os::raw::c_char,
    ) -> HighsInt;
}
unsafe extern "C" {
    #[doc = " Get the index of a row from its name.\n\n If multiple rows have the same name, or if no row exists with `name`, this\n function returns `kHighsStatusError`.\n\n @param name A pointer of the name of the row to query.\n @param row  A pointer in which to store the index of the row\n\n @returns A `kHighsStatus` constant indicating whether the call succeeded."]
    pub fn Highs_getRowByName(
        highs: *const ::std::os::raw::c_void,
        name: *const ::std::os::raw::c_char,
        row: *mut HighsInt,
    ) -> HighsInt;
}
unsafe extern "C" {
    #[doc = " Get the name of a column.\n\n @param col   The index of the column to query.\n @param name  A pointer in which to store the name of the column. This must\n              have length `kHighsMaximumStringLength`.\n\n @returns A `kHighsStatus` constant indicating whether the call succeeded."]
    pub fn Highs_getColName(
        highs: *const ::std::os::raw::c_void,
        col: HighsInt,
        name: *mut ::std::os::raw::c_char,
    ) -> HighsInt;
}
unsafe extern "C" {
    #[doc = " Get the index of a column from its name.\n\n If multiple columns have the same name, or if no column exists with `name`,\n this function returns `kHighsStatusError`.\n\n @param name A pointer of the name of the column to query.\n @param col  A pointer in which to store the index of the column\n\n @returns A `kHighsStatus` constant indicating whether the call succeeded."]
    pub fn Highs_getColByName(
        highs: *const ::std::os::raw::c_void,
        name: *const ::std::os::raw::c_char,
        col: *mut HighsInt,
    ) -> HighsInt;
}
unsafe extern "C" {
    #[doc = " Get the integrality of a column.\n\n @param col          The index of the column to query.\n @param integrality  A HighsInt in which the integrality of the column should\n                     be placed. The integer is one of the `kHighsVarTypeXXX`\n                     constants.\n\n @returns A `kHighsStatus` constant indicating whether the call succeeded."]
    pub fn Highs_getColIntegrality(
        highs: *const ::std::os::raw::c_void,
        col: HighsInt,
        integrality: *mut HighsInt,
    ) -> HighsInt;
}
unsafe extern "C" {
    #[doc = " Delete multiple adjacent columns.\n\n @param highs     A pointer to the Highs instance.\n @param from_col  The index of the first column to delete.\n @param to_col    The index of the last column to delete.\n\n @returns A `kHighsStatus` constant indicating whether the call succeeded."]
    pub fn Highs_deleteColsByRange(
        highs: *mut ::std::os::raw::c_void,
        from_col: HighsInt,
        to_col: HighsInt,
    ) -> HighsInt;
}
unsafe extern "C" {
    #[doc = " Delete multiple columns given by an array of indices.\n\n @param highs             A pointer to the Highs instance.\n @param num_set_entries   The number of columns to delete.\n @param set               An array of size [num_set_entries] with the indices\n                          of the columns to delete.\n\n @returns A `kHighsStatus` constant indicating whether the call succeeded."]
    pub fn Highs_deleteColsBySet(
        highs: *mut ::std::os::raw::c_void,
        num_set_entries: HighsInt,
        set: *const HighsInt,
    ) -> HighsInt;
}
unsafe extern "C" {
    #[doc = " Delete multiple columns given by a mask.\n\n @param highs     A pointer to the Highs instance.\n @param mask      An array of length [num_col] with 1 if the column\n                  should be deleted and 0 otherwise.\n\n @returns A `kHighsStatus` constant indicating whether the call succeeded."]
    pub fn Highs_deleteColsByMask(
        highs: *mut ::std::os::raw::c_void,
        mask: *mut HighsInt,
    ) -> HighsInt;
}
unsafe extern "C" {
    #[doc = " Delete multiple adjacent rows.\n\n @param highs     A pointer to the Highs instance.\n @param from_row  The index of the first row to delete.\n @param to_row    The index of the last row to delete.\n\n @returns A `kHighsStatus` constant indicating whether the call succeeded."]
    pub fn Highs_deleteRowsByRange(
        highs: *mut ::std::os::raw::c_void,
        from_row: HighsInt,
        to_row: HighsInt,
    ) -> HighsInt;
}
unsafe extern "C" {
    #[doc = " Delete multiple rows given by an array of indices.\n\n @param highs             A pointer to the Highs instance.\n @param num_set_entries   The number of rows to delete.\n @param set               An array of size [num_set_entries] with the indices\n                          of the rows to delete.\n\n @returns A `kHighsStatus` constant indicating whether the call succeeded."]
    pub fn Highs_deleteRowsBySet(
        highs: *mut ::std::os::raw::c_void,
        num_set_entries: HighsInt,
        set: *const HighsInt,
    ) -> HighsInt;
}
unsafe extern "C" {
    #[doc = " Delete multiple rows given by a mask.\n\n @param highs     A pointer to the Highs instance.\n @param mask      An array of length [num_row] with `1` if the row should be\n                  deleted and `0` otherwise. The new index of any column not\n                  deleted is stored in place of the value `0`.\n\n @returns A `kHighsStatus` constant indicating whether the call succeeded."]
    pub fn Highs_deleteRowsByMask(
        highs: *mut ::std::os::raw::c_void,
        mask: *mut HighsInt,
    ) -> HighsInt;
}
unsafe extern "C" {
    #[doc = " Scale a column by a constant.\n\n Scaling a column modifies the elements in the constraint matrix, the variable\n bounds, and the objective coefficient.\n\n @param highs     A pointer to the Highs instance.\n @param col       The index of the column to scale.\n @param scaleval  The value by which to scale the column. If `scaleval < 0`,\n                  the variable bounds flipped.\n\n @returns A `kHighsStatus` constant indicating whether the call succeeded."]
    pub fn Highs_scaleCol(
        highs: *mut ::std::os::raw::c_void,
        col: HighsInt,
        scaleval: f64,
    ) -> HighsInt;
}
unsafe extern "C" {
    #[doc = " Scale a row by a constant.\n\n @param highs     A pointer to the Highs instance.\n @param row       The index of the row to scale.\n @param scaleval  The value by which to scale the row. If `scaleval < 0`, the\n                  row bounds are flipped.\n\n @returns A `kHighsStatus` constant indicating whether the call succeeded."]
    pub fn Highs_scaleRow(
        highs: *mut ::std::os::raw::c_void,
        row: HighsInt,
        scaleval: f64,
    ) -> HighsInt;
}
unsafe extern "C" {
    #[doc = " Return the value of infinity used by HiGHS.\n\n @param highs     A pointer to the Highs instance.\n\n @returns The value of infinity used by HiGHS."]
    pub fn Highs_getInfinity(highs: *const ::std::os::raw::c_void) -> f64;
}
unsafe extern "C" {
    #[doc = " Return the size of integers used by HiGHS.\n\n @param highs     A pointer to the Highs instance.\n\n @returns The size of integers used by HiGHS."]
    pub fn Highs_getSizeofHighsInt(highs: *const ::std::os::raw::c_void) -> HighsInt;
}
unsafe extern "C" {
    #[doc = " Return the number of columns in the model.\n\n @param highs     A pointer to the Highs instance.\n\n @returns The number of columns in the model."]
    pub fn Highs_getNumCol(highs: *const ::std::os::raw::c_void) -> HighsInt;
}
unsafe extern "C" {
    #[doc = " Return the number of rows in the model.\n\n @param highs     A pointer to the Highs instance.\n\n @returns The number of rows in the model."]
    pub fn Highs_getNumRow(highs: *const ::std::os::raw::c_void) -> HighsInt;
}
unsafe extern "C" {
    #[doc = " Return the number of nonzeros in the constraint matrix of the model.\n\n @param highs     A pointer to the Highs instance.\n\n @returns The number of nonzeros in the constraint matrix of the model."]
    pub fn Highs_getNumNz(highs: *const ::std::os::raw::c_void) -> HighsInt;
}
unsafe extern "C" {
    #[doc = " Return the number of nonzeroes in the Hessian matrix of the model.\n\n @param highs     A pointer to the Highs instance.\n\n @returns The number of nonzeroes in the Hessian matrix of the model."]
    pub fn Highs_getHessianNumNz(highs: *const ::std::os::raw::c_void) -> HighsInt;
}
unsafe extern "C" {
    #[doc = " Return the number of columns in the presolved model.\n\n @param highs     A pointer to the Highs instance.\n\n @returns The number of columns in the presolved model."]
    pub fn Highs_getPresolvedNumCol(highs: *const ::std::os::raw::c_void) -> HighsInt;
}
unsafe extern "C" {
    #[doc = " Return the number of rows in the presolved model.\n\n @param highs     A pointer to the Highs instance.\n\n @returns The number of rows in the presolved model."]
    pub fn Highs_getPresolvedNumRow(highs: *const ::std::os::raw::c_void) -> HighsInt;
}
unsafe extern "C" {
    #[doc = " Return the number of nonzeros in the constraint matrix of the presolved\n model.\n\n @param highs     A pointer to the Highs instance.\n\n @returns The number of nonzeros in the constraint matrix of the presolved\n model."]
    pub fn Highs_getPresolvedNumNz(highs: *const ::std::os::raw::c_void) -> HighsInt;
}
unsafe extern "C" {
    #[doc = " Get the data from a HiGHS model.\n\n The input arguments have the same meaning (in a different order) to those\n used in `Highs_passModel`.\n\n Note that all arrays must be pre-allocated to the correct size before calling\n `Highs_getModel`. Use the following query methods to check the appropriate\n size:\n  - `Highs_getNumCol`\n  - `Highs_getNumRow`\n  - `Highs_getNumNz`\n  - `Highs_getHessianNumNz`\n\n @returns A `kHighsStatus` constant indicating whether the call succeeded."]
    pub fn Highs_getModel(
        highs: *const ::std::os::raw::c_void,
        a_format: HighsInt,
        q_format: HighsInt,
        num_col: *mut HighsInt,
        num_row: *mut HighsInt,
        num_nz: *mut HighsInt,
        hessian_num_nz: *mut HighsInt,
        sense: *mut HighsInt,
        offset: *mut f64,
        col_cost: *mut f64,
        col_lower: *mut f64,
        col_upper: *mut f64,
        row_lower: *mut f64,
        row_upper: *mut f64,
        a_start: *mut HighsInt,
        a_index: *mut HighsInt,
        a_value: *mut f64,
        q_start: *mut HighsInt,
        q_index: *mut HighsInt,
        q_value: *mut f64,
        integrality: *mut HighsInt,
    ) -> HighsInt;
}
unsafe extern "C" {
    #[doc = " Get the data from a HiGHS LP.\n\n The input arguments have the same meaning (in a different order) to those\n used in `Highs_passModel`.\n\n Note that all arrays must be pre-allocated to the correct size before calling\n `Highs_getModel`. Use the following query methods to check the appropriate\n size:\n  - `Highs_getNumCol`\n  - `Highs_getNumRow`\n  - `Highs_getNumNz`\n\n @returns A `kHighsStatus` constant indicating whether the call succeeded."]
    pub fn Highs_getLp(
        highs: *const ::std::os::raw::c_void,
        a_format: HighsInt,
        num_col: *mut HighsInt,
        num_row: *mut HighsInt,
        num_nz: *mut HighsInt,
        sense: *mut HighsInt,
        offset: *mut f64,
        col_cost: *mut f64,
        col_lower: *mut f64,
        col_upper: *mut f64,
        row_lower: *mut f64,
        row_upper: *mut f64,
        a_start: *mut HighsInt,
        a_index: *mut HighsInt,
        a_value: *mut f64,
        integrality: *mut HighsInt,
    ) -> HighsInt;
}
unsafe extern "C" {
    #[doc = " Get the data from a HiGHS presolved LP.\n\n The input arguments have the same meaning (in a different order) to those\n used in `Highs_passModel`.\n\n Note that all arrays must be pre-allocated to the correct size before calling\n `Highs_getModel`. Use the following query methods to check the appropriate\n size:\n  - `Highs_getPresolvedNumCol`\n  - `Highs_getPresolvedNumRow`\n  - `Highs_getPresolvedNumNz`\n\n @returns A `kHighsStatus` constant indicating whether the call succeeded."]
    pub fn Highs_getPresolvedLp(
        highs: *const ::std::os::raw::c_void,
        a_format: HighsInt,
        num_col: *mut HighsInt,
        num_row: *mut HighsInt,
        num_nz: *mut HighsInt,
        sense: *mut HighsInt,
        offset: *mut f64,
        col_cost: *mut f64,
        col_lower: *mut f64,
        col_upper: *mut f64,
        row_lower: *mut f64,
        row_upper: *mut f64,
        a_start: *mut HighsInt,
        a_index: *mut HighsInt,
        a_value: *mut f64,
        integrality: *mut HighsInt,
    ) -> HighsInt;
}
unsafe extern "C" {
    #[doc = " Set a primal (and possibly dual) solution as a starting point, then run\n crossover to compute a basic feasible solution.\n\n @param highs      A pointer to the Highs instance.\n @param num_col    The number of variables.\n @param num_row    The number of rows.\n @param col_value  An array of length [num_col] with optimal primal solution\n                   for each column.\n @param col_dual   An array of length [num_col] with optimal dual solution for\n                   each column. May be `NULL`, in which case no dual solution\n                   is passed.\n @param row_dual   An array of length [num_row] with optimal dual solution for\n                   each row. . May be `NULL`, in which case no dual solution\n                   is passed.\n\n @returns A `kHighsStatus` constant indicating whether the call succeeded."]
    pub fn Highs_crossover(
        highs: *mut ::std::os::raw::c_void,
        num_col: HighsInt,
        num_row: HighsInt,
        col_value: *const f64,
        col_dual: *const f64,
        row_dual: *const f64,
    ) -> HighsInt;
}
unsafe extern "C" {
    #[doc = " Compute the ranging information for all costs and bounds. For\n nonbasic variables the ranging information is relative to the\n active bound. For basic variables the ranging information relates\n to...\n\n For any values that are not required, pass NULL.\n\n @param highs                  A pointer to the Highs instance.\n @param col_cost_up_value      The upper range of the cost value\n @param col_cost_up_objective  The objective at the upper cost range\n @param col_cost_up_in_var     The variable entering the basis at the upper\n                               cost range\n @param col_cost_up_ou_var     The variable leaving the basis at the upper\n                               cost range\n @param col_cost_dn_value      The lower range of the cost value\n @param col_cost_dn_objective  The objective at the lower cost range\n @param col_cost_dn_in_var     The variable entering the basis at the lower\n                               cost range\n @param col_cost_dn_ou_var     The variable leaving the basis at the lower\n                               cost range\n @param col_bound_up_value     The upper range of the column bound value\n @param col_bound_up_objective The objective at the upper column bound range\n @param col_bound_up_in_var    The variable entering the basis at the upper\n                               column bound range\n @param col_bound_up_ou_var    The variable leaving the basis at the upper\n                               column bound range\n @param col_bound_dn_value     The lower range of the column bound value\n @param col_bound_dn_objective The objective at the lower column bound range\n @param col_bound_dn_in_var    The variable entering the basis at the lower\n                               column bound range\n @param col_bound_dn_ou_var    The variable leaving the basis at the lower\n                               column bound range\n @param row_bound_up_value     The upper range of the row bound value\n @param row_bound_up_objective The objective at the upper row bound range\n @param row_bound_up_in_var    The variable entering the basis at the upper\n                               row bound range\n @param row_bound_up_ou_var    The variable leaving the basis at the upper row\n                               bound range\n @param row_bound_dn_value     The lower range of the row bound value\n @param row_bound_dn_objective The objective at the lower row bound range\n @param row_bound_dn_in_var    The variable entering the basis at the lower\n                               row bound range\n @param row_bound_dn_ou_var    The variable leaving the basis at the lower row\n                               bound range\n\n @returns A `kHighsStatus` constant indicating whether the call succeeded."]
    pub fn Highs_getRanging(
        highs: *mut ::std::os::raw::c_void,
        col_cost_up_value: *mut f64,
        col_cost_up_objective: *mut f64,
        col_cost_up_in_var: *mut HighsInt,
        col_cost_up_ou_var: *mut HighsInt,
        col_cost_dn_value: *mut f64,
        col_cost_dn_objective: *mut f64,
        col_cost_dn_in_var: *mut HighsInt,
        col_cost_dn_ou_var: *mut HighsInt,
        col_bound_up_value: *mut f64,
        col_bound_up_objective: *mut f64,
        col_bound_up_in_var: *mut HighsInt,
        col_bound_up_ou_var: *mut HighsInt,
        col_bound_dn_value: *mut f64,
        col_bound_dn_objective: *mut f64,
        col_bound_dn_in_var: *mut HighsInt,
        col_bound_dn_ou_var: *mut HighsInt,
        row_bound_up_value: *mut f64,
        row_bound_up_objective: *mut f64,
        row_bound_up_in_var: *mut HighsInt,
        row_bound_up_ou_var: *mut HighsInt,
        row_bound_dn_value: *mut f64,
        row_bound_dn_objective: *mut f64,
        row_bound_dn_in_var: *mut HighsInt,
        row_bound_dn_ou_var: *mut HighsInt,
    ) -> HighsInt;
}
unsafe extern "C" {
    #[doc = " Compute the solution corresponding to a (possibly weighted) sum of\n (allowable) infeasibilities in an LP/MIP.\n\n If local penalties are not defined, pass NULL, and the global\n penalty will be used. Negative penalty values imply that the bound\n or RHS value cannot be violated\n\n @param highs                             A pointer to the Highs instance.\n @param const double global_lower_penalty The penalty for violating lower\n bounds on variables\n @param const double global_upper_penalty The penalty for violating upper\n bounds on variables\n @param const double global_rhs_penalty   The penalty for violating constraint\n RHS values\n @param const double* local_lower_penalty The penalties for violating specific\n lower bounds on variables\n @param const double* local_upper_penalty The penalties for violating specific\n upper bounds on variables\n @param const double* local_rhs_penalty   The penalties for violating specific\n constraint RHS values\n @returns A `kHighsStatus` constant indicating whether the call succeeded."]
    pub fn Highs_feasibilityRelaxation(
        highs: *mut ::std::os::raw::c_void,
        global_lower_penalty: f64,
        global_upper_penalty: f64,
        global_rhs_penalty: f64,
        local_lower_penalty: *const f64,
        local_upper_penalty: *const f64,
        local_rhs_penalty: *const f64,
    ) -> HighsInt;
}
unsafe extern "C" {
    #[doc = " Releases all resources held by the global scheduler instance.\n\n It is not thread-safe to call this function while calling `Highs_run` or one\n of the `Highs_XXXcall` methods on any other Highs instance in any thread.\n\n After this function has terminated, it is guaranteed that eventually all\n previously created scheduler threads will terminate and allocated memory will\n be released.\n\n After this function has returned, the option value for the number of threads\n may be altered to a new value before the next call to `Highs_run` or one of\n the `Highs_XXXcall` methods.\n\n @param blocking   If the `blocking` parameter has a nonzero value, then this\n                   function will not return until all memory is freed, which\n                   might be desirable when debugging heap memory, but it\n                   requires the calling thread to wait for all scheduler\n                   threads to wake-up which is usually not necessary.\n\n @returns No status is returned since the function call cannot fail. Calling\n this function while any Highs instance is in use on any thread is\n undefined behavior and may cause crashes, but cannot be detected and hence\n is fully in the callers responsibility."]
    pub fn Highs_resetGlobalScheduler(blocking: HighsInt);
}
unsafe extern "C" {
    #[doc = " Get a void* pointer to a callback data item\n\n @param data_out      A pointer to the HighsCallbackDataOut instance.\n @param item_name     The name of the item.\n\n @returns A void* pointer to the callback data item, or NULL if item_name not\n valid"]
    pub fn Highs_getCallbackDataOutItem(
        data_out: *const HighsCallbackDataOut,
        item_name: *const ::std::os::raw::c_char,
    ) -> *const ::std::os::raw::c_void;
}
unsafe extern "C" {
    #[doc = " Set a solution within a callback by passing a subset of the values.\n\n For any values that are unavailable/unknown, pass kHighsUndefined.\n\n @param data_in     A pointer to the callback input data instance.\n @param num_entries Number of variables in the set\n @param value       An array of length [num_entries <= num_col] with\n                    column solution values.\n\n @returns A `kHighsStatus` constant indicating whether the call succeeded."]
    pub fn Highs_setCallbackSolution(
        data_in: *mut HighsCallbackDataIn,
        num_entries: HighsInt,
        value: *const f64,
    ) -> HighsInt;
}
unsafe extern "C" {
    #[doc = " Set a partial primal solution by passing values for a set of variables,\n within a valid callback.\n\n @param data_in     A pointer to the callback input data instance.\n @param num_entries Number of variables in the set\n @param index       Indices of variables in the set\n @param value       Values of variables in the set\n\n @returns A `kHighsStatus` constant indicating whether the call succeeded."]
    pub fn Highs_setCallbackSparseSolution(
        data_in: *mut HighsCallbackDataIn,
        num_entries: HighsInt,
        index: *const HighsInt,
        value: *const f64,
    ) -> HighsInt;
}
unsafe extern "C" {
    #[doc = " Finds a feasible solution for a given (partial) primal user solution,\n within a valid callback.\n\n On success, the user solution is updated within the callback input data\n instance.\n\n @returns A `kHighsStatus` constant indicating whether the call succeeded."]
    pub fn Highs_repairCallbackSolution(data_in: *mut HighsCallbackDataIn) -> HighsInt;
}
unsafe extern "C" {
    #[doc = " Return the HiGHS compilation date.\n\n @returns Thse HiGHS compilation date."]
    pub fn Highs_compilationDate() -> *const ::std::os::raw::c_char;
}
unsafe extern "C" {
    pub fn Highs_call(
        num_col: HighsInt,
        num_row: HighsInt,
        num_nz: HighsInt,
        col_cost: *const f64,
        col_lower: *const f64,
        col_upper: *const f64,
        row_lower: *const f64,
        row_upper: *const f64,
        a_start: *const HighsInt,
        a_index: *const HighsInt,
        a_value: *const f64,
        col_value: *mut f64,
        col_dual: *mut f64,
        row_value: *mut f64,
        row_dual: *mut f64,
        col_basis_status: *mut HighsInt,
        row_basis_status: *mut HighsInt,
        model_status: *mut HighsInt,
    ) -> HighsInt;
}
unsafe extern "C" {
    pub fn Highs_runQuiet(highs: *mut ::std::os::raw::c_void) -> HighsInt;
}
unsafe extern "C" {
    pub fn Highs_setHighsLogfile(
        highs: *mut ::std::os::raw::c_void,
        logfile: *const ::std::os::raw::c_void,
    ) -> HighsInt;
}
unsafe extern "C" {
    pub fn Highs_setHighsOutput(
        highs: *mut ::std::os::raw::c_void,
        outputfile: *const ::std::os::raw::c_void,
    ) -> HighsInt;
}
unsafe extern "C" {
    pub fn Highs_getIterationCount(highs: *const ::std::os::raw::c_void) -> HighsInt;
}
unsafe extern "C" {
    pub fn Highs_getSimplexIterationCount(highs: *const ::std::os::raw::c_void) -> HighsInt;
}
unsafe extern "C" {
    pub fn Highs_setHighsBoolOptionValue(
        highs: *mut ::std::os::raw::c_void,
        option: *const ::std::os::raw::c_char,
        value: HighsInt,
    ) -> HighsInt;
}
unsafe extern "C" {
    pub fn Highs_setHighsIntOptionValue(
        highs: *mut ::std::os::raw::c_void,
        option: *const ::std::os::raw::c_char,
        value: HighsInt,
    ) -> HighsInt;
}
unsafe extern "C" {
    pub fn Highs_setHighsDoubleOptionValue(
        highs: *mut ::std::os::raw::c_void,
        option: *const ::std::os::raw::c_char,
        value: f64,
    ) -> HighsInt;
}
unsafe extern "C" {
    pub fn Highs_setHighsStringOptionValue(
        highs: *mut ::std::os::raw::c_void,
        option: *const ::std::os::raw::c_char,
        value: *const ::std::os::raw::c_char,
    ) -> HighsInt;
}
unsafe extern "C" {
    pub fn Highs_setHighsOptionValue(
        highs: *mut ::std::os::raw::c_void,
        option: *const ::std::os::raw::c_char,
        value: *const ::std::os::raw::c_char,
    ) -> HighsInt;
}
unsafe extern "C" {
    pub fn Highs_getHighsBoolOptionValue(
        highs: *const ::std::os::raw::c_void,
        option: *const ::std::os::raw::c_char,
        value: *mut HighsInt,
    ) -> HighsInt;
}
unsafe extern "C" {
    pub fn Highs_getHighsIntOptionValue(
        highs: *const ::std::os::raw::c_void,
        option: *const ::std::os::raw::c_char,
        value: *mut HighsInt,
    ) -> HighsInt;
}
unsafe extern "C" {
    pub fn Highs_getHighsDoubleOptionValue(
        highs: *const ::std::os::raw::c_void,
        option: *const ::std::os::raw::c_char,
        value: *mut f64,
    ) -> HighsInt;
}
unsafe extern "C" {
    pub fn Highs_getHighsStringOptionValue(
        highs: *const ::std::os::raw::c_void,
        option: *const ::std::os::raw::c_char,
        value: *mut ::std::os::raw::c_char,
    ) -> HighsInt;
}
unsafe extern "C" {
    pub fn Highs_getHighsOptionType(
        highs: *const ::std::os::raw::c_void,
        option: *const ::std::os::raw::c_char,
        type_: *mut HighsInt,
    ) -> HighsInt;
}
unsafe extern "C" {
    pub fn Highs_resetHighsOptions(highs: *mut ::std::os::raw::c_void) -> HighsInt;
}
unsafe extern "C" {
    pub fn Highs_getHighsIntInfoValue(
        highs: *const ::std::os::raw::c_void,
        info: *const ::std::os::raw::c_char,
        value: *mut HighsInt,
    ) -> HighsInt;
}
unsafe extern "C" {
    pub fn Highs_getHighsDoubleInfoValue(
        highs: *const ::std::os::raw::c_void,
        info: *const ::std::os::raw::c_char,
        value: *mut f64,
    ) -> HighsInt;
}
unsafe extern "C" {
    pub fn Highs_getNumCols(highs: *const ::std::os::raw::c_void) -> HighsInt;
}
unsafe extern "C" {
    pub fn Highs_getNumRows(highs: *const ::std::os::raw::c_void) -> HighsInt;
}
unsafe extern "C" {
    pub fn Highs_getHighsInfinity(highs: *const ::std::os::raw::c_void) -> f64;
}
unsafe extern "C" {
    pub fn Highs_getHighsRunTime(highs: *const ::std::os::raw::c_void) -> f64;
}
unsafe extern "C" {
    pub fn Highs_setOptionValue(
        highs: *mut ::std::os::raw::c_void,
        option: *const ::std::os::raw::c_char,
        value: *const ::std::os::raw::c_char,
    ) -> HighsInt;
}
unsafe extern "C" {
    pub fn Highs_getScaledModelStatus(highs: *const ::std::os::raw::c_void) -> HighsInt;
}
