diff --git a/blas/impl/KokkosBlas1_axpby_impl.hpp b/blas/impl/KokkosBlas1_axpby_impl.hpp
index 1d1ba69282..bf2b7ca847 100644
--- a/blas/impl/KokkosBlas1_axpby_impl.hpp
+++ b/blas/impl/KokkosBlas1_axpby_impl.hpp
@@ -29,16 +29,16 @@ namespace Impl {
 
 template <class T>
 constexpr typename std::enable_if<Kokkos::is_view_v<T>, int>::type
-myExtent(T & v)
+axpbyVarExtent(T & v)
 {
   return v.extent(0);
 }
 
 template <class T>
 constexpr typename std::enable_if<!Kokkos::is_view_v<T>, int>::type
-myExtent(T &)
+axpbyVarExtent(T &)
 {
-  return -1;
+  return 0;
 }
   
 //
@@ -76,7 +76,7 @@ struct Axpby_Functor {
   BV m_b;
 
   Axpby_Functor(const XV& x, const YV& y, const AV& av, const BV& bv,
-                const SizeType startingColumn) // Aqui__ Not needed ???
+                const SizeType startingColumn)
       : m_x(x), m_y(y), m_a(av), m_b(bv) {
     static_assert(Kokkos::is_view<XV>::value,
                   "KokkosBlas::Impl::"
@@ -95,18 +95,16 @@ struct Axpby_Functor {
     static_assert(YV::rank == 1,
                   "KokkosBlas::Impl::Axpby_Functor: "
                   "XV and YV must have rank 1.");
-#if 1 // Aqui__ Not needed ???
     if (startingColumn != 0) {
-      if (myExtent(m_a) > 1) {
+      if (axpbyVarExtent(m_a) > 1) {
         m_a = Kokkos::subview(
             av, std::make_pair(startingColumn, SizeType(av.extent(0))));
       }
-      if (myExtent(m_b) > 1) {
+      if (axpbyVarExtent(m_b) > 1) {
         m_b = Kokkos::subview(
             bv, std::make_pair(startingColumn, SizeType(bv.extent(0))));
       }
     }
-#endif
   }
 
   KOKKOS_INLINE_FUNCTION
@@ -374,14 +372,6 @@ template <class execution_space, class AV, class XV, class BV, class YV,
 void Axpby_Generic(const execution_space& space, const AV& av, const XV& x,
                    const BV& bv, const YV& y, const SizeType startingColumn,
                    int scalar_x = 2, int scalar_y = 2) {
-  std::cout << "Entering impl.Axpby_Generic()"
-            << ": scalar_x/y = "     << scalar_x                   << "/" << scalar_y
-            << ", is_view av/bv = "  << Kokkos::is_view<AV>::value << "/" << Kokkos::is_view<BV>::value
-            << ", rank XV/YV = "     << XV::rank                   << "/" << YV::rank
-            << ", extent x/y = "     << x.extent(0)                << "/" << y.extent(0)
-            << ", extent av/bv = "   << myExtent(av)               << "/" << myExtent(bv)
-            << ", startingColumn = " << startingColumn
-            << std::endl;
   static_assert(Kokkos::is_view<XV>::value,
                 "KokkosBlas::Impl::"
                 "Axpby_Generic: X is not a Kokkos::View.");
@@ -504,11 +494,9 @@ void Axpby_Generic(const execution_space& space, const AV& av, const XV& x,
     }
 #endif  // KOKKOSBLAS_OPTIMIZATION_LEVEL_AXPBY > 2
     else { // (scalar_y == 2)
-      std::cout << "In impl.Axpby_generic(2,2): calling parallel_for(), KOKKOSBLAS_OPTIMIZATION_LEVEL_AXPBY = " << KOKKOSBLAS_OPTIMIZATION_LEVEL_AXPBY << std::endl;
       Axpby_Functor<AV, XV, BV, YV, 2, 2, SizeType> op(x, y, av, bv,
                                                        startingColumn);
       Kokkos::parallel_for("KokkosBlas::Axpby::S15", policy, op);
-      std::cout << "In impl.Axpby_generic(2,2): returned from parallel_for()" << std::endl;
     }
   }
 }
diff --git a/blas/impl/KokkosBlas1_axpby_mv_impl.hpp b/blas/impl/KokkosBlas1_axpby_mv_impl.hpp
index 109407bc8d..19bb318247 100644
--- a/blas/impl/KokkosBlas1_axpby_mv_impl.hpp
+++ b/blas/impl/KokkosBlas1_axpby_mv_impl.hpp
@@ -652,7 +652,6 @@ struct Axpby_MV_Functor<typename XMV::non_const_value_type, XMV,
   }
 };
 
-#if 1 // Needed when Invoke_Left() is corredcted and put back to work // Aqui_ (later)
 // Column-unrolled variant of Axpby_MV_Functor.  The number of columns
 // in X and Y, UNROLL, is a compile-time constant.
 template <class AV, class XMV, class BV, class YMV, int scalar_x, int scalar_y,
@@ -699,12 +698,12 @@ struct Axpby_MV_Unroll_Functor {
                   "KokkosBlas::Impl::Axpby_MV_Unroll_Functor: "
                   "BV must have rank 1.");
 
-    if (startingColumn != 0) { // Aqui__
-      if (myExtent(m_a) > 1) {
+    if (startingColumn != 0) {
+      if (axpbyVarExtent(m_a) > 1) {
         m_a = Kokkos::subview(
             av, std::make_pair(startingColumn, SizeType(av.extent(0))));
       }
-      if (myExtent(m_b) > 1) {
+      if (axpbyVarExtent(m_b) > 1) {
         m_b = Kokkos::subview(
             bv, std::make_pair(startingColumn, SizeType(bv.extent(0))));
       }
@@ -1444,7 +1443,6 @@ void Axpby_MV_Unrolled(const execution_space& space, const AV& av, const XMV& x,
     }
   }
 }
-#endif // Aqui_ (later)
 
 // Invoke the "generic" (not unrolled) multivector functor that
 // computes any of the following:
@@ -1582,7 +1580,6 @@ void Axpby_MV_Generic(const execution_space& space, const AV& av, const XMV& x,
   }
 }
 
-#if 1 // Needed when Axpby_MV_Invoke_Left() is corredcted and put back to work // Aqui_ (later)
 // Compute any of the following, in a way optimized for X and Y
 // being LayoutLeft:
 //
@@ -1607,7 +1604,6 @@ template <class execution_space, class AV, class XMV, class BV, class YMV,
 struct Axpby_MV_Invoke_Left {
   static void run(const execution_space& space, const AV& av, const XMV& x,
                   const BV& bv, const YMV& y, int scalar_x = 2, int scalar_y = 2) {
-    std::cout << "Entering mv_impl.Axpby_MV_Invoke_Left.run(): scalar_x/y = " << scalar_x << "/" << scalar_y << std::endl;
     static_assert(Kokkos::is_view<XMV>::value,
                   "KokkosBlas::Impl::"
                   "Axpby_MV_Invoke_Left: X is not a Kokkos::View.");
@@ -1627,14 +1623,12 @@ struct Axpby_MV_Invoke_Left {
                   "X and Y must have rank 2.");
 
     const SizeType numCols = x.extent(1);
-    std::cout << "In mv_impl.Axpby_MV_Invoke_Left.run(): numCols = " << numCols << std::endl;
 
     // Strip-mine by 8, then 4.  After that, do one column at a time.
     // We limit the number of strip-mine values in order to keep down
     // the amount of code to compile.
     SizeType j = 0;
     for (; j + 8 <= numCols; j += 8) {
-      std::cout << "In mv_impl.Axpby_MV_Invoke_Left.run(): 8, j = " << j << std::endl;
       XMV X_cur = Kokkos::subview(x, Kokkos::ALL(), std::make_pair(j, j + 8));
       YMV Y_cur = Kokkos::subview(y, Kokkos::ALL(), std::make_pair(j, j + 8));
 
@@ -1642,10 +1636,9 @@ struct Axpby_MV_Invoke_Left {
       // subviews of av and bv, if they are Views.  If they are scalars,
       // the functor doesn't have to do anything to them.
       Axpby_MV_Unrolled<execution_space, AV, XMV, BV, YMV, 8, SizeType>(
-          space, av, X_cur, bv, Y_cur, j, scalar_x, scalar_y); // Aqui__
+          space, av, X_cur, bv, Y_cur, j, scalar_x, scalar_y);
     }
     for (; j + 4 <= numCols; j += 4) {
-      std::cout << "In mv_impl.Axpby_MV_Invoke_Left.run(): 4, j = " << j << std::endl;
       XMV X_cur = Kokkos::subview(x, Kokkos::ALL(), std::make_pair(j, j + 4));
       YMV Y_cur = Kokkos::subview(y, Kokkos::ALL(), std::make_pair(j, j + 4));
 
@@ -1653,10 +1646,9 @@ struct Axpby_MV_Invoke_Left {
       // subviews of av and bv, if they are Views.  If they are scalars,
       // the functor doesn't have to do anything to them.
       Axpby_MV_Unrolled<execution_space, AV, XMV, BV, YMV, 4, SizeType>(
-          space, av, X_cur, bv, Y_cur, j, scalar_x, scalar_y); // Aqui__
+          space, av, X_cur, bv, Y_cur, j, scalar_x, scalar_y);
     }
     for (; j < numCols; ++j) {
-      std::cout << "In mv_impl.Axpby_MV_Invoke_Left.run(): 1, j = " << j << std::endl;
       auto x_cur = Kokkos::subview(x, Kokkos::ALL(), j);
       auto y_cur = Kokkos::subview(y, Kokkos::ALL(), j);
 
@@ -1665,22 +1657,11 @@ struct Axpby_MV_Invoke_Left {
       // the functor doesn't have to do anything to them.
       typedef decltype(x_cur) XV;
       typedef decltype(y_cur) YV;
-      //if ((myExtent(av) > 1) ||
-      //    (myExtent(bv) > 1)) {
-        Axpby_Generic<execution_space, AV, XV, BV, YV, SizeType>(
-            space, av, x_cur, bv, y_cur, j, scalar_x, scalar_y); // Aqui__
-#if 0
-      }
-      else {
-        Axpby_Generic<execution_space, AV, XV, BV, YV, SizeType>(
-            space, av, x_cur, bv, y_cur, 0, scalar_x, scalar_y); // Aqui__
-      }
-#endif
+      Axpby_Generic<execution_space, AV, XV, BV, YV, SizeType>(
+          space, av, x_cur, bv, y_cur, j, scalar_x, scalar_y);
     }
-    std::cout << "Leaving mv_impl.Axpby_MV_Invoke_Left.run()" << std::endl;
   }
 };
-#endif // Aqui_ (later)
 
 // Compute any of the following, in a way optimized for X and Y
 // being LayoutRight:
@@ -1706,7 +1687,6 @@ template <class execution_space, class AV, class XMV, class BV, class YMV,
 struct Axpby_MV_Invoke_Right {
   static void run(const execution_space& space, const AV& av, const XMV& x,
                   const BV& bv, const YMV& y, int scalar_x = 2, int scalar_y = 2) {
-    std::cout << "Entering mv_impl.Axpby_MV_Invoke_Right.run()" << std::endl;
     static_assert(Kokkos::is_view<XMV>::value,
                   "KokkosBlas::Impl::"
                   "Axpby_MV_Invoke_Right: X is not a Kokkos::View.");
diff --git a/blas/impl/KokkosBlas1_axpby_spec.hpp b/blas/impl/KokkosBlas1_axpby_spec.hpp
index b8c9afe17b..697580df2f 100644
--- a/blas/impl/KokkosBlas1_axpby_spec.hpp
+++ b/blas/impl/KokkosBlas1_axpby_spec.hpp
@@ -99,13 +99,13 @@ struct axpby_eti_spec_avail {
   template <>                                                               \
   struct axpby_eti_spec_avail<                                              \
       EXEC_SPACE,                                                           \
-      Kokkos::View<const SCALAR*, LAYOUT, /*AquiCorrection*/                \
+      Kokkos::View<const SCALAR*, LAYOUT,                                   \
                    Kokkos::Device<EXEC_SPACE, MEM_SPACE>,                   \
                    Kokkos::MemoryTraits<Kokkos::Unmanaged> >,               \
       Kokkos::View<const SCALAR**, LAYOUT,                                  \
                    Kokkos::Device<EXEC_SPACE, MEM_SPACE>,                   \
                    Kokkos::MemoryTraits<Kokkos::Unmanaged> >,               \
-      Kokkos::View<const SCALAR*, LAYOUT, /*AquiCorrection*/                \
+      Kokkos::View<const SCALAR*, LAYOUT,                                   \
                    Kokkos::Device<EXEC_SPACE, MEM_SPACE>,                   \
                    Kokkos::MemoryTraits<Kokkos::Unmanaged> >,               \
       Kokkos::View<SCALAR**, LAYOUT, Kokkos::Device<EXEC_SPACE, MEM_SPACE>, \
@@ -181,7 +181,6 @@ struct Axpby<execution_space, AV, XMV, BV, YMV, 2, false,
 
   static void axpby(const execution_space& space, const AV& av, const XMV& X,
                     const BV& bv, const YMV& Y) {
-    std::cout << "Entering spec.Axpby::axpby(case 001)" << std::endl;
     static_assert(Kokkos::is_view<XMV>::value,
                   "KokkosBlas::Impl::"
                   "Axpby<rank-2>::axpby: X is not a Kokkos::View.");
@@ -232,20 +231,18 @@ struct Axpby<execution_space, AV, XMV, BV, YMV, 2, false,
 
     if (numRows < static_cast<size_type>(INT_MAX) &&
         numRows * numCols < static_cast<size_type>(INT_MAX)) {
-      std::cout << "In spec.Axpby::axpby(case 001.1)" << std::endl;
       using index_type = int;
       using Axpby_MV_Invoke_Layout = typename
-        std::conditional< std::is_same< typename XMV::array_layout, Kokkos::LayoutLeft >::value // AquiCorrection
-                        , Axpby_MV_Invoke_Left<execution_space, AV, XMV, BV, YMV, index_type> // Aqui ???
+        std::conditional< std::is_same< typename XMV::array_layout, Kokkos::LayoutLeft >::value
+                        , Axpby_MV_Invoke_Left<execution_space, AV, XMV, BV, YMV, index_type>
                         , Axpby_MV_Invoke_Right<execution_space, AV, XMV, BV, YMV, index_type>
                         >::type;
       Axpby_MV_Invoke_Layout::run(space, av, X, bv, Y, a, b);
     } else {
-      std::cout << "In spec.Axpby::axpby(case 001.2)" << std::endl;
       using index_type = typename XMV::size_type;
       using Axpby_MV_Invoke_Layout = typename
-        std::conditional< std::is_same<typename XMV::array_layout, Kokkos::LayoutLeft>::value // AquiCorrection
-                        , Axpby_MV_Invoke_Left<execution_space, AV, XMV, BV, YMV, index_type> // Aqui ???
+        std::conditional< std::is_same<typename XMV::array_layout, Kokkos::LayoutLeft>::value
+                        , Axpby_MV_Invoke_Left<execution_space, AV, XMV, BV, YMV, index_type>
                         , Axpby_MV_Invoke_Right<execution_space, AV, XMV, BV, YMV, index_type>
                         >::type;
       Axpby_MV_Invoke_Layout::run(space, av, X, bv, Y, a, b);
@@ -273,7 +270,6 @@ struct Axpby<execution_space, typename XMV::non_const_value_type, XMV,
 
   static void axpby(const execution_space& space, const AV& alpha, const XMV& X,
                     const BV& beta, const YMV& Y) {
-    std::cout << "Entering spec.Axpby::axpby(case 002)" << std::endl;
     static_assert(Kokkos::is_view<XMV>::value,
                   "KokkosBlas::Impl::Axpby::axpby (MV): "
                   "X is not a Kokkos::View.");
@@ -339,20 +335,18 @@ struct Axpby<execution_space, typename XMV::non_const_value_type, XMV,
 
     if (numRows < static_cast<size_type>(INT_MAX) &&
         numRows * numCols < static_cast<size_type>(INT_MAX)) {
-      std::cout << "In spec.Axpby::axpby(case 002.1)" << std::endl;
       using index_type = int;
       using Axpby_MV_Invoke_Layout = typename
-        std::conditional< std::is_same<typename XMV::array_layout, Kokkos::LayoutLeft>::value // AquiCorrection
-                        , Axpby_MV_Invoke_Left<execution_space, AV, XMV, BV, YMV, index_type> // Aqui ???
+        std::conditional< std::is_same<typename XMV::array_layout, Kokkos::LayoutLeft>::value
+                        , Axpby_MV_Invoke_Left<execution_space, AV, XMV, BV, YMV, index_type>
                         , Axpby_MV_Invoke_Right<execution_space, AV, XMV, BV, YMV, index_type>
                         >::type;
       Axpby_MV_Invoke_Layout::run(space, alpha, X, beta, Y, a, b);
     } else {
-      std::cout << "In spec.Axpby::axpby(case 002.2)" << std::endl;
       using index_type = typename XMV::size_type;
       using Axpby_MV_Invoke_Layout = typename
-        std::conditional< std::is_same<typename XMV::array_layout, Kokkos::LayoutLeft>::value // AquiCorrection
-                        , Axpby_MV_Invoke_Left<execution_space, AV, XMV, BV, YMV, index_type> // Aqui ???
+        std::conditional< std::is_same<typename XMV::array_layout, Kokkos::LayoutLeft>::value
+                        , Axpby_MV_Invoke_Left<execution_space, AV, XMV, BV, YMV, index_type>
                         , Axpby_MV_Invoke_Right<execution_space, AV, XMV, BV, YMV, index_type>
                         >::type;
       Axpby_MV_Invoke_Layout::run(space, alpha, X, beta, Y, a, b);
@@ -375,7 +369,6 @@ struct Axpby<execution_space, AV, XV, BV, YV, 1, false,
 
   static void axpby(const execution_space& space, const AV& av, const XV& X,
                     const BV& bv, const YV& Y) {
-    std::cout << "Entering spec.Axpby::axpby(case 003)" << std::endl;
     Kokkos::Profiling::pushRegion(KOKKOSKERNELS_IMPL_COMPILE_LIBRARY
                                       ? "KokkosBlas::axpby[ETI]"
                                       : "KokkosBlas::axpby[noETI]");
@@ -393,12 +386,10 @@ struct Axpby<execution_space, AV, XV, BV, YV, 1, false,
     }
 
     if (numRows < static_cast<size_type>(INT_MAX)) {
-      std::cout << "In spec.Axpby::axpby(case 003.1)" << std::endl;
       using index_type = int;
       Axpby_Generic<execution_space, AV, XV, BV, YV, index_type>(
         space, av, X, bv, Y, 0, a, b);
     } else {
-      std::cout << "In spec.Axpby::axpby(case 003.2)" << std::endl;
       using index_type = typename XV::size_type;
       Axpby_Generic<execution_space, AV, XV, BV, YV, index_type>(
         space, av, X, bv, Y, 0, a, b);
@@ -427,7 +418,6 @@ struct Axpby<execution_space, typename XV::non_const_value_type, XV,
 
   static void axpby(const execution_space& space, const AV& alpha, const XV& X,
                     const BV& beta, const YV& Y) {
-    std::cout << "Entering spec.Axpby::axpby(case 004)" << std::endl;
     static_assert(Kokkos::is_view<XV>::value,
                   "KokkosBlas::Impl::"
                   "Axpby<rank-1>::axpby: X is not a Kokkos::View.");
@@ -491,13 +481,11 @@ struct Axpby<execution_space, typename XV::non_const_value_type, XV,
 #endif  // KOKKOSBLAS_OPTIMIZATION_LEVEL_AXPBY > 2
 
     if (numRows < static_cast<size_type>(INT_MAX)) {
-      std::cout << "In spec.Axpby::axpby(case 004.1)" << std::endl;
       using index_type = int;
       Axpby_Generic<execution_space, typename XV::non_const_value_type, XV,
                     typename YV::non_const_value_type, YV, index_type>(
           space, alpha, X, beta, Y, 0, a, b);
     } else {
-      std::cout << "In spec.Axpby::axpby(case 004.2)" << std::endl;
       using index_type = typename XV::size_type;
       Axpby_Generic<execution_space, typename XV::non_const_value_type, XV,
                     typename YV::non_const_value_type, YV, index_type>(
diff --git a/blas/impl/KokkosBlas1_axpby_unification_attempt_impl.hpp b/blas/impl/KokkosBlas1_axpby_unification_attempt_impl.hpp
index df7e741309..aeaf8213ce 100644
--- a/blas/impl/KokkosBlas1_axpby_unification_attempt_impl.hpp
+++ b/blas/impl/KokkosBlas1_axpby_unification_attempt_impl.hpp
@@ -25,7 +25,7 @@ namespace Impl {
 // --------------------------------
 
 template <class tExecSpace>
-constexpr int atHostOrDev() {
+constexpr int atHostOrDev() { // Aqui__
 
 #ifdef KOKKOS_ENABLE_SERIAL
   constexpr bool exec_is_serial = std::is_same_v<tExecSpace, Kokkos::Serial>;
diff --git a/blas/unit_test/Test_Blas1_axpby_unification.hpp b/blas/unit_test/Test_Blas1_axpby_unification.hpp
index 7464139377..7bccdbc704 100644
--- a/blas/unit_test/Test_Blas1_axpby_unification.hpp
+++ b/blas/unit_test/Test_Blas1_axpby_unification.hpp
@@ -737,20 +737,18 @@ void impl_test_axpby_unification(int const N) {
 
 template <class tScalarA, class tLayoutAX, class tScalarB, class tLayoutBY, class Device>
 void impl_test_axpby_mv_unification(int const N, int const K) {
-#if 1 // Aqui
   using ViewTypeAr0    = Kokkos::View<tScalarA,                   tLayoutAX, Device>;
   using ViewTypeAr1s_1 = Kokkos::View<tScalarA[1],                tLayoutAX, Device>;
   using ViewTypeAr1s_k = Kokkos::View<tScalarA[numVecsAxpbyTest], tLayoutAX, Device>; // Yes, hard coded
   using ViewTypeAr1d   = Kokkos::View<tScalarA*,                  tLayoutAX, Device>;
-#endif
+
   using ViewTypeX      = Kokkos::View<tScalarA**,                 tLayoutAX, Device>;
 
   using ViewTypeBr0    = Kokkos::View<tScalarB,                   tLayoutBY, Device>;
   using ViewTypeBr1s_1 = Kokkos::View<tScalarB[1],                tLayoutBY, Device>;
-#if 1
   using ViewTypeBr1s_k = Kokkos::View<tScalarB[numVecsAxpbyTest], tLayoutBY, Device>; // Yes, hard coded
   using ViewTypeBr1d   = Kokkos::View<tScalarB*,                  tLayoutBY, Device>;
-#endif
+
   using ViewTypeY      = Kokkos::View<tScalarB**,                 tLayoutBY, Device>;
 
   std::array<tScalarA,4> const valuesA{-1,0,1,3};
@@ -765,11 +763,10 @@ void impl_test_axpby_mv_unification(int const N, int const K) {
                                                       + Kokkos::ArithTraits<tScalarB>::abs(valuesB[valuesB.size()-1])
                                                       ) * max_val * eps;
 
-#if 1
   // ************************************************************
   // Case 01/36: Ascalar + Bscalar
   // ************************************************************
-  std::cout << "Starting case 01/36" << std::endl;
+  //std::cout << "Starting case 01/36" << std::endl;
   for (size_t i(0); i < valuesA.size(); ++i) {
     tScalarA const valueA( valuesA[i] );
     for (size_t j(0); j < valuesB.size(); ++j) {
@@ -797,7 +794,7 @@ void impl_test_axpby_mv_unification(int const N, int const K) {
   // ************************************************************
   // Case 02/36: Ascalar + Br0
   // ************************************************************
-  std::cout << "Starting case 02/36" << std::endl;
+  //std::cout << "Starting case 02/36" << std::endl;
   for (size_t i(0); i < valuesA.size(); ++i) {
     tScalarA const valueA( valuesA[i] );
     for (size_t j(0); j < valuesB.size(); ++j) {
@@ -821,12 +818,11 @@ void impl_test_axpby_mv_unification(int const N, int const K) {
       }
     }
   }
-#endif
 
   // ************************************************************
   // Case 03/36: Ascalar + Br1s_1
   // ************************************************************
-  std::cout << "Starting case 03/36" << std::endl;
+  //std::cout << "Starting case 03/36" << std::endl;
   for (size_t i(0); i < valuesA.size(); ++i) {
     tScalarA const valueA( valuesA[i] );
     for (size_t j(0); j < valuesB.size(); ++j) {
@@ -837,7 +833,6 @@ void impl_test_axpby_mv_unification(int const N, int const K) {
         view_stride_adapter<ViewTypeBr1s_1> b("B", 1);
         view_stride_adapter<ViewTypeY     > y("Y", N, K);
 
-        std::cout << "Starting case 03/36, i = " << i << ", j = " << j << std::endl;
         a = valueA;
         Kokkos::deep_copy(b.d_base, valueB);
         impl_test_axpby_mv_unification_compare< tScalarA
@@ -852,11 +847,10 @@ void impl_test_axpby_mv_unification(int const N, int const K) {
     }
   }
 
-#if 1 // Aqui_
   // ************************************************************
   // Case 04/36: Ascalar + Br1s_k
   // ************************************************************
-  std::cout << "Starting case 04/36" << std::endl;
+  //std::cout << "Starting case 04/36" << std::endl;
   for (size_t i(0); i < valuesA.size(); ++i) {
     tScalarA const valueA( valuesA[i] );
     for (size_t j(0); j < valuesB.size(); ++j) {
@@ -887,7 +881,7 @@ void impl_test_axpby_mv_unification(int const N, int const K) {
   // ************************************************************
   // Case 05/36: Ascalar + Br1d,1
   // ************************************************************
-  std::cout << "Starting case 05/36" << std::endl;
+  //std::cout << "Starting case 05/36" << std::endl;
   for (size_t i(0); i < valuesA.size(); ++i) {
     tScalarA const valueA( valuesA[i] );
     for (size_t j(0); j < valuesB.size(); ++j) {
@@ -915,7 +909,7 @@ void impl_test_axpby_mv_unification(int const N, int const K) {
   // ************************************************************
   // Case 06/36: Ascalar + Br1d,m
   // ************************************************************
-  std::cout << "Starting case 06/36" << std::endl;
+  //std::cout << "Starting case 06/36" << std::endl;
   for (size_t i(0); i < valuesA.size(); ++i) {
     tScalarA const valueA( valuesA[i] );
     for (size_t j(0); j < valuesB.size(); ++j) {
@@ -946,7 +940,7 @@ void impl_test_axpby_mv_unification(int const N, int const K) {
   // ************************************************************
   // Case 07/36: Ar0 + Bscalar
   // ************************************************************w
-  std::cout << "Starting case 07/36" << std::endl;
+  //std::cout << "Starting case 07/36" << std::endl;
   for (size_t i(0); i < valuesA.size(); ++i) {
     tScalarA const valueA( valuesA[i] );
     for (size_t j(0); j < valuesB.size(); ++j) {
@@ -974,7 +968,7 @@ void impl_test_axpby_mv_unification(int const N, int const K) {
   // ************************************************************
   // Case 08/36: Ar0 + Br0
   // ************************************************************
-  std::cout << "Starting case 08/36" << std::endl;
+  //std::cout << "Starting case 08/36" << std::endl;
   for (size_t i(0); i < valuesA.size(); ++i) {
     tScalarA const valueA( valuesA[i] );
     for (size_t j(0); j < valuesB.size(); ++j) {
@@ -1002,7 +996,7 @@ void impl_test_axpby_mv_unification(int const N, int const K) {
   // ************************************************************
   // Case 09/36: Ar0 + Br1s_1
   // ************************************************************
-  std::cout << "Starting case 09/36" << std::endl;
+  //std::cout << "Starting case 09/36" << std::endl;
   for (size_t i(0); i < valuesA.size(); ++i) {
     tScalarA const valueA( valuesA[i] );
     for (size_t j(0); j < valuesB.size(); ++j) {
@@ -1030,7 +1024,7 @@ void impl_test_axpby_mv_unification(int const N, int const K) {
   // ************************************************************
   // Case 10/36: Ar0 + Br1s_k
   // ************************************************************
-  std::cout << "Starting case 10/36" << std::endl;
+  //std::cout << "Starting case 10/36" << std::endl;
   for (size_t i(0); i < valuesA.size(); ++i) {
     tScalarA const valueA( valuesA[i] );
     for (size_t j(0); j < valuesB.size(); ++j) {
@@ -1061,7 +1055,7 @@ void impl_test_axpby_mv_unification(int const N, int const K) {
   // ************************************************************
   // Case 11/36: Ar0 + Br1d,1
   // ************************************************************
-  std::cout << "Starting case 11/36" << std::endl;
+  //std::cout << "Starting case 11/36" << std::endl;
   for (size_t i(0); i < valuesA.size(); ++i) {
     tScalarA const valueA( valuesA[i] );
     for (size_t j(0); j < valuesB.size(); ++j) {
@@ -1089,7 +1083,7 @@ void impl_test_axpby_mv_unification(int const N, int const K) {
   // ************************************************************
   // Case 12/36: Ar0 + Br1d,m
   // ************************************************************
-  std::cout << "Starting case 12/36" << std::endl;
+  //std::cout << "Starting case 12/36" << std::endl;
   for (size_t i(0); i < valuesA.size(); ++i) {
     tScalarA const valueA( valuesA[i] );
     for (size_t j(0); j < valuesB.size(); ++j) {
@@ -1120,7 +1114,7 @@ void impl_test_axpby_mv_unification(int const N, int const K) {
   // ************************************************************
   // Case 13/36: Ar1s_1 + Bscalar
   // ************************************************************w
-  std::cout << "Starting case 13/36" << std::endl;
+  //std::cout << "Starting case 13/36" << std::endl;
   for (size_t i(0); i < valuesA.size(); ++i) {
     tScalarA const valueA( valuesA[i] );
     for (size_t j(0); j < valuesB.size(); ++j) {
@@ -1148,7 +1142,7 @@ void impl_test_axpby_mv_unification(int const N, int const K) {
   // ************************************************************
   // Case 14/36: Ar1s_1 + Br0
   // ************************************************************
-  std::cout << "Starting case 14/36" << std::endl;
+  //std::cout << "Starting case 14/36" << std::endl;
   for (size_t i(0); i < valuesA.size(); ++i) {
     tScalarA const valueA( valuesA[i] );
     for (size_t j(0); j < valuesB.size(); ++j) {
@@ -1176,7 +1170,7 @@ void impl_test_axpby_mv_unification(int const N, int const K) {
   // ************************************************************
   // Case 15/36: Ar1s_1 + Br1s_1
   // ************************************************************
-  std::cout << "Starting case 15/36" << std::endl;
+  //std::cout << "Starting case 15/36" << std::endl;
   for (size_t i(0); i < valuesA.size(); ++i) {
     tScalarA const valueA( valuesA[i] );
     for (size_t j(0); j < valuesB.size(); ++j) {
@@ -1204,7 +1198,7 @@ void impl_test_axpby_mv_unification(int const N, int const K) {
   // ************************************************************
   // Case 16/36: Ar1s_1 + Br1s_k
   // ************************************************************
-  std::cout << "Starting case 16/36" << std::endl;
+  //std::cout << "Starting case 16/36" << std::endl;
   for (size_t i(0); i < valuesA.size(); ++i) {
     tScalarA const valueA( valuesA[i] );
     for (size_t j(0); j < valuesB.size(); ++j) {
@@ -1235,7 +1229,7 @@ void impl_test_axpby_mv_unification(int const N, int const K) {
   // ************************************************************
   // Case 17/36: Ar1s_1 + Br1d,1
   // ************************************************************
-  std::cout << "Starting case 17/36" << std::endl;
+  //std::cout << "Starting case 17/36" << std::endl;
   for (size_t i(0); i < valuesA.size(); ++i) {
     tScalarA const valueA( valuesA[i] );
     for (size_t j(0); j < valuesB.size(); ++j) {
@@ -1263,7 +1257,7 @@ void impl_test_axpby_mv_unification(int const N, int const K) {
   // ************************************************************
   // Case 18/36: Ar1s_1 + Br1d,m
   // ************************************************************
-  std::cout << "Starting case 18/36" << std::endl;
+  //std::cout << "Starting case 18/36" << std::endl;
   for (size_t i(0); i < valuesA.size(); ++i) {
     tScalarA const valueA( valuesA[i] );
     for (size_t j(0); j < valuesB.size(); ++j) {
@@ -1294,7 +1288,7 @@ void impl_test_axpby_mv_unification(int const N, int const K) {
   // ************************************************************
   // Case 19/36: Ar1s_k + Bscalar
   // ************************************************************
-  std::cout << "Starting case 19/36" << std::endl;
+  //std::cout << "Starting case 19/36" << std::endl;
   for (size_t i(0); i < valuesA.size(); ++i) {
     tScalarA const valueA( valuesA[i] );
     for (size_t j(0); j < valuesB.size(); ++j) {
@@ -1325,7 +1319,7 @@ void impl_test_axpby_mv_unification(int const N, int const K) {
   // ************************************************************
   // Case 20/36: Ar1s_k + Br0
   // ************************************************************
-  std::cout << "Starting case 20/36" << std::endl;
+  //std::cout << "Starting case 20/36" << std::endl;
   for (size_t i(0); i < valuesA.size(); ++i) {
     tScalarA const valueA( valuesA[i] );
     for (size_t j(0); j < valuesB.size(); ++j) {
@@ -1356,7 +1350,7 @@ void impl_test_axpby_mv_unification(int const N, int const K) {
   // ************************************************************
   // Case 21/36: Ar1s_k + Br1s_1
   // ************************************************************
-  std::cout << "Starting case 21/36" << std::endl;
+  //std::cout << "Starting case 21/36" << std::endl;
   for (size_t i(0); i < valuesA.size(); ++i) {
     tScalarA const valueA( valuesA[i] );
     for (size_t j(0); j < valuesB.size(); ++j) {
@@ -1387,7 +1381,7 @@ void impl_test_axpby_mv_unification(int const N, int const K) {
   // ************************************************************
   // Case 22/36: Ar1s_k + Br1s_k
   // ************************************************************
-  std::cout << "Starting case 22/36" << std::endl;
+  //std::cout << "Starting case 22/36" << std::endl;
   for (size_t i(0); i < valuesA.size(); ++i) {
     tScalarA const valueA( valuesA[i] );
     for (size_t j(0); j < valuesB.size(); ++j) {
@@ -1421,7 +1415,7 @@ void impl_test_axpby_mv_unification(int const N, int const K) {
   // ************************************************************
   // Case 23/36: Ar1s_k + Br1d,1
   // ************************************************************
-  std::cout << "Starting case 23/36" << std::endl;
+  //std::cout << "Starting case 23/36" << std::endl;
   for (size_t i(0); i < valuesA.size(); ++i) {
     tScalarA const valueA( valuesA[i] );
     for (size_t j(0); j < valuesB.size(); ++j) {
@@ -1452,7 +1446,7 @@ void impl_test_axpby_mv_unification(int const N, int const K) {
   // ************************************************************
   // Case 24/36: Ar1s_k + Br1d,m
   // ************************************************************
-  std::cout << "Starting case 24/36" << std::endl;
+  //std::cout << "Starting case 24/36" << std::endl;
   for (size_t i(0); i < valuesA.size(); ++i) {
     tScalarA const valueA( valuesA[i] );
     for (size_t j(0); j < valuesB.size(); ++j) {
@@ -1484,9 +1478,9 @@ void impl_test_axpby_mv_unification(int const N, int const K) {
   }
 
   // ************************************************************
-  // Case 2numVecsAxpbyTest/36: Ar1d,1 + Bscalar
+  // Case 25/36: Ar1d,1 + Bscalar
   // ************************************************************w
-  std::cout << "Starting case 25/36" << std::endl;
+  //std::cout << "Starting case 25/36" << std::endl;
   for (size_t i(0); i < valuesA.size(); ++i) {
     tScalarA const valueA( valuesA[i] );
     for (size_t j(0); j < valuesB.size(); ++j) {
@@ -1514,7 +1508,7 @@ void impl_test_axpby_mv_unification(int const N, int const K) {
   // ************************************************************
   // Case 26/36: Ar1d,1 + Br0
   // ************************************************************
-  std::cout << "Starting case 26/36" << std::endl;
+  //std::cout << "Starting case 26/36" << std::endl;
   for (size_t i(0); i < valuesA.size(); ++i) {
     tScalarA const valueA( valuesA[i] );
     for (size_t j(0); j < valuesB.size(); ++j) {
@@ -1542,7 +1536,7 @@ void impl_test_axpby_mv_unification(int const N, int const K) {
   // ************************************************************
   // Case 27/36: Ar1d,1 + Br1s_1
   // ************************************************************
-  std::cout << "Starting case 27/36" << std::endl;
+  //std::cout << "Starting case 27/36" << std::endl;
   for (size_t i(0); i < valuesA.size(); ++i) {
     tScalarA const valueA( valuesA[i] );
     for (size_t j(0); j < valuesB.size(); ++j) {
@@ -1570,7 +1564,7 @@ void impl_test_axpby_mv_unification(int const N, int const K) {
   // ************************************************************
   // Case 28/36: Ar1d,1 + Br1s_k
   // ************************************************************
-  std::cout << "Starting case 28/36" << std::endl;
+  //std::cout << "Starting case 28/36" << std::endl;
   for (size_t i(0); i < valuesA.size(); ++i) {
     tScalarA const valueA( valuesA[i] );
     for (size_t j(0); j < valuesB.size(); ++j) {
@@ -1601,7 +1595,7 @@ void impl_test_axpby_mv_unification(int const N, int const K) {
   // ************************************************************
   // Case 29/36: Ar1d,1 + Br1d,1
   // ************************************************************
-  std::cout << "Starting case 29/36" << std::endl;
+  //std::cout << "Starting case 29/36" << std::endl;
   for (size_t i(0); i < valuesA.size(); ++i) {
     tScalarA const valueA( valuesA[i] );
     for (size_t j(0); j < valuesB.size(); ++j) {
@@ -1629,7 +1623,7 @@ void impl_test_axpby_mv_unification(int const N, int const K) {
   // ************************************************************
   // Case 30/36: Ar1d,1 + Br1d,m
   // ************************************************************
-  std::cout << "Starting case 30/36" << std::endl;
+  //std::cout << "Starting case 30/36" << std::endl;
   for (size_t i(0); i < valuesA.size(); ++i) {
     tScalarA const valueA( valuesA[i] );
     for (size_t j(0); j < valuesB.size(); ++j) {
@@ -1660,7 +1654,7 @@ void impl_test_axpby_mv_unification(int const N, int const K) {
   // ************************************************************
   // Case 31/36: Ar1d,m + Bscalar
   // ************************************************************w
-  std::cout << "Starting case 31/36" << std::endl;
+  //std::cout << "Starting case 31/36" << std::endl;
   for (size_t i(0); i < valuesA.size(); ++i) {
     tScalarA const valueA( valuesA[i] );
     for (size_t j(0); j < valuesB.size(); ++j) {
@@ -1691,7 +1685,7 @@ void impl_test_axpby_mv_unification(int const N, int const K) {
   // ************************************************************
   // Case 32/36: Ar1d,m + Br0
   // ************************************************************
-  std::cout << "Starting case 32/36" << std::endl;
+  //std::cout << "Starting case 32/36" << std::endl;
   for (size_t i(0); i < valuesA.size(); ++i) {
     tScalarA const valueA( valuesA[i] );
     for (size_t j(0); j < valuesB.size(); ++j) {
@@ -1722,7 +1716,7 @@ void impl_test_axpby_mv_unification(int const N, int const K) {
   // ************************************************************
   // Case 33/36: Ar1d,m + Br1s_1
   // ************************************************************
-  std::cout << "Starting case 33/36" << std::endl;
+  //std::cout << "Starting case 33/36" << std::endl;
   for (size_t i(0); i < valuesA.size(); ++i) {
     tScalarA const valueA( valuesA[i] );
     for (size_t j(0); j < valuesB.size(); ++j) {
@@ -1753,7 +1747,7 @@ void impl_test_axpby_mv_unification(int const N, int const K) {
   // ************************************************************
   // Case 34/36: Ar1d,m + Br1s_k
   // ************************************************************
-  std::cout << "Starting case 34/36" << std::endl;
+  //std::cout << "Starting case 34/36" << std::endl;
   for (size_t i(0); i < valuesA.size(); ++i) {
     tScalarA const valueA( valuesA[i] );
     for (size_t j(0); j < valuesB.size(); ++j) {
@@ -1787,7 +1781,7 @@ void impl_test_axpby_mv_unification(int const N, int const K) {
   // ************************************************************
   // Case 35/36: Ar1d,m + Br1d,1
   // ************************************************************
-  std::cout << "Starting case 35/36" << std::endl;
+  //std::cout << "Starting case 35/36" << std::endl;
   for (size_t i(0); i < valuesA.size(); ++i) {
     tScalarA const valueA( valuesA[i] );
     for (size_t j(0); j < valuesB.size(); ++j) {
@@ -1818,7 +1812,7 @@ void impl_test_axpby_mv_unification(int const N, int const K) {
   // ************************************************************
   // Case 36/36: Ar1d,m + Br1d,m
   // ************************************************************
-  std::cout << "Starting case 36/36" << std::endl;
+  //std::cout << "Starting case 36/36" << std::endl;
   for (size_t i(0); i < valuesA.size(); ++i) {
     tScalarA const valueA( valuesA[i] );
     for (size_t j(0); j < valuesB.size(); ++j) {
@@ -1848,7 +1842,6 @@ void impl_test_axpby_mv_unification(int const N, int const K) {
       }
     }
   }
-#endif // Aqui_
 }
 
 }  // namespace Test