diff --git a/src/solver.cpp b/src/solver.cpp
index f13ca43c1..6ca6e7c1f 100644
--- a/src/solver.cpp
+++ b/src/solver.cpp
@@ -164,7 +164,8 @@ bicgstab_euler(const P dt, imex_flag imex,
 template<typename P, resource resrc>
 gmres_info<P>
 simple_gmres_euler(adapt::distributed_grid<P> const &adaptive_grid, int const elem_size,
-                   P dt, kronmult_matrix<P> const &mat,
+                   P const dt, imex_flag imex,
+                   kron_operators<P> const &ops,
                    fk::vector<P, mem_type::owner, resrc> &x,
                    fk::vector<P, mem_type::owner, resrc> const &b,
                    int const restart, int const max_iter, P const tolerance)
@@ -175,12 +176,12 @@ simple_gmres_euler(adapt::distributed_grid<P> const &adaptive_grid, int const el
         adaptive_grid, elem_size,
         [&](P const alpha, fk::vector<P, mem_type::view, resrc> const x_in,
             P const beta, fk::vector<P, mem_type::view, resrc> y) -> void {
-          tools::time_event performance("kronmult - implicit", mat.flops());
+          tools::time_event performance("kronmult - implicit", ops.flops());
           auto plan = adaptive_grid.get_distrib_plan();
           // switch to elem_size?
           auto const size_r = elem_size * adaptive_grid.get_subgrid(get_rank()).nrows();
           fk::vector<P, mem_type::owner, resrc> y_local(size_r), y_tmp(size_r);
-          mat.template apply<resrc>(-dt * alpha, x_in.data(), P{0}, y_local.data());
+          ops.template apply<resrc>(-dt * alpha, x_in.data(), P{0}, y_local.data());
           reduce_results(y_local, y_tmp, plan, get_rank());
           y_local.resize(y.size());
           exchange_results(y_tmp, y_local, elem_size, plan, get_rank());
@@ -194,9 +195,8 @@ simple_gmres_euler(adapt::distributed_grid<P> const &adaptive_grid, int const el
   ignore(adaptive_grid);
   ignore(elem_size);
 #endif
-  return simple_gmres_euler(dt, mat, x, b, restart, max_iter, tolerance);
+  return simple_gmres_euler(dt, imex, ops, x, b, restart, max_iter, tolerance);
 }
-#endif
 
 /*! Generates a default number inner iterations when no use input is given
  * \param num_cols Number of columns in the A matrix.
@@ -811,8 +811,7 @@ simple_gmres_euler(const double dt, imex_flag imex,
                    fk::vector<double, mem_type::owner, resource::device> const &b,
                    int const restart, int const max_iter, double const tolerance);
 template gmres_info<double>
-bicgstab_euler(adapt::distributed_grid<double> const &adaptive_grid, int const elem_size,
-               const double dt, imex_flag imex,
+bicgstab_euler(const double dt, imex_flag imex,
                kron_operators<double> const &ops,
                fk::vector<double, mem_type::owner, resource::device> &x,
                fk::vector<double, mem_type::owner, resource::device> const &b,
@@ -820,14 +819,14 @@ bicgstab_euler(adapt::distributed_grid<double> const &adaptive_grid, int const e
 
 template gmres_info<double>
 simple_gmres_euler(adapt::distributed_grid<double> const &adaptive_grid, int const elem_size,
-                   const double dt, kronmult_matrix<double> const &mat,
+                   const double dt, kron_operators<double> const &ops,
                    fk::vector<double> &x, fk::vector<double> const &b,
                    int const restart, int const max_iter,
                    double const tolerance);
 
 template gmres_info<double> simple_gmres_euler(
     adapt::distributed_grid<double> const &adaptive_grid, int const elem_size,
-    double const dt, kronmult_matrix<double> const &mat,
+    double const dt, kron_operators<double> const &ops,
     fk::vector<double, mem_type::owner, resource::device> &x,
     fk::vector<double, mem_type::owner, resource::device> const &b,
     int const restart, int const max_iter, double const tolerance);
@@ -859,7 +858,7 @@ bicgstab(fk::matrix<float> const &A, fk::vector<float> &x,
          int const max_iter, float const tolerance);
 
 template gmres_info<float>
-simple_gmres_euler(adapt::distributed_grid<double> const &adaptive_grid, int const elem_size,
+simple_gmres_euler(adapt::distributed_grid<float> const &adaptive_grid, int const elem_size,
                    const float dt, imex_flag imex,
                    kron_operators<float> const &ops,
                    fk::vector<float, mem_type::owner, resource::host> &x,
@@ -867,8 +866,7 @@ simple_gmres_euler(adapt::distributed_grid<double> const &adaptive_grid, int con
                    int const restart, int const max_iter, float const tolerance);
 
 template gmres_info<float>
-bicgstab_euler(adapt::distributed_grid<double> const &adaptive_grid, int const elem_size,
-               const float dt, imex_flag imex,
+bicgstab_euler(const float dt, imex_flag imex,
                kron_operators<float> const &ops,
                fk::vector<float, mem_type::owner, resource::host> &x,
                fk::vector<float, mem_type::owner, resource::host> const &b,
@@ -884,8 +882,7 @@ simple_gmres_euler(adapt::distributed_grid<double> const &adaptive_grid, int con
                    int const restart, int const max_iter, float const tolerance);
 
 template gmres_info<float>
-bicgstab_euler(adapt::distributed_grid<double> const &adaptive_grid, int const elem_size,
-              const float dt, imex_flag imex,
+bicgstab_euler(const float dt, imex_flag imex,
                kron_operators<float> const &ops,
                fk::vector<float, mem_type::owner, resource::device> &x,
                fk::vector<float, mem_type::owner, resource::device> const &b,
diff --git a/src/solver.hpp b/src/solver.hpp
index 5921d65ab..f466fc3d4 100644
--- a/src/solver.hpp
+++ b/src/solver.hpp
@@ -41,8 +41,7 @@ simple_gmres_euler(adapt::distributed_grid<P> const &adaptive_grid, int const el
 // solves ( I - dt * mat ) * x = b
 template<typename P, resource resrc>
 gmres_info<P>
-bicgstab_euler(adapt::distributed_grid<P> const &adaptive_grid, int const elem_size,
-               const P dt, imex_flag imex,
+bicgstab_euler(const P dt, imex_flag imex,
                kron_operators<P> const &ops,
                fk::vector<P, mem_type::owner, resrc> &x,
                fk::vector<P, mem_type::owner, resrc> const &b,
diff --git a/src/solver_tests.cpp b/src/solver_tests.cpp
index b39837163..a26240d8d 100644
--- a/src/solver_tests.cpp
+++ b/src/solver_tests.cpp
@@ -117,7 +117,7 @@ void test_kronmult(parser const &parse, P const tol_factor)
   asgard::kron_operators<P> operator_matrices;
   asgard::adapt::distributed_grid adaptive_grid(*pde, opts);
   operator_matrices.make(imex_flag::unspecified, *pde, adaptive_grid, opts);
-  P const dt = pde->get_dt();
+  P const dt       = pde->get_dt();
   auto const &grid = adaptive_grid.get_subgrid(get_rank());
   // perform matrix-free gmres
   fk::vector<P> const matrix_free_gmres = [&adaptive_grid, elem_size, &grid, &operator_matrices, &gold, &b,
@@ -128,16 +128,8 @@ void test_kronmult(parser const &parse, P const tol_factor)
     std::copy_n(b.data(grid.col_start * elem_size), len, b_dist.data());
     int const restart  = parser::DEFAULT_GMRES_INNER_ITERATIONS;
     int const max_iter = parser::DEFAULT_GMRES_OUTER_ITERATIONS;
-<<<<<<< HEAD
     P const tolerance  = std::is_same_v<float, P> ? 4e-6 : 1e-12;
     solver::simple_gmres_euler(adaptive_grid, elem_size, dt, imex_flag::unspecified, operator_matrices, x,
-=======
-    P const tolerance  = std::is_same_v<float, P> ? 1e-6 : 1e-12;
-#ifdef KRON_MODE_GLOBAL
-    ignore(adaptive_grid);
-    ignore(elem_size);
-    solver::simple_gmres_euler(dt, matrix_entry::regular, operator_matrices.kglobal, x,
->>>>>>> 1f21f3c7... revert precision regressions
                                b, restart, max_iter, tolerance);
     return x;
   }();
@@ -151,7 +143,7 @@ void test_kronmult(parser const &parse, P const tol_factor)
     fk::vector<P> x(gold);
     int const max_iter = parser::DEFAULT_GMRES_OUTER_ITERATIONS;
     P const tolerance  = std::is_same_v<float, P> ? 1e-6 : 1e-12;
-    solver::bicgstab_euler(adaptive_grid, elem_size, dt, imex_flag::unspecified, operator_matrices, x,
+    solver::bicgstab_euler(dt, imex_flag::unspecified, operator_matrices, x,
                            b, max_iter, tolerance);
     return x;
   }();
diff --git a/src/time_advance.cpp b/src/time_advance.cpp
index 643685514..e86a149c3 100644
--- a/src/time_advance.cpp
+++ b/src/time_advance.cpp
@@ -328,7 +328,7 @@ implicit_advance(PDE<P> &pde, kron_operators<P> &operator_matrices,
   int const degree    = pde.get_dimensions()[0].get_degree();
   int const elem_size = static_cast<int>(std::pow(degree, pde.num_dims()));
   auto const &plan    = adaptive_grid.get_distrib_plan();
-  auto const size = elem_size * adaptive_grid.get_subgrid(get_rank()).nrows();
+  auto const size     = elem_size * adaptive_grid.get_subgrid(get_rank()).nrows();
 
 #ifdef ASGARD_USE_SCALAPACK
   fk::vector<P> x(size);
@@ -964,7 +964,6 @@ imex_advance(PDE<P> &pde, kron_operators<P> &operator_matrices,
           adaptive_grid, elem_size,
           P{0.5} * pde.get_dt(), imex_flag::imex_implicit, operator_matrices,
           f_2, f, restart, max_iter, tolerance);
-
     }
     else if (solver == solve_opts::bicgstab)
     {