diff --git a/extern/filereaderlp/reader.cpp b/extern/filereaderlp/reader.cpp
index 9f86079f10..abe56759f8 100644
--- a/extern/filereaderlp/reader.cpp
+++ b/extern/filereaderlp/reader.cpp
@@ -828,7 +828,7 @@ void Reader::splittokens() {
         // Current section is non-trivial, so mark its end, using the
         // value of currentsection to indicate that there is no open
         // section
-        assert(debug_open_section);
+        lpassert(debug_open_section);
         sectiontokens[currentsection].second = it;
         debug_open_section = false;
         currentsection = LpSectionKeyword::NONE;
@@ -846,12 +846,12 @@ void Reader::splittokens() {
       // the current section
       if (currentsection != LpSectionKeyword::NONE &&
           currentsection != next->keyword) {
-        assert(debug_open_section);
+        lpassert(debug_open_section);
         sectiontokens[currentsection].second = it;
         debug_open_section = false;
       }
       currentsection = LpSectionKeyword::NONE;
-      assert(!debug_open_section);
+      lpassert(!debug_open_section);
       continue;
     }
     // Next section is non-empty
@@ -862,16 +862,16 @@ void Reader::splittokens() {
       lpassert(sectiontokens.count(currentsection) == 0);
       // Remember the beginning of the new section: its the token
       // following the current one
-      assert(!debug_open_section);
+      lpassert(!debug_open_section);
       sectiontokens[currentsection].first = next;
       debug_open_section = true;
     }
     // Always ends with either an open section or a section type of
     // LpSectionKeyword::NONE
-    assert(debug_open_section != (currentsection == LpSectionKeyword::NONE));
+    lpassert(debug_open_section != (currentsection == LpSectionKeyword::NONE));
   }
   // Check that the last section has been closed
-  assert(currentsection == LpSectionKeyword::NONE);
+  lpassert(currentsection == LpSectionKeyword::NONE);
 }
 
 void Reader::processtokens() {
diff --git a/src/lp_data/Highs.cpp b/src/lp_data/Highs.cpp
index f6f732c788..3acf20f5a2 100644
--- a/src/lp_data/Highs.cpp
+++ b/src/lp_data/Highs.cpp
@@ -3150,17 +3150,18 @@ HighsStatus Highs::callSolveQp() {
   return_status = interpretCallStatus(options_.log_options, call_status,
                                       return_status, "QpSolver");
   if (return_status == HighsStatus::kError) return return_status;
-  model_status_ = runtime.status == ProblemStatus::OPTIMAL
+  model_status_ = runtime.status == QpModelStatus::OPTIMAL
                       ? HighsModelStatus::kOptimal
-                  : runtime.status == ProblemStatus::UNBOUNDED
+                  : runtime.status == QpModelStatus::UNBOUNDED
                       ? HighsModelStatus::kUnbounded
-                  : runtime.status == ProblemStatus::INFEASIBLE
+                  : runtime.status == QpModelStatus::INFEASIBLE
                       ? HighsModelStatus::kInfeasible
-                  : runtime.status == ProblemStatus::ITERATIONLIMIT
+                  : runtime.status == QpModelStatus::ITERATIONLIMIT
                       ? HighsModelStatus::kIterationLimit
-                  : runtime.status == ProblemStatus::TIMELIMIT
+                  : runtime.status == QpModelStatus::TIMELIMIT
                       ? HighsModelStatus::kTimeLimit
                       : HighsModelStatus::kNotset;
+  // extract variable values
   solution_.col_value.resize(lp.num_col_);
   solution_.col_dual.resize(lp.num_col_);
   const double objective_multiplier = lp.sense_ == ObjSense::kMinimize ? 1 : -1;
@@ -3169,6 +3170,7 @@ HighsStatus Highs::callSolveQp() {
     solution_.col_dual[iCol] =
         objective_multiplier * runtime.dualvar.value[iCol];
   }
+  // extract constraint activity
   solution_.row_value.resize(lp.num_row_);
   solution_.row_dual.resize(lp.num_row_);
   // Negate the vector and Hessian
@@ -3179,6 +3181,35 @@ HighsStatus Highs::callSolveQp() {
   }
   solution_.value_valid = true;
   solution_.dual_valid = true;
+
+  // extract basis status
+  basis_.col_status.resize(lp.num_col_);
+  basis_.row_status.resize(lp.num_row_);
+
+  for (HighsInt i = 0; i < lp.num_col_; i++) {
+    if (runtime.status_var[i] == BasisStatus::ActiveAtLower) {
+      basis_.col_status[i] = HighsBasisStatus::kLower;
+    } else if (runtime.status_var[i] == BasisStatus::ActiveAtUpper) {
+      basis_.col_status[i] = HighsBasisStatus::kUpper;
+    } else if (runtime.status_var[i] == BasisStatus::InactiveInBasis) {
+      basis_.col_status[i] = HighsBasisStatus::kNonbasic;
+    } else {
+      basis_.col_status[i] = HighsBasisStatus::kBasic;
+    }
+  }
+
+  for (HighsInt i = 0; i < lp.num_row_; i++) {
+    if (runtime.status_con[i] == BasisStatus::ActiveAtLower) {
+      basis_.row_status[i] = HighsBasisStatus::kLower;
+    } else if (runtime.status_con[i] == BasisStatus::ActiveAtUpper) {
+      basis_.row_status[i] = HighsBasisStatus::kUpper;
+    } else if (runtime.status_con[i] == BasisStatus::InactiveInBasis) {
+      basis_.row_status[i] = HighsBasisStatus::kNonbasic;
+    } else {
+      basis_.row_status[i] = HighsBasisStatus::kBasic;
+    }
+  }
+
   // Get the objective and any KKT failures
   info_.objective_function_value = model_.objectiveValue(solution_.col_value);
   getKktFailures(options_, model_, solution_, basis_, info_);
diff --git a/src/presolve/HighsPostsolveStack.cpp b/src/presolve/HighsPostsolveStack.cpp
index 13ad08249d..0196514612 100644
--- a/src/presolve/HighsPostsolveStack.cpp
+++ b/src/presolve/HighsPostsolveStack.cpp
@@ -568,7 +568,7 @@ void HighsPostsolveStack::DuplicateRow::undo(const HighsOptions& options,
 void HighsPostsolveStack::DuplicateColumn::undo(const HighsOptions& options,
                                                 HighsSolution& solution,
                                                 HighsBasis& basis) const {
-  const bool debug_report = true;
+  const bool debug_report = false;
   const double mergeVal = solution.col_value[col];
 
   auto okResidual = [&](const double x, const double y) {
@@ -986,7 +986,7 @@ void HighsPostsolveStack::DuplicateColumn::undoFix(
       options.primal_feasibility_tolerance;
   std::vector<double>& col_value = solution.col_value;
   const bool allow_assert = false;
-  const bool debug_report = true;
+  const bool debug_report = false;
   //=============================================================================================
 
   auto isInteger = [&](const double v) {
diff --git a/src/qpsolver/basis.cpp b/src/qpsolver/basis.cpp
index 384b962aac..ec1cabc920 100644
--- a/src/qpsolver/basis.cpp
+++ b/src/qpsolver/basis.cpp
@@ -4,17 +4,23 @@
 #include <memory>
 
 Basis::Basis(Runtime& rt, std::vector<HighsInt> active,
-             std::vector<BasisStatus> lower, std::vector<HighsInt> inactive)
+             std::vector<BasisStatus> status, std::vector<HighsInt> inactive)
     : runtime(rt),
       buffer_column_aq(rt.instance.num_var),
       buffer_row_ep(rt.instance.num_var) {
   buffer_vec2hvec.setup(rt.instance.num_var);
+
+  for (HighsInt i=0; i<runtime.instance.num_var + runtime.instance.num_con; i++) {
+    basisstatus[i] = BasisStatus::Inactive;
+  }
+
   for (size_t i = 0; i < active.size(); i++) {
     activeconstraintidx.push_back(active[i]);
-    basisstatus[activeconstraintidx[i]] = lower[i];
+    basisstatus[activeconstraintidx[i]] = status[i];
   }
-  for (HighsInt i : inactive) {
-    nonactiveconstraintsidx.push_back(i);
+  for (size_t i=0; i<inactive.size(); i++) {
+    nonactiveconstraintsidx.push_back(inactive[i]);
+    basisstatus[nonactiveconstraintsidx[i]] = BasisStatus::InactiveInBasis;
   }
 
   Atran = rt.instance.A.t();
@@ -99,16 +105,17 @@ void Basis::report() {
 void Basis::deactivate(HighsInt conid) {
   // printf("deact %" HIGHSINT_FORMAT "\n", conid);
   assert(contains(activeconstraintidx, conid));
-  basisstatus.erase(conid);
+  basisstatus[conid] = BasisStatus::InactiveInBasis;
   remove(activeconstraintidx, conid);
   nonactiveconstraintsidx.push_back(conid);
 }
 
-QpSolverStatus Basis::activate(const Settings& settings, HighsInt conid, BasisStatus atlower,
+QpSolverStatus Basis::activate(const Settings& settings, HighsInt conid, BasisStatus newstatus,
                                HighsInt nonactivetoremove, Pricing* pricing) {
   // printf("activ %" HIGHSINT_FORMAT "\n", conid);
   if (!contains(activeconstraintidx, (HighsInt)conid)) {
-    basisstatus[conid] = atlower;
+    basisstatus[nonactivetoremove] = BasisStatus::Inactive;
+    basisstatus[conid] = newstatus;
     activeconstraintidx.push_back(conid);
   } else {
     printf("Degeneracy? constraint %" HIGHSINT_FORMAT " already in basis\n",
diff --git a/src/qpsolver/basis.hpp b/src/qpsolver/basis.hpp
index 69058e44cc..136d70a00f 100644
--- a/src/qpsolver/basis.hpp
+++ b/src/qpsolver/basis.hpp
@@ -14,14 +14,6 @@
 #include "util/HVector.h"
 #include "util/HVectorBase.h"
 
-enum class BasisStatus {
-  Default,
-  ActiveAtLower = 1,
-  ActiveAtUpper,
-  ActiveAtZero,
-  Inactive
-};
-
 class Basis {
   HVector buffer_vec2hvec;
 
diff --git a/src/qpsolver/feasibility_highs.hpp b/src/qpsolver/feasibility_highs.hpp
index 22c1d71668..d6386b3987 100644
--- a/src/qpsolver/feasibility_highs.hpp
+++ b/src/qpsolver/feasibility_highs.hpp
@@ -70,7 +70,7 @@ static void computestartingpoint_highs(Runtime& runtime, CrashSolution& result)
 
   HighsStatus status = highs.run();
   if (status != HighsStatus::kOk) {
-    runtime.status = ProblemStatus::ERROR;
+    runtime.status = QpModelStatus::ERROR;
     return;
   }
 
@@ -78,7 +78,7 @@ static void computestartingpoint_highs(Runtime& runtime, CrashSolution& result)
 
   HighsModelStatus phase1stat = highs.getModelStatus();
   if (phase1stat == HighsModelStatus::kInfeasible) {
-    runtime.status = ProblemStatus::INFEASIBLE;
+    runtime.status = QpModelStatus::INFEASIBLE;
     return;
   }
 
diff --git a/src/qpsolver/feasibility_quass.hpp b/src/qpsolver/feasibility_quass.hpp
index caea5b9d61..c401c4b6f6 100644
--- a/src/qpsolver/feasibility_quass.hpp
+++ b/src/qpsolver/feasibility_quass.hpp
@@ -57,7 +57,7 @@ void computestartingpoint_quass(Runtime& runtime, CrashSolution& result) {
 
   // HighsModelStatus phase1stat = highs.getModelStatus();
   // if (phase1stat == HighsModelStatus::kInfeasible) {
-  //   runtime.status = ProblemStatus::INFEASIBLE;
+  //   runtime.status = QpModelStatus::INFEASIBLE;
   //   return;
   // }
 
diff --git a/src/qpsolver/qpconst.hpp b/src/qpsolver/qpconst.hpp
index 6225037f20..0d8b75f60c 100644
--- a/src/qpsolver/qpconst.hpp
+++ b/src/qpsolver/qpconst.hpp
@@ -4,4 +4,22 @@
 
 enum class QpSolverStatus { OK, NOTPOSITIVDEFINITE, DEGENERATE };
 
+enum class QpModelStatus {
+  INDETERMINED,
+  OPTIMAL,
+  UNBOUNDED,
+  INFEASIBLE,
+  ITERATIONLIMIT,
+  TIMELIMIT,
+  ERROR
+};
+
+enum class BasisStatus {
+  Inactive,
+  ActiveAtLower = 1,
+  ActiveAtUpper,
+  InactiveInBasis
+};
+
+
 #endif
diff --git a/src/qpsolver/quass.cpp b/src/qpsolver/quass.cpp
index 55468c7d0e..3e5a1a664e 100644
--- a/src/qpsolver/quass.cpp
+++ b/src/qpsolver/quass.cpp
@@ -29,7 +29,7 @@ void Quass::solve() {
   runtime.instance = runtime.perturbed;
   CrashSolution crash(runtime.instance.num_var, runtime.instance.num_con);
   computestartingpoint(runtime, crash);
-  if (runtime.status != ProblemStatus::INDETERMINED) {
+  if (runtime.status != QpModelStatus::INDETERMINED) {
     return;
   }
   Basis basis(runtime, crash.active, crash.rowstatus, crash.inactive);
@@ -246,13 +246,13 @@ void Quass::solve(const Vector& x0, const Vector& ra, Basis& b0) {
   while (true) {
     // check iteration limit
     if (runtime.statistics.num_iterations >= runtime.settings.iterationlimit) {
-      runtime.status = ProblemStatus::ITERATIONLIMIT;
+      runtime.status = QpModelStatus::ITERATIONLIMIT;
       break; 
     }
 
     // check time limit
     if (runtime.timer.readRunHighsClock() >= runtime.settings.timelimit) {
-      runtime.status = ProblemStatus::TIMELIMIT;
+      runtime.status = QpModelStatus::TIMELIMIT;
       break;
     }
 
@@ -272,7 +272,7 @@ void Quass::solve(const Vector& x0, const Vector& ra, Basis& b0) {
     if (atfsep) {
       HighsInt minidx = pricing->price(runtime.primal, gradient.getGradient());
       if (minidx == -1) {
-        runtime.status = ProblemStatus::OPTIMAL;
+        runtime.status = QpModelStatus::OPTIMAL;
         break;
       }
 
@@ -295,7 +295,7 @@ void Quass::solve(const Vector& x0, const Vector& ra, Basis& b0) {
       if (!zero_curvature_direction) {
         status = factor.expand(buffer_yp, buffer_gyp, buffer_l, buffer_m);
         if (status != QpSolverStatus::OK) {
-          runtime.status = ProblemStatus::INDETERMINED;
+          runtime.status = QpModelStatus::INDETERMINED;
           return;
         }
       }
@@ -317,7 +317,7 @@ void Quass::solve(const Vector& x0, const Vector& ra, Basis& b0) {
         status = reduce(runtime, basis, stepres.limitingconstraint, buffer_d,
                         maxabsd, constrainttodrop);
         if (status != QpSolverStatus::OK) {
-          runtime.status = ProblemStatus::INDETERMINED;
+          runtime.status = QpModelStatus::INDETERMINED;
           return;
         }
         if (!zero_curvature_direction) {
@@ -334,7 +334,7 @@ void Quass::solve(const Vector& x0, const Vector& ra, Basis& b0) {
                                     : BasisStatus::ActiveAtUpper,
                                 constrainttodrop, pricing.get());
         if (status != QpSolverStatus::OK) {
-          runtime.status = ProblemStatus::INDETERMINED;
+          runtime.status = QpModelStatus::INDETERMINED;
           return;
         }
         if (basis.getnumactive() != runtime.instance.num_var) {
@@ -344,7 +344,7 @@ void Quass::solve(const Vector& x0, const Vector& ra, Basis& b0) {
         if (stepres.alpha ==
             std::numeric_limits<double>::infinity()) {
           // unbounded
-          runtime.status = ProblemStatus::UNBOUNDED;
+          runtime.status = QpModelStatus::UNBOUNDED;
           return;
         }
         atfsep = false;
@@ -377,6 +377,15 @@ void Quass::solve(const Vector& x0, const Vector& ra, Basis& b0) {
     }
   }
 
+  // extract basis status
+  for (HighsInt i=0; i<runtime.instance.num_var; i++) {
+    runtime.status_var[i] = basis.getstatus(i);
+  }
+
+  for (HighsInt i=0; i<runtime.instance.num_con; i++) {
+    runtime.status_con[i] = basis.getstatus(runtime.instance.num_var + i);
+  }
+
   if (basis.getnumactive() == runtime.instance.num_var) {
     runtime.primal = basis.recomputex(runtime.instance);
   }
diff --git a/src/qpsolver/result.hpp b/src/qpsolver/result.hpp
deleted file mode 100644
index 2773a6ccb4..0000000000
--- a/src/qpsolver/result.hpp
+++ /dev/null
@@ -1,17 +0,0 @@
-#ifndef __SRC_LIB_RESULT_HPP__
-#define __SRC_LIB_RESULT_HPP__
-
-#include "vector.hpp"
-
-enum class ProblemStatus { INDETERMINED, OPTIMAL, UNBOUNDED, INFEASIBLE };
-
-struct Result {
-  ProblemStatus status;
-  Vector primalsolution;
-  Vector dualsolution;
-
-  Result(HighsInt num_var, HighsInt num_con)
-      : primalsolution(num_var), dualsolution(num_con) {}
-};
-
-#endif
diff --git a/src/qpsolver/runtime.hpp b/src/qpsolver/runtime.hpp
index 7f07c60feb..03ee6e68d3 100644
--- a/src/qpsolver/runtime.hpp
+++ b/src/qpsolver/runtime.hpp
@@ -6,16 +6,7 @@
 #include "instance.hpp"
 #include "settings.hpp"
 #include "statistics.hpp"
-
-enum class ProblemStatus {
-  INDETERMINED,
-  OPTIMAL,
-  UNBOUNDED,
-  INFEASIBLE,
-  ITERATIONLIMIT,
-  TIMELIMIT,
-  ERROR
-};
+#include "qpsolver/qpconst.hpp"
 
 struct Runtime {
   Instance instance;
@@ -32,7 +23,10 @@ struct Runtime {
   Vector rowactivity;
   Vector dualvar;
   Vector dualcon;
-  ProblemStatus status = ProblemStatus::INDETERMINED;
+  QpModelStatus status = QpModelStatus::INDETERMINED;
+
+  std::vector<BasisStatus> status_var;
+  std::vector<BasisStatus> status_con;
 
   Runtime(Instance& inst, HighsTimer& ht)
       : instance(inst),
@@ -40,7 +34,9 @@ struct Runtime {
         primal(Vector(instance.num_var)),
         rowactivity(Vector(instance.num_con)),
         dualvar(instance.num_var),
-        dualcon(instance.num_con) {}
+        dualcon(instance.num_con),
+        status_var(instance.num_var),
+        status_con(instance.num_con) {}
 };
 
 #endif